Back to skill

Security audit

conduxt

Security checks for vulnerabilities and agentic risk

Overview

This skill is a real coding-agent orchestrator, but it defaults to unattended broad approvals and persistent repo state, so it needs careful review before installation.

Install only if you are comfortable with an autonomous coding workflow that can create worktrees, run agents, persist task state, and potentially push or open PRs. Prefer requiring explicit confirmation for --approve-all, git push, and gh pr create; pin ACP adapter versions; and fix the setup.sh Python fallback and Markdown escaping before use in sensitive repositories.

Vulnerability Patterns
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • 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
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (3)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/setup.sh:154
Finding

Arbitrary Python Code Injection Through Untrusted Task Metadata

Content
View full analysis
/dev/null; then python3 -c " import json with open('$ACTIVE_TASKS_FILE', 'r') as f: data = json.load(f) if not any(t['task_id'] == '$TASK_ID' for t in data['tasks']): data['tasks'].append({ 'task_id': '$TASK_ID', 'session': '$TASK_ID', 'branch': '$BRANCH', 'worktree': '$WORKTREE_DIR', 'started_at': '$TIMESTAMP', 'status': 'pending', 'backend': '$BACKEND', 'description': '''$TASK_DESC''', 'pid': None }) with open('$ACTIVE_TASKS_FILE', 'w') as f: json.dump(data, f, indent=2) print('[setup] Registered task in active-tasks.json (via python3).') else: print('[setup] Task already in active-tasks.json — skipping.') " 2>/dev/null || echo "[setup] WARNING: Could not update active-tasks.json." ``` ### Technical Analysis The fallback implementation constructs a Python program dynamically using a double-quoted shell string. Multiple externally supplied values are interpolated directly into Python source code: - `TASK_ID` - `BRANCH` - `WORKTREE_DIR` - `TASK_DESC` These values are not encoded as Python string literals. In particular, a quotation mark or suitable Python syntax in `TASK_ID`, `BRANCH`, or `WORKTREE_DIR` can terminate the intended literal and inject additional statements. Although `TASK_DESC` is surrounded by triple quotes, a description containing the matching triple-quote delimiter can also escape its assigned value. The vulnerable branch runs when `jq` is unavailable and `python3` is present. Suppression of standard error does not prevent execution; it only makes exploitation attempts and failures less visible. ### Attack Path 1. An attacker supplies or influences a task ID, branch, worktree path, or task description processed by `s ...[truncated 1050 chars]
Remediation
View remediation

T02 · Agent Memory Poisoning

Warning
Location
scripts/setup.sh:105
Finding

Persistent Agent Memory Poisoning Through Unescaped Task Content

Content
View full analysis
> "$MEMORY_FILE" <
Remediation
View remediation

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
scripts/launch.sh:151
Finding

Unattended Coding Agents Receive Blanket Permission Approval

Content
View full analysis
&1 || { ``` ### Technical Analysis The preferred ACPX launch path combines unattended execution through `--no-wait` with `--approve-all`. This automatically approves every permission request made by the coding Agent, without restricting approval to repository reads, worktree writes, test execution, or other capabilities necessary for the particular task. Coding Agents process repository files and task descriptions that may be untrusted. Malicious repository instructions, prompt-injection content, compromised dependencies, or incorrect Agent decisions can therefore result in privileged tool operations being approved automatically. The Skill documentation advises against sending API keys through prompts, but this does not enforce least privilege or prevent the Agent from reading accessible files or invoking network-capable commands. Blanket approval exceeds the minimum permissions necessary for many coding and investigation tasks. ### Attack Path 1. A user starts an ACPX task against a repository containing malicious or misleading Agent-facing instructions. 2. `launch.sh` supplies the repository task to an autonomous coding Agent. 3. The Agent interprets the repository content or task text as a reason to request a sensitive operation. 4. `--approve-all` authorizes the request without user review. 5. The Agent performs actions such as reading files outside the worktree, executing arbitrary commands, modifying unrelated data, installing software, or initiating network communication, subject to the invoking account's permiss ...[truncated 708 chars]
Remediation
View remediation
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Memory PoisoningPersistent Context Injection, Context Window Stuffing, Memory Manipulation
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Rogue AgentSelf-Modification, Session Persistence
Findings (19)

Tp4

High
Category
MCP Tool Poisoning
Confidence
94% confidence
Finding

The description presents a skill whose main purpose is to start and orchestrate coding-agent sessions using ACPX or tmux. The supplied code chunk is instead a setup utility focused on repository/task initialization and state tracking. While backend auto-detection for acpx/tmux appears, there is no session launch, no duplex orchestration, no agent control, and no coding-task execution. The code’s primary behavior is git/worktree preparation plus local memory/state file management, which is materially different from the declared purpose. This is more than a supporting implementation detail because the core advertised capability—agent session orchestration—is absent from the provided code.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
93% confidence
Finding

The declared description presents a broad coding-session orchestrator used to start and manage coding work. The supplied code chunk does not implement general orchestration of coding tasks or session creation; instead, it specifically implements a watchdog for existing sessions. Its primary function is observation, health checking, status persistence, milestone logging, callback handling, and limited recovery/remediation. While this is related to an orchestration system and uses ACPX/tmux as described, the code’s actual purpose is materially narrower and operationally different from the declared purpose. Therefore, the description does not accurately represent this code chunk.

Content

No source excerpt is available for this finding.

Vague Triggers

High
Category
Not specified by scanner
Confidence
97% confidence
Finding

The invocation examples include very broad phrases like "code this" and "fix this bug," making accidental activation likely during ordinary conversation. For a user-invocable skill that can launch agents, create branches, and potentially auto-approve actions, ambiguous triggering materially increases the risk of unintended side effects.

Content

No source excerpt is available for this finding.

Memory Manipulation

High
Category
Memory Poisoning
Confidence
90% confidence
Finding

Skill manipulates agent memory, state, or stored context. Memory corruption can alter personality, override safety rules, or cause unpredictable behavior.

Content

Scanner excerpt · SKILL.md (reported line 40)May include surrounding context.

md
| Output | Typed ndjson (tool_call/text/done) | Raw ANSI text (burns 30-40% Context) |
| Mid-task instructions | Prompt queue: submit anytime, queued | send-keys: timing issues, may be treated as user input |
| Completion detection | Native `[done]` signal | Regex matching or Callback injection |
| Cancellation | Cooperative `session/cancel` (preserves state) | `C-c` (unreliable, may corrupt state) |
| Crash recovery | Auto-restart + load serialized session | Session survives but agent death goes unnoticed |
| Permissions | `--approve-all` / `--deny-all` policy-based | Interactive TTY popups (block unattended flows) |
| Visual monitoring | ndjson pipe to external tools | tmux split-pane (advantage) |

Missing User Warnings

High
Category
Not specified by scanner
Confidence
97% confidence
Finding

The skill explicitly recommends --approve-all for unattended agent execution without a strong user warning or compensating controls. This allows downstream agents to perform privileged operations with little friction, which is especially dangerous in a coding workflow that can modify files, run commands, and push branches.

Content

No source excerpt is available for this finding.

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
95% confidence
Finding

The skill instructs pushing branches and creating PRs based on agent-produced changes, with only a generic note to verify tests. This is dangerous because it operationalizes externally influenced agent output into repository and remote actions, and combined with auto-approval/autonomous workflows could publish malicious, incorrect, or sensitive changes.

Content

Scanner excerpt · SKILL.md (reported line 274)May include surrounding context.

md
→ cd <worktree> && <auto-detect test runner>

2. Push branch
   → git push -u origin <branch>

3. Create PR
   → gh pr create --title "fix: <title>" --body "..." --base main --head <branch>

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
85% confidence
Finding

The skill describes file reads/writes and persistent state management but does not declare a restrictive tool scope such as permissions or allowed-tools. In a user-invocable orchestration skill, this increases the chance that broad file operations occur implicitly and without clear policy boundaries, especially because the skill also manages worktrees and MEMORY.md state.

Content

No source excerpt is available for this finding.

Autonomous Decision Making

Medium
Category
Excessive Agency
Confidence
90% confidence
Finding

Advertising auto-approval of all permission requests enables autonomous execution without human review. In this skill, that autonomy is coupled with external tooling and repository mutation, so an agent mistake or compromise could rapidly propagate harmful actions.

Content

Scanner excerpt · SKILL.md (reported line 81)May include surrounding context.

md
| `acpx sessions list` | List all active sessions |
| `acpx sessions show -s <session>` | Show session details |
| `acpx cancel -s <session>` | Cooperative cancel of current task |
| `acpx prompt -s <session> --approve-all "<msg>"` | Auto-approve all permission requests |

### Community Skills (Composable)

Vague Triggers

Medium
Category
Not specified by scanner
Confidence
88% confidence
Finding

The scenario triggers are flexible and loosely defined, which can cause the skill to treat general development discussion as a command to orchestrate agents or fetch external data. In this context, ambiguity is more dangerous because the skill performs persistent workspace changes and external tool operations.

Content

No source excerpt is available for this finding.

Session Persistence

Medium
Category
Rogue Agent
Confidence
60% confidence
Finding

Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Content

Scanner excerpt · SKILL.md (reported line 152)May include surrounding context.

md
• Code review comments → extract action items

2. Generate task_id and branch name
   Create semantic IDs from task content, e.g.:
   • "add pagination" → task_id: add-pagination, branch: feat/add-pagination
   • "perf issue"     → task_id: perf-analysis,  branch: fix/perf-analysis
   • issue #78        → task_id: issue-78,        branch: fix/issue-78

Autonomous Decision Making

Medium
Category
Excessive Agency
Confidence
92% confidence
Finding

The launch flow specifically instructs using --approve-all for unattended operation, converting the orchestrator into a high-autonomy executor. This materially raises risk because the same flow also creates worktrees and can drive coding agents through arbitrary task prompts.

Content

Scanner excerpt · SKILL.md (reported line 170)May include surrounding context.

md
│   "<task description + callback instructions (see §6)>"   │
   │                                                            │
   │ • --no-wait: returns immediately, doesn't block you        │
   │ • --approve-all: auto-approve permissions for unattended   │
   │ • session auto-persisted to ~/.acpx/sessions/<task_id>.json│
   └────────────────────────────────────────────────────────────┘

Vague Triggers

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

Using a single common word like status as a trigger is prone to collision with normal conversational language. The resulting risk is unintended disclosure of session state or unintended execution of status-related commands, though the impact is lower than launch/approval actions.

Content

No source excerpt is available for this finding.

Rp1

Medium
Category
MCP Rug Pull
Confidence
89% confidence
Finding

Using npx @zed-industries/claude-agent-acp without a pinned version allows whatever package version is current at execution time to be fetched and run. That creates a supply-chain risk where upstream compromise, typo/republication, or breaking changes could execute unexpected code in a high-privilege orchestration path.

Content

No source excerpt is available for this finding.

Rp1

Medium
Category
MCP Rug Pull
Confidence
89% confidence
Finding

Using npx @zed-industries/codex-acp without version pinning introduces the same remote package execution and supply-chain exposure. Because this skill can launch coding agents, approve actions, and manipulate git state, compromise of the adapter can have broad downstream effects.

Content

No source excerpt is available for this finding.

Session Persistence

Medium
Category
Rogue Agent
Confidence
60% confidence
Finding

Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Content

Scanner excerpt · SKILL.md (reported line 276)May include surrounding context.

md
2. Push branch
   → git push -u origin <branch>

3. Create PR
   → gh pr create --title "fix: <title>" --body "..." --base main --head <branch>

4. Update MEMORY.md: status=completed, add PR link

Autonomous Decision Making

Medium
Category
Excessive Agency
Confidence
89% confidence
Finding

The command reference normalizes --approve-all as a standard operation, reinforcing unsafe use patterns. In a reusable skill, this can lead operators to enable unrestricted agent autonomy even when not necessary.

Content

Scanner excerpt · SKILL.md (reported line 443)May include surrounding context.

md
| Send prompt | `acpx prompt -s <name> "<text>"` |
| Fire-and-forget | `acpx prompt -s <name> --no-wait "<text>"` |
| Structured output | `acpx prompt -s <name> --format json "<text>"` |
| Auto-approve perms | `acpx prompt -s <name> --approve-all "<text>"` |
| List sessions | `acpx sessions list` |
| Show session | `acpx sessions show -s <name>` |
| Cancel task | `acpx cancel -s <name>` |

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The ACPX launch path passes --approve-all when starting an autonomous coding agent, which removes any interactive approval barrier before the agent can run commands or modify repository state. In this skill’s context, the prompt explicitly instructs the agent to complete coding tasks, run tests, and commit changes, so auto-approval materially increases the chance of unintended or unsafe file, git, or shell actions without user review.

Content

No source excerpt is available for this finding.

Session Persistence

Medium
Category
Rogue Agent
Confidence
65% confidence
Finding

Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Content

Scanner excerpt · scripts/launch.sh (reported line 254)May include surrounding context.

sh
WATCHDOG_SCRIPT="$(dirname "$0")/watchdog.sh"
    if [ -f "$WATCHDOG_SCRIPT" ] && [ -x "$WATCHDOG_SCRIPT" ]; then
        echo "[launch] Starting watchdog for task '${TASK_ID}'."
        nohup "$WATCHDOG_SCRIPT" "$TASK_ID" > "${ORCHESTRATOR_DIR}/${TASK_ID}-watchdog.log" 2>&1 &
        WATCHDOG_PID=$!
        echo "$WATCHDOG_PID" > "${ORCHESTRATOR_DIR}/${TASK_ID}-watchdog.pid"
    fi

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
87% confidence
Finding

The script persists agent-generated milestone text into repository memory files without any consent, redaction, or trust boundary checks. Because agent/session output can contain sensitive code snippets, secrets, internal URLs, or prompt material, this creates an unintended data retention and propagation channel inside the repo that may later be committed, indexed, or shared.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.