Back to skill

Security audit

agent-father

Security checks for vulnerabilities and agentic risk

Overview

This skill mostly matches its stated agent-management purpose, but its scripts can modify external Feishu resources, store employee data, and contain unsafe deletion and code-injection paths that need review before installation.

Review this skill before installing in a real OpenClaw environment. Only run it with trusted employee input and trusted CSV files, avoid --force deletion, back up OpenClaw workspaces first, restrict permissions on generated employee records, and rotate Feishu secrets if troubleshooting output has exposed them. The deletion and node -e injection issues should be fixed before use with untrusted operators or shared service accounts.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (4)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/create-employee.sh:187
Finding
Arbitrary JavaScript Execution Through Unsafely Constructed node -e Program<![CDATA[ ## Vulnerability Details **File Location**: `scripts/create-employee.sh:187-203` **Vulnerability Type**: Shell-to-JavaScript code injection **Risk Level**: High ### Vulnerable Code ```bash if command -v node &> /dev/null; then node -e " const fs = require('fs'); const data = JSON.parse(fs.readFileSync('$EMPLOYEE_JSON', 'utf-8')); const exists = data.employees.find(e => e.id === '$ROLE'); if (!exists) { data.employees.push({ id: '$ROLE', name: '$AGENT_NAME', phone: '$PHONE', chatId: '$CHAT_ID', sessionId: '$SESSION_ID', workspace: '$WORKSPACE_PATH', agentDir: '$AGENT_DIR', status: 'pending_onboarding', createdAt: new Date().toISOString() }); } fs.writeFileSync('$EMPLOYEE_JSON', JSON.stringify(data, null, 2)); console.log(' ✅ 员工信息已添加'); " 2>/dev/null || echo " ⚠️ 无法更新" fi ``` ### Technical Analysis The script constructs an executable JavaScript program by directly interpolating shell variables into a `node -e` argument. Several interpolated values are derived from command-line input, including `ROLE`, `AGENT_NAME`, and `PHONE`. Other values originate from filesystem paths or the Feishu API response. Shell quoting does not make these values safe inside JavaScript string literals. An input containing a single quote and valid JavaScript syntax can terminate or restructure the intended string literal. For example, an attacker can supply a value that adds another object property whose value executes an expression such as `require('child_process').execSync(...)`. This is not merely malformed JSON injection: the affected text is evaluated as JavaScript source by Node.js. ### Attack Path 1. The attacker obtains the ability to invoke `create-employee.sh`, either directly or indirectly through `batch-create.sh` and an attacker-controlled CSV file. 2. The attacker places a JavaScript expression payload in an employee field such as the phone number or employee name. 3. The script performs its earlier creation ...[truncated 999 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Never interpolate shell variables into JavaScript source. - Place values in environment variables or pass them as separate positional arguments: ```bash EMPLOYEE_JSON="$EMPLOYEE_JSON" \ ROLE="$ROLE" \ AGENT_NAME="$AGENT_NAME" \ PHONE="$PHONE" \ node <<'NODE' const fs = require('fs'); const path = process.env.EMPLOYEE_JSON; const data = JSON.parse(fs.readFileSync(path, 'utf8')); if (!data.employees.some(employee => employee.id === process.env.ROLE)) { data.employees.push({ id: process.env.ROLE, name: process.env.AGENT_NAME, phone: process.env.PHONE }); } fs.writeFileSync(path, JSON.stringify(data, null, 2), { mode: 0o600 }); NODE ``` - Pass every remaining field through `process.env` or a structured input file rather than source interpolation. - Validate role, phone, chat ID, and session ID formats before use. - Use a JSON-aware implementation for all configuration updates. - Add regression tests containing quotes, backslashes, newlines, JavaScript syntax, and shell metacharacters. - Restrict employee-record permissions because they contain personal data. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/delete-agent.sh:29
Finding
Path Traversal and Unconstrained Recursive Directory Deletion<![CDATA[ ## Vulnerability Details **File Location**: `scripts/delete-agent.sh:29-122` **Vulnerability Type**: Path traversal leading to arbitrary recursive deletion **Risk Level**: High ### Vulnerable Code The deletion target is constructed from an unvalidated command-line argument: ```bash AGENT_ID="$1" FORCE="${2:-}" if [ -z "$AGENT_ID" ]; then echo "❌ 用法:$0 <agent-id> [--force]" exit 1 fi AGENT_DIR="$BASE_AGENTS_DIR/$AGENT_ID" if [ ! -d "$AGENT_DIR" ]; then echo "❌ 错误:Agent '$AGENT_ID' 不存在" echo " 目录:$AGENT_DIR" exit 1 fi ``` The resulting path and a path read from `agent.json` are recursively deleted: ```bash # 1. 删除 Agent 目录 if [ -d "$AGENT_DIR" ]; then echo " 删除 Agent 目录:$AGENT_DIR" rm -rf "$AGENT_DIR" echo " ✅ 已删除" fi # 2. 删除工作区目录 if [ -n "$WORKSPACE_PATH" ] && [ -d "$WORKSPACE_PATH" ]; then echo " 删除工作区目录:$WORKSPACE_PATH" rm -rf "$WORKSPACE_PATH" echo " ✅ 已删除" fi ``` ### Technical Analysis `AGENT_ID` is appended to `BASE_AGENTS_DIR` without enforcing the documented agent-ID format. Shell quoting prevents word splitting but does not prevent filesystem traversal. An identifier containing `../` can resolve outside the agents directory. The script only tests whether the resulting path is an existing directory. It does not: - Canonicalize the path. - Verify that the canonical path remains under `BASE_AGENTS_DIR`. - Reject traversal components. - Reject a target equal to a protected root. - Detect symlink-based boundary escapes. The optional `--force` flag removes the interactive confirmation. In addition, `WORKSPACE_PATH` is accepted from an `agent.json` file and recursively deleted without verifying that it belongs to an approved workspace root. ### Attack Path #### Traversal through the agent identifier 1. The attacker selects an existing user-accessible directory outside the OpenClaw agents directory. 2. The attacker invokes the script with an identifier containing traversal component ...[truncated 1282 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Enforce the documented identifier grammar before constructing paths: ```bash case "$AGENT_ID" in ''|*[!a-z0-9-]*) echo "Invalid agent ID" >&2 exit 1 ;; esac ``` - Canonicalize both the approved root and deletion target with `realpath`. - Require the target to be a strict descendant of the approved root: ```bash root="$(realpath -- "$BASE_AGENTS_DIR")" target="$(realpath -- "$AGENT_DIR")" case "$target" in "$root"/*) ;; *) echo "Deletion target escapes agent root" >&2; exit 1 ;; esac ``` - Apply an equivalent allowlist and containment check to `WORKSPACE_PATH`. - Explicitly reject empty targets, `/`, `$HOME`, `OPENCLAW_BASE`, the agents root, and the workspace root. - Refuse to follow symlinks or require each managed target to carry a trusted marker file. - Use `rm -rf -- "$target"` only after all checks pass. - Consider moving deleted agents into a quarantine or trash directory instead of deleting them immediately. - Require confirmation even in automation unless a narrowly scoped, authenticated administrative option is used. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/delete-agent.sh:64
Finding
JavaScript Injection in Agent Deletion Operations<![CDATA[ ## Vulnerability Details **File Location**: `scripts/delete-agent.sh:64-141` **Vulnerability Type**: JavaScript source injection through node -e **Risk Level**: High ### Vulnerable Code Filesystem paths are embedded directly into executable JavaScript: ```bash if [ -f "$AGENT_JSON" ]; then echo "📊 Agent 信息:" if command -v node &> /dev/null; then node -e " const fs = require('fs'); const data = JSON.parse(fs.readFileSync('$AGENT_JSON', 'utf-8')); console.log(' 姓名:' + (data.name || 'N/A')); console.log(' 工作区:' + (data.workspace || 'N/A')); console.log(' 创建时间:' + (data.createdAt || 'N/A')); " 2>/dev/null || echo " 无法读取 agent.json" fi echo "" fi WORKSPACE_PATH="" if [ -f "$AGENT_JSON" ] && command -v node &> /dev/null; then WORKSPACE_PATH=$(node -e "const fs=require('fs');const d=JSON.parse(fs.readFileSync('$AGENT_JSON','utf-8'));console.log(d.workspace||'');" 2>/dev/null || echo "") fi ``` The untrusted identifier is embedded in another program later in the deletion flow: ```bash if [ -f "$EMPLOYEE_JSON" ] && command -v node &> /dev/null; then echo " 更新员工名单:$EMPLOYEE_JSON" node -e " const fs = require('fs'); const path = '$EMPLOYEE_JSON'; const data = JSON.parse(fs.readFileSync(path, 'utf-8')); const originalLength = data.employees.length; data.employees = data.employees.filter(e => e.id !== '$AGENT_ID'); if (data.employees.length < originalLength) { fs.writeFileSync(path, JSON.stringify(data, null, 2)); console.log(' ✅ 已从员工名单中移除'); } else { console.log(' ⚠️ 员工名单中未找到该 Agent'); } " 2>/dev/null || echo " ⚠️ 无法更新员工名单" fi ``` ### Technical Analysis The command-line `AGENT_ID` influences both `AGENT_DIR` and the JavaScript literal used in the employee filter. Unix filenames may contain quotes and JavaScript punctuation. If an attacker can select or create a matching directory name, a crafted identifier can terminate the intended JavaScript string and inject an expression or statement. ...[truncated 1506 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove all shell-variable interpolation from JavaScript source. - Pass the agent ID and paths as positional arguments: ```bash node - "$EMPLOYEE_JSON" "$AGENT_ID" <<'NODE' const fs = require('fs'); const employeeFile = process.argv[2]; const agentId = process.argv[3]; const data = JSON.parse(fs.readFileSync(employeeFile, 'utf8')); data.employees = data.employees.filter(employee => employee.id !== agentId); fs.writeFileSync(employeeFile, JSON.stringify(data, null, 2)); NODE ``` - Validate `AGENT_ID` against a strict allowlist before any filesystem or Node.js operation. - Canonicalize and validate paths independently of the code-injection fix. - Avoid suppressing all Node.js diagnostics with `2>/dev/null`; report a sanitized error so failed validation and attempted exploitation are visible. - Add tests using single quotes, double quotes, newlines, backslashes, traversal components, and JavaScript expressions. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
QUICKSTART.md:24
Finding
Troubleshooting Instructions Can Disclose Feishu Application Secrets<![CDATA[ ## Vulnerability Details **File Location**: `QUICKSTART.md:24-31` **Vulnerability Type**: Sensitive configuration disclosure through unsafe diagnostic guidance **Risk Level**: Medium ### Vulnerable Code ```bash # 检查 openclaw.json 中是否有飞书配置 cat $OPENCLAW_BASE/openclaw.json | grep -A 5 '"feishu"' # 应该看到: # "feishu": { # "enabled": true, # "appId": "cli_xxx", # "appSecret": "xxx", # ... # } ``` The same diagnostic pattern is repeated at `QUICKSTART.md:159-160` and `SKILL.md:223-224`. ### Technical Analysis The documentation instructs users to print the Feishu section of `openclaw.json`. The expected output explicitly includes `appSecret`. The `-A 5` option also prints adjacent configuration lines that may contain other sensitive channel settings. Although this command does not transmit the secret by itself, its output can be captured by: - Terminal session recording. - CI/CD logs. - Remote support sessions. - Shell transcript collection. - Screenshots or copied troubleshooting output. - Agent execution logs when documentation commands are run by automation. The project already recognizes the secret as sensitive in `create-feishu-chat.sh`, where it displays `[hidden]`; the documentation does not preserve the same protection. ### Attack Path 1. A user encounters a Feishu configuration problem. 2. The user follows the documented troubleshooting command. 3. The terminal prints the application secret and neighboring configuration. 4. The user shares the output, or the execution environment records it. 5. A person with access to that transcript obtains the credential. 6. The exposed secret may be used with the corresponding application ID to request Feishu application access tokens, subject to the application's configured permissions. ### Impact Assessment The impact depends on the Feishu application's permission scope. Potential consequences include: - Unauthorized acquisition of application access tokens. - Unauthorized Feishu API calls ...[truncated 341 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Replace all `cat ... | grep -A ...` guidance with a parser that reports only key presence. - Never print the value of `appSecret`. For example: ```bash node - "$OPENCLAW_BASE/openclaw.json" <<'NODE' const fs = require('fs'); const config = JSON.parse(fs.readFileSync(process.argv[2], 'utf8')); const feishu = config.channels?.feishu ?? {}; console.log(`appId configured: ${Boolean(feishu.appId)}`); console.log(`appSecret configured: ${Boolean(feishu.appSecret)}`); NODE ``` - Update `QUICKSTART.md`, `SKILL.md`, and all troubleshooting examples consistently. - Add an explicit warning not to share `openclaw.json`, terminal output containing credentials, or application secrets. - Recommend restrictive permissions such as mode `0600` for the configuration file. - Rotate the Feishu application secret if it has already appeared in logs or shared troubleshooting output. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • YARA SignaturesMalware Match, Webshell Match, Cryptominer Match
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (33)

Tp4

High
Category
MCP Tool Poisoning
Confidence
94% confidence
Finding
The description significantly overstates the implemented functionality. The supplied code is a single-agent scaffolding script: it creates folders, writes configuration/identity files, and appends an employee-list entry. While this partially aligns with 'create new Agent/employee' and workspace setup, the broader declared scope—Feishu group creation, onboarding automation, batch onboarding, group configuration, training, and employee management—is not present in the code. Additionally, the description specifically says it automatically reads from openclaw.json, but the script instead derives the base directory from OPENCLAW_BASE, an openclaw config command, or filesystem heuristics; it never reads openclaw.json directly. Therefore the declared description does not accurately represent the actual behavior.

Tp4

High
Category
MCP Tool Poisoning
Confidence
94% confidence
Finding
声明描述的是一个覆盖 Agent/员工全生命周期管理的综合工具,但给出的代码块只实现了“创建飞书群组”这一子功能。虽然描述中提到支持飞书群组,且代码也确实会从 openclaw.json 读取配置,这部分是一致的;但代码没有任何 Agent 创建、员工入职、批量处理、工作区配置、培训或员工管理逻辑。因此,代码行为与声明的整体用途存在明显不匹配,属于声明范围远大于实际实现的情况。

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
描述强调的是“创建和管理”流程,尤其是一键创建、群组配置、入职和培训等正向管理能力;而该代码块的核心行为是执行不可逆的删除操作,删除 Agent 及其工作区,并更新员工名单。这属于未在描述中明确体现的高影响能力,且与“创建/入职”主目的明显不同。虽然“员工管理”可以广义包含删除,但当前描述没有充分表明存在销毁性删除功能,且代码没有实现描述中提到的大部分核心能力(创建、批量入职、飞书群组、培训、自动读取 openclaw.json 配置)。因此描述与实际行为存在实质性不匹配。

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The declared description promises a broad end-to-end management tool covering agent creation, group creation/configuration, workspace configuration, employee onboarding, batch onboarding, training, and employee management, with config auto-loaded from openclaw.json. The supplied code chunk only generates onboarding/training materials (ONBOARDING.md, TASKS.md, INBOX-GUIDE.md, and a training guide) in the workspace. It accepts only two positional arguments and does not implement one-click creation flows, batch processing, Feishu integration, group setup, employee management, or openclaw.json parsing. While岗前培训/onboarding is one of the declared scenarios, the actual code is only a small subset of the claimed functionality, so the description materially overstates the behavior.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
声明描述的是一个高层级、具备创建与管理全流程能力的工具,但代码片段仅包含只读查询和校验类辅助函数,没有任何创建、修改、入职、群组配置或培训逻辑。虽然代码访问了 openclaw 相关路径并验证 openclaw.json,这与声明中的配置背景部分有一定关联,但其主要行为与宣称能力明显不符,属于材料性描述不匹配。

YARA rule 'agent_skill_mcp_tool_poisoning_metadata': MCP/tool metadata poisoning indicators in tool schemas or skill manifests [agent_skills]

High
Category
YARA Match
Content
---
name: agent-father
description: 创建和管理 AI Agent/员工的全流程工具。支持一键创建 Agent、飞书群组、工作区配置、员工入职。自动从 openclaw.json 读取配置。使用场景:(1) 创建新 Agent/员工,(2) 批量入职,(3) 群组配置,(4) 岗前培训,(5) 员工管理。
metadata: { "openclaw": { "emoji": "👨‍🍼", "requires": { "bins": ["bash", "mkdir", "cat", "grep", "sed", "tr", "curl", "node"] } } }
---

# 👨‍🍼 Agent Father Skill

**创建新 Agent 和员工的完整解决方案**,自动从 openclaw.json 读取飞书配置,包含 JSON 配置、�
Confidence
80% confidence
Finding
YARA rule matched a hack tool or exploit indicator (offensive tools, reconnaissance, privilege escalation, or exploit frameworks).

Context-Inappropriate Capability

High
Confidence
98% confidence
Finding
The script reads `workspace` from `agent.json` and passes it directly to `rm -rf` after only checking that the path exists. Because there is no validation that this workspace path is under an expected managed base directory, a tampered or malicious `agent.json` can cause deletion of arbitrary directories accessible to the user running the script, especially dangerous with `--force` in an agent-management tool that performs destructive operations.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
This markdown file documents a command for deleting an employee/agent, but it does not include any warning, confirmation note, or caution about irreversible data removal. Under the markdown-specific warning criteria, destructive actions that may affect user data or system state should be disclosed to the user.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The quickstart tells users to run commands that create Feishu groups and employee artifacts, but it does not clearly warn that these actions will create external resources and modify local workspace/configuration state. In an agent-management skill, that omission can cause unintended provisioning, data creation, and side effects in real environments, especially when users treat the quickstart as a safe test.

Lp3

Medium
Category
MCP Least Privilege
Confidence
92% confidence
Finding
The skill advertises and documents shell-script execution but does not declare any explicit tool scope such as permissions or allowed-tools. That makes the operational boundary unclear and can allow an agent runtime to invoke shell capabilities more broadly than intended, increasing the chance of unsafe command execution in a skill that creates and deletes resources.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The skill documents deletion commands for agents and optionally chats without an explicit warning about irreversible data loss, backups, or confirmation requirements. In an agent-assisted environment, this increases the risk of accidental destructive execution against workspaces, employee records, or collaboration resources.

Missing User Warnings

Medium
Confidence
82% confidence
Finding
This shell script reads employee data from a CSV file and invokes another script to create employee records in bulk. Although it prints progress messages, it does not provide a user-facing warning or confirmation that running it will create multiple employee accounts/records from supplied personal data, which is a safety-relevant bulk write operation.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The script persists personal contact data such as phone numbers into agent.json without clearly warning the operator that sensitive personal data will be written to disk. In this skill’s context, the tool is specifically for creating and onboarding employees/agents, so silent storage of PII in generated files increases privacy, compliance, and accidental disclosure risk if those directories are shared, synced, or committed.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The script appends names, phone numbers, chat IDs, and session IDs to a shared roster file without an explicit warning that the file will be created or modified. In a workforce-management skill, this is more dangerous because the roster is likely to become a broadly accessible operational document, increasing the chance of overexposure of employee PII and internal identifiers.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The script sends employee-related data, including agent name, description, and onboarding content, to an external Feishu/OpenClaw chat channel without any explicit consent, privacy notice, or validation of whether that destination is appropriate. In an employee-management skill, this is more dangerous because the workflow is designed to handle real personnel data, so silent transmission can cause unintended disclosure to third-party systems or misbound chat destinations.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The script persistently stores employee records containing phone numbers, chat IDs, session IDs, workspace paths, and agent directories in a local JSON file without warning, retention controls, or access protection. In this skill’s context, that creates a meaningful privacy and operational-security risk because the file aggregates sensitive identifiers that could be harvested by other local users, malware, or backup/sync systems.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
This shell script extracts APP_ID and APP_SECRET from openclaw.json or environment variables, then uses them in an HTTP request to obtain an access token. While the code logs that configuration was loaded, it does not clearly warn the user that sensitive credentials will be read from local config/environment and sent over the network, which matches the missing-warning criteria for code files.

External Transmission

Medium
Category
Data Exfiltration
Content
# 获取访问令牌
get_access_token() {
  local response
  response=$(curl -s -X POST "${API_BASE}/auth/v3/app_access_token/internal" \
    -H "Content-Type: application/json" \
    -d "{
      \"app_id\": \"${APP_ID}\",
Confidence
70% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The create_chat function posts the group name, description, owner, and user_id_list to the Feishu remote API. Although the script prints status messages about creating the chat, it does not disclose that user-supplied identifiers and chat details are transmitted to an external service, so users are not explicitly warned about the privacy-impacting network operation.

External Transmission

Medium
Category
Data Exfiltration
Content
# 调用创建群聊 API
  local response
  response=$(curl -s -X POST "${API_BASE}/im/v1/chats" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer ${token}" \
    -d "$data")
Confidence
83% confidence
Finding
The script manually constructs JSON from untrusted command-line input and sends it directly to the Feishu chat-creation API. Because fields such as name, description, owner, and users are inserted without JSON escaping or validation, a crafted value containing quotes or JSON fragments could alter the request body, potentially adding unintended members, changing ownership, or causing malformed requests against the authenticated API.

Natural-Language Policy Violations

Medium
Confidence
95% confidence
Finding
The comments, usage text, warnings, and status messages throughout the script are written only in Chinese. This imposes a specific language on users without any opt-in, alternative locale, or documented justification for a Chinese-only constraint, which matches the language/locale policy violation criteria.

Natural-Language Policy Violations

Medium
Confidence
96% confidence
Finding
This shell script presents all user-facing comments, usage examples, status messages, and generated markdown content in Chinese only. That imposes a specific language/locale on all users without any opt-in, selection mechanism, or stated region-specific requirement, which matches the language-policy violation criteria.

Natural-Language Policy Violations

Medium
Confidence
88% confidence
Finding
This shell skill's user-facing comments, help text, and status/error messages are entirely in Chinese, with no indication that another language is supported or that the user can opt in to the locale. Under the policy rule for natural-language violations, forcing a specific language without user choice is reportable unless the locale constraint is explicitly documented and justified.

Natural-Language Policy Violations

Low
Confidence
87% confidence
Finding
The skill content forces a specific language/locale presentation for all users, and there is no visible indication that users can choose another language or that the locale restriction is intentional and justified. This may violate language/locale policy requirements when no opt-in or alternative is offered.

Natural-Language Policy Violations

Low
Confidence
83% confidence
Finding
All instructional content and examples are presented in Chinese, which can impose a language requirement on users without opt-in. The policy allows locale constraints when they are explicitly justified or when users are offered a language choice, neither of which is present here.

Static analysis

No suspicious patterns detected.