Video Pipeline Bundle

• Outcome: Review
• Latest audit: Sep 11, 2026 · 1:21 AM UTC
• Version: 1.0.2

Overview

This video workflow is not clearly malicious, but it needs review because it can modify the Python environment and contains command-execution flaws around user-controlled paths.

Install only after reviewing the scripts. Prefer an isolated virtual environment or container, do not process untrusted filenames or directories, disable notifications unless needed, avoid passing API keys on the command line, and be aware that transcription correction sends text to the selected LLM provider.

A.I.G

Vulnerability Patterns

• Insecure Dependencies: Introduces malicious components through unsafe dependency sources
• Insecure Skill Coding Practices: Finds exploitable flaws such as hardcoded secrets or command injection
• Skill Instruction Hijacking: Alters the agent's session goals or safety constraints when the skill loads
• Agent Memory Poisoning: Writes attacker-controlled rules into memory that affect later sessions
• Remote Payload Retrieval and Execution: Fetches external code whose behavior can change after review

Findings (3)

T08 · Insecure Dependencies

Error

• Location: scripts/video_to_text.py:39

Finding

Automatic Installation of Unpinned Packages into the System Python Environment

Content

View full analysis

Vulnerability Details

File Locations:

• scripts/video_to_text.py:39-52
• scripts/video_clip.py:17-32

Vulnerability Type: Automatic unpinned dependency installation and supply-chain exposure
Risk Level: High

Vulnerable Code

From scripts/video_to_text.py:

python

def check_dependencies():
    """检查并安装依赖"""
    print("🔍 检查依赖...")
    
    deps = ["faster-whisper", "requests"]
    for dep in deps:
        try:
            __import__(dep.replace("-", "_"))
            print(f"  ✅ {dep} 已安装")
        except ImportError:
            print(f"  📦 正在安装 {dep}...")
            try:
                subprocess.run([sys.executable, "-m", "pip", "install", dep, "--break-system-packages"], 
                           capture_output=True)
                print(f"  ✅ {dep} 安装完成")
            except Exception as e:
                print(f"  ❌ {dep} 安装失败: {e}")
                return False

From scripts/video_clip.py:

python

def check_dependencies():
    """检查并安装依赖"""
    print("🔍 检查依赖...")
    
    # 检查 auto-editor
    result = subprocess.run(["which", "auto-editor"], capture_output=True)
    if result.returncode != 0:
        print("📦 正在安装 auto-editor...")
        try:
            subprocess.run([sys.executable, "-m", "pip", "install", "auto-editor", "--break-system-packages"], 
                         capture_output=True)
            print("  ✅ auto-editor 安装完成")
        except Exception as e:
            print(f"  ❌ auto-editor 安装失败: {e}")
            return False
    else:
        print("  ✅ auto-editor 已安装")
    return True

Technical Analysis

The scripts automatically install faster-whisper, requests, or auto-editor when an import or executable check fails. No package versions or cryptographic hashes are pinned, so the package content installed during one invocation may differ from the content installed during another invocation.

Python package installation can execute package build and installation logic. Conseque ...[truncated 2722 chars]

Remediation

View remediation

Remediation Suggestions

1. Remove all automatic pip installation from normal execution paths.
2. If a dependency is missing, terminate with a clear error and provide a separate, user-controlled setup procedure.
3. Install dependencies only inside a dedicated virtual environment or container.
4. Pin direct and transitive dependency versions in a lock file.
5. Require cryptographic hashes, such as through pip install --require-hashes -r requirements.txt.
6. Remove --break-system-packages; do not modify an externally managed Python environment.
7. Review and approve package sources and configure pip to use a trusted registry.
8. Record tested dependency versions in the documentation.
9. Check subprocess return codes and report installation failure accurately if a separate installer is retained.
10. Update SKILL.md so its dependency-installation description accurately distinguishes informational setup commands from executable installation behavior.

T09 · Insecure Skill Coding Practices

Error

• Location: scripts/pipeline.py:205

Finding

Shell Command Injection Through User-Controlled Paths and Filenames

Content

View full analysis

Vulnerability Details

File Locations:

• scripts/pipeline.py:205-209
• scripts/pipeline.py:223-230
• scripts/pipeline.py:260-264
• scripts/pipeline.py:313-314
• scripts/pipeline.py:327-328

Vulnerability Type: Operating-system command injection
Risk Level: High

Vulnerable Code

The pipeline constructs shell command strings using input and output paths:

python

# 执行剪辑 - 使用本地脚本
script_dir = os.path.dirname(os.path.abspath(__file__))
cmd = f'python3 "{script_dir}/video_clip.py" --input "{input_dir}" --output "{output_dir}" --target "" '
send("▶️ 开始剪辑...")

result = subprocess.run(cmd, shell=True, capture_output=True, text=True)

The concatenation step repeats this pattern:

python

# 创建文件列表
list_file = "/tmp/concat_list.txt"
with open(list_file, "w") as f:
    for v in videos:
        f.write(f"file '{v['path']}'\n")

send("▶️ 开始拼接...")
cmd = f'ffmpeg -f concat -safe 0 -i "{list_file}" -c copy -y "{output_file}"'
result = subprocess.run(cmd, shell=True, capture_output=True, text=True)

The transcription step also invokes a generated shell command:

python

# 执行转写 - 使用本地脚本
script_dir = os.path.dirname(os.path.abspath(__file__))
cmd = f'python3 "{script_dir}/video_to_text.py" --input "{os.path.dirname(video_path)}" --output "{output_dir}" --model small --target "" '
send("▶️ 开始转写...")

result = subprocess.run(cmd, shell=True, capture_output=True, text=True)

Subtitle-burning commands interpolate discovered video and subtitle paths into shell syntax:

python

cmd = f'ffmpeg -i "{v["path"]}" -vf "subtitles=\'{subtitle_file}\'" -c:a copy -y "{output_path}"'
result = subprocess.run(cmd, shell=True, capture_output=True, text=True)

The merged-video branch contains the same pattern:

python

cmd = f'ffmpeg -i "{v["path"]}" -vf "subtitles=\'{subtitle_file}\'" -c:a copy -y "{output_path}"'
result = subprocess.run(cmd, shell=True, capture_output=True, text=True)

Technical Analysis

`subprocess.run(..., shell=Tru ...[truncated 3073 chars]

Remediation

View remediation

Remediation Suggestions

1. Remove shell=True from every pipeline subprocess invocation.
2. Pass each command and argument as a list:

python

subprocess.run(
    [
        sys.executable,
        os.path.join(script_dir, "video_clip.py"),
        "--input",
        input_dir,
        "--output",
        output_dir,
        "--target",
        "",
    ],
    capture_output=True,
    text=True,
    check=True,
)

3. Invoke FFmpeg in the same manner:

python

subprocess.run(
    [
        "ffmpeg",
        "-f",
        "concat",
        "-safe",
        "0",
        "-i",
        list_file,
        "-c",
        "copy",
        "-y",
        output_file,
    ],
    capture_output=True,
    text=True,
    check=True,
)

4. Construct subtitle-filter arguments as a single list element without passing them through a shell.
5. Validate that input and output paths resolve to intended directories, but do not rely on validation or manual shell escaping as a substitute for shell=False.
6. Test paths containing spaces, quotes, dollar signs, parentheses, semicolons, Unicode characters, and newlines.
7. Use sys.executable rather than the literal python3 so child scripts run in the expected Python environment.
8. Check subprocess return codes or use check=True, and fail safely when a child process does not complete successfully.

T09 · Insecure Skill Coding Practices

Warning

• Location: scripts/pipeline.py:223

Finding

Predictable Shared Temporary File Enables Symlink and Race Attacks

Content

View full analysis

Vulnerability Details

File Locations:

• scripts/pipeline.py:223-231
• scripts/ffmpeg_tools.py:79-91

Vulnerability Type: Insecure temporary-file creation and time-of-check/time-of-use race
Risk Level: Medium

Vulnerable Code

From scripts/pipeline.py:

python

# 创建文件列表
list_file = "/tmp/concat_list.txt"
with open(list_file, "w") as f:
    for v in videos:
        f.write(f"file '{v['path']}'\n")

send("▶️ 开始拼接...")
cmd = f'ffmpeg -f concat -safe 0 -i "{list_file}" -c copy -y "{output_file}"'
result = subprocess.run(cmd, shell=True, capture_output=True, text=True)

os.remove(list_file)

From scripts/ffmpeg_tools.py:

python

# 创建临时文件列表
list_file = "/tmp/concat_list.txt"
with open(list_file, "w") as f:
    for vf in video_files:
        f.write(f"file '{vf}'\n")

send_message(f"🔗 开始拼接 {len(video_files)} 个视频...")

cmd = ["ffmpeg", "-f", "concat", "-safe", "0", "-i", list_file, "-c", "copy", "-y", output_file]

process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)

Technical Analysis

Both implementations use the same predictable path, /tmp/concat_list.txt, in a commonly shared temporary directory. The file is opened using normal write mode without exclusive creation, symlink checks, randomized naming, restrictive permission handling, or ownership verification.

On systems where /tmp is shared among users, another local process can pre-create that path as a symbolic link. Opening it with "w" follows the link and truncates the linked target if the invoking user has permission. Another process can also modify or replace the file after it is written but before FFmpeg reads it, producing a time-of-check/time-of-use race.

Concurrent legitimate Skill invocations also interfere with each other because both jobs overwrite and remove the same file. One process may cause another process to concatenate an incorrect set of videos or fail when the shared file is removed.

The concat-file co ...[truncated 2040 chars]

Remediation

View remediation

Remediation Suggestions

1. Create a unique temporary file with Python’s tempfile module:

python

import tempfile

list_path = None
try:
    with tempfile.NamedTemporaryFile(
        mode="w",
        encoding="utf-8",
        prefix="video_concat_",
        suffix=".txt",
        delete=False,
    ) as list_file:
        list_path = list_file.name
        for video in videos:
            list_file.write(format_concat_entry(video["path"]))

    subprocess.run(
        ["ffmpeg", "-f", "concat", "-safe", "0", "-i", list_path,
         "-c", "copy", "-y", output_file],
        check=True,
    )
finally:
    if list_path:
        try:
            os.unlink(list_path)
        except FileNotFoundError:
            pass

2. Ensure the temporary file is created atomically with restrictive permissions and is not shared between invocations.
3. Keep the file descriptor open through creation and writing, and avoid reopening a predictable pathname.
4. Escape filenames according to FFmpeg concat-demuxer syntax, including apostrophes, backslashes, carriage returns, and newlines.
5. Reject filenames that cannot be represented safely if robust concat-format escaping is unavailable.
6. Place cleanup in a finally block so failures do not leave path metadata behind.
7. Apply the correction consistently in both pipeline.py and ffmpeg_tools.py.
8. Add concurrency tests and tests involving pre-existing symlinks and unusual filenames.

SkillSpector

Vulnerability Patterns

• Data Exfiltration: External Transmission, Env Variable Harvesting, File System Enumeration
• Excessive Agency: Unrestricted Tool Access, Autonomous Decision Making, Scope Creep
• Tool Misuse: Tool Parameter Abuse, Chaining Abuse, Unsafe Defaults
• Behavioral AST: exec() Call, eval() Call, Dynamic Import
• Taint Tracking: Direct Taint Flow, Variable-Mediated Taint Flow, Credential Exfiltration Chain

Findings (63)

Tainted flow: 'headers' from os.environ.get (line 152, credential/environment) → requests.post (network output)

Critical

• Category: Data Flow
• Confidence: 90% confidence

Finding

Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Content

Scanner excerpt · scripts/video_to_text.py (reported line 165)May include surrounding context.

python

"messages": [{"role": "user", "content": prompt + text}]}
    
    try:
        resp = requests.post(url, headers=headers, json=payload, timeout=120)
        result = resp.json()
        if "content" in result:
            for c in result["content"]:

Tool Parameter Abuse

High

• Category: Tool Misuse
• Confidence: 98% confidence

Finding

The command for invoking video_clip.py is built with string interpolation from user-controlled paths and executed with shell=True. An attacker who supplies crafted input or output directory values containing shell metacharacters can break out of quoting and achieve arbitrary command execution under the privileges of the current user.

Content

Scanner excerpt · scripts/pipeline.py (reported line 219)May include surrounding context.

python

cmd = f'python3 "{script_dir}/video_clip.py" --input "{input_dir}" --output "{output_dir}" --target "" '
    send("▶️ 开始剪辑...")
    
    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
    print(result.stdout)
    print(result.stderr)

Tool Parameter Abuse

High

• Category: Tool Misuse
• Confidence: 97% confidence

Finding

The ffmpeg concat command is assembled as a shell string using output_file and executed with shell=True. Because the file path is derived from user input, a maliciously crafted output path can inject additional shell commands and execute arbitrary code.

Content

Scanner excerpt · scripts/pipeline.py (reported line 250)May include surrounding context.

python

send("▶️ 开始拼接...")
    cmd = f'ffmpeg -f concat -safe 0 -i "{list_file}" -c copy -y "{output_file}"'
    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
    
    os.remove(list_file)

Tool Parameter Abuse

High

• Category: Tool Misuse
• Confidence: 98% confidence

Finding

The transcription step executes a shell command string containing user-influenced directory paths via shell=True. This exposes the host to command injection if an attacker controls the input or output path values or can cause specially crafted filesystem names to be processed.

Content

Scanner excerpt · scripts/pipeline.py (reported line 279)May include surrounding context.

python

cmd = f'python3 "{script_dir}/video_to_text.py" --input "{os.path.dirname(video_path)}" --output "{output_dir}" --model small --target "" '
    send("▶️ 开始转写...")
    
    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
    print(result.stdout)
    
    # 列出字幕文件

Tool Parameter Abuse

High

• Category: Tool Misuse
• Confidence: 99% confidence

Finding

The subtitle burn step is especially risky because it interpolates both video paths and subtitle filenames into a shell command with nested quoting. Since subtitle filenames come from filesystem contents, a maliciously named .srt file can inject shell syntax and trigger arbitrary command execution during processing.

Content

Scanner excerpt · scripts/pipeline.py (reported line 331)May include surrounding context.

python

output_path = os.path.join(output_dir, output_name)
        
        cmd = f'ffmpeg -i "{v["path"]}" -vf "subtitles=\'{subtitle_file}\'" -c:a copy -y "{output_path}"'
        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
        
        if os.path.exists(output_path):
            send(f"✅ 完成: {output_name}")

Tool Parameter Abuse

High

• Category: Tool Misuse
• Confidence: 99% confidence

Finding

This is a second instance of the same shell-injection pattern in the merged-video subtitle burn path. Because it reuses filesystem-derived subtitle and video names in a shell command, exploitation can lead to arbitrary command execution and makes the media-processing context more dangerous, since untrusted media directories are common inputs.

Content

Scanner excerpt · scripts/pipeline.py (reported line 346)May include surrounding context.

python

output_path = os.path.join(output_dir, output_name)
            
            cmd = f'ffmpeg -i "{v["path"]}" -vf "subtitles=\'{subtitle_file}\'" -c:a copy -y "{output_path}"'
            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
            
            if os.path.exists(output_path):
                send(f"✅ 完成: {output_name}")

Natural-Language Policy Violations

Medium

• Category: Not specified by scanner
• Confidence: 88% confidence

Finding

The manifest description and nearly all operational instructions are presented only in Chinese, which effectively forces a specific language for users of the skill. The policy allows locale constraints only when they are explicitly justified or when users are offered a language choice, neither of which is present here.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

Medium

• Category: Not specified by scanner
• Confidence: 95% confidence

Finding

The documentation gives conflicting safety claims about dependency installation: earlier sections say the script will automatically detect and install dependencies, including pip packages, while the security notes later claim it only shows commands and does not auto-install. This inconsistency can mislead users into running the skill under a false assumption of safety, especially in environments where automatic package installation modifies the system or pulls untrusted code.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Medium

• Category: Not specified by scanner
• Confidence: 92% confidence

Finding

The module docstring, comments, status messages, and CLI help strings are all fixed in Chinese. This imposes a specific language on users without opt-in or any explanation that the tool is intended only for a Chinese-speaking or region-specific context.

Content

No source excerpt is available for this finding.

subprocess module call

Medium

• Category: Dangerous Code Execution
• Confidence: 70% confidence

Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · scripts/burn_subtitle.py (reported line 20)May include surrounding context.

python

if not TARGET:
        print(msg)
        return
    subprocess.run([
        "openclaw", "message", "send",
        "--channel", "feishu",
        "--target", TARGET,

subprocess module call

Medium

• Category: Dangerous Code Execution
• Confidence: 70% confidence

Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · scripts/ffmpeg_tools.py (reported line 24)May include surrounding context.

python

if not TARGET:
        print(msg)
        return
    subprocess.run([
        "openclaw", "message", "send",
        "--channel", "feishu",
        "--target", TARGET,

subprocess module call

Medium

• Category: Dangerous Code Execution
• Confidence: 70% confidence

Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · scripts/video_to_text.py (reported line 83)May include surrounding context.

python

if not TARGET:
        print(msg)
        return
    subprocess.run([
        "openclaw", "message", "send",
        "--channel", "feishu",
        "--target", TARGET,

Missing User Warnings

Medium

• Category: Not specified by scanner
• Confidence: 97% confidence

Finding

The script sends filenames and processing status to an external Feishu channel without a strong runtime warning or explicit consent mechanism. In many environments, video names can contain sensitive project, customer, or personal information, so this creates a data leakage channel. The skill context makes this more dangerous because notifications are automatic and happen for every processed file.

Content

No source excerpt is available for this finding.

Tainted flow: 'TARGET' from os.environ.get (line 135, credential/environment) → subprocess.run (code execution)

Medium

• Category: Data Flow
• Confidence: 65% confidence

Finding

Data from a source is assigned to a variable that is later passed to a sink, creating a variable-mediated taint flow.

Content

Scanner excerpt · scripts/burn_subtitle.py (reported line 20)May include surrounding context.

python

if not TARGET:
        print(msg)
        return
    subprocess.run([
        "openclaw", "message", "send",
        "--channel", "feishu",
        "--target", TARGET,

subprocess module call

Medium

• Category: Dangerous Code Execution
• Confidence: 91% confidence

Finding

The script launches ffmpeg on attacker-controlled file paths, including embedding the subtitle path inside the -vf subtitles= filter expression. Although shell injection is avoided, ffmpeg filter parsing has its own escaping rules, so crafted subtitle filenames containing quotes or filter metacharacters can break parsing, cause unintended behavior, or process a different path than intended. The skill context increases risk because it batch-processes files from a directory without sanitizing names.

Content

Scanner excerpt · scripts/burn_subtitle.py (reported line 82)May include surrounding context.

python

print(f"执行: {' '.join(cmd)}")
    
    # 执行并捕获进度
    process = subprocess.Popen(
        cmd,
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,

Context-Inappropriate Capability

Medium

• Category: Not specified by scanner
• Confidence: 97% confidence

Finding

A video-processing utility includes outbound messaging unrelated to core media operations. In agent environments, unexplained network-capable side effects materially increase risk because filenames, processing status, or future modifications could leak sensitive workflow data to external channels.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

Medium

• Category: Not specified by scanner
• Confidence: 96% confidence

Finding

The helper is described as sending to a group chat, but it can send arbitrary messages to any Feishu target provided by CLI or environment. In an agent skill context, that creates an unexpected exfiltration or covert-notification channel and makes operator review harder because the documentation understates where data can go.

Content

No source excerpt is available for this finding.

Tainted flow: 'TARGET' from os.environ.get (line 248, credential/environment) → subprocess.run (code execution)

Medium

• Category: Data Flow
• Confidence: 65% confidence

Finding

Data from a source is assigned to a variable that is later passed to a sink, creating a variable-mediated taint flow.

Content

Scanner excerpt · scripts/ffmpeg_tools.py (reported line 24)May include surrounding context.

python

if not TARGET:
        print(msg)
        return
    subprocess.run([
        "openclaw", "message", "send",
        "--channel", "feishu",
        "--target", TARGET,

subprocess module call

Medium

• Category: Dangerous Code Execution
• Confidence: 70% confidence

Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · scripts/burn_subtitle.py (reported line 52)May include surrounding context.

python

cmd = ["ffprobe", "-v", "error", "-show_entries", 
           "format=duration,size,format_name", "-of", "default=noprint_wrappers=1:nokey=1", video_path]
    try:
        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
        lines = result.stdout.strip().split('\n')
        info = {}
        for line in lines:

subprocess module call

Medium

• Category: Dangerous Code Execution
• Confidence: 70% confidence

Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · scripts/ffmpeg_tools.py (reported line 47)May include surrounding context.

python

cmd = ["ffprobe", "-v", "error", "-show_entries", 
           "format=duration,size,format_name", "-of", "default=noprint_wrappers=1:nokey=1", video_path]
    try:
        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
        lines = result.stdout.strip().split('\n')
        info = {}
        for line in lines:

subprocess module call

Medium

• Category: Dangerous Code Execution
• Confidence: 96% confidence

Finding

The concat command writes untrusted file paths into an ffmpeg concat list and invokes ffmpeg with -safe 0, disabling pathname safety checks. If an attacker can place specially crafted media paths or control the input directory contents, ffmpeg may be induced to read unexpected files or network resources, which is especially risky given ffmpeg's large attack surface on hostile media.

Content

Scanner excerpt · scripts/ffmpeg_tools.py (reported line 92)May include surrounding context.

python

cmd = ["ffmpeg", "-f", "concat", "-safe", "0", "-i", list_file, "-c", "copy", "-y", output_file]
    
    process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
    for line in process.stdout:
        print(line, end='')

Missing User Warnings

Medium

• Category: Not specified by scanner
• Confidence: 91% confidence

Finding

The burn and convert operations force overwrite with -y and provide no warning or confirmation, which can destroy existing files if output paths collide. In automated agent workflows, silent destructive behavior is a real integrity risk because path mistakes or adversarial filenames can cause loss of prior artifacts.

Content

No source excerpt is available for this finding.

subprocess module call

Medium

• Category: Dangerous Code Execution
• Confidence: 98% confidence

Finding

The burn command passes a user-influenced subtitle path into ffmpeg's subtitles filter expression without escaping filter-special characters. Because ffmpeg filter arguments have their own parser, crafted subtitle filenames can alter filter behavior or reference unintended files, and hostile subtitle/media content is processed by a complex external binary with a history of parser vulnerabilities.

Content

Scanner excerpt · scripts/ffmpeg_tools.py (reported line 140)May include surrounding context.

python

cmd = ["ffmpeg", "-i", video_path, "-vf", f"subtitles='{subtitle_path}'", "-c:a", "copy", "-y", output_path]
        
        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
        for line in process.stderr:
            print(line, end='')

subprocess module call

Medium

• Category: Dangerous Code Execution
• Confidence: 70% confidence

Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · scripts/ffmpeg_tools.py (reported line 180)May include surrounding context.

python

cmd = ["ffmpeg", "-i", video_path, "-c:a", "copy", "-y", output_path]
        
        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
        for line in process.stderr:
            print(line, end='')

Natural-Language Policy Violations

Medium

• Category: Not specified by scanner
• Confidence: 96% confidence

Finding

The module docstring, CLI descriptions, and runtime messages are written exclusively in Chinese, with no language selection or opt-in mechanism. This creates a locale policy issue because the skill imposes a specific language on users regardless of preference or environment.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.