Back to skill

Security audit

Task Specialist

Security checks for vulnerabilities and agentic risk

Overview

The skill is a coherent local task manager, but its verification checkpoint workflow can steer agents into running task-stored shell commands without strong trust boundaries.

Install only if you trust the workspace and agents that can create or edit tasks. Treat every displayed verification checkpoint as untrusted text: inspect it independently before running it, prefer project-owned test scripts over pasted shell, and avoid sharing a writable .tasks.db with untrusted collaborators or agents.

Vulnerability Patterns
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (1)

T09 · Insecure Skill Coding Practices

Warning

Untrusted Stored Verification Commands Can Induce Arbitrary Command Execution

scripts/cmds/cmd_complete.sh:22
` will natively print the Bash subshell checkpoint. **For security (RCE prevention), these checkpoints must be executed manually.** ``` `SKILL.md:72`: ```markdown 4. **Completion and Checkpoints**: Run `task complete `. If your task contains a Checkpoint Validation (a Bash subshell script), the engine will output the command for you to run manually. **You must repair the codebase until the tests pass before you can technically complete the task and self-terminate.** ``` `scripts/cmds/cmd_create.sh:50-51`: ```bash local verify_val="NULL" [ -n "$verify" ] && verify_val="'$(printf '%s' "$verify" | sed "s/'/''/g")'" ``` `scripts/cmds/cmd_edit.sh:58-65`: ```bash if [ -n "$verify" ]; then local safe_verify safe_verify=$(printf '%s' "$verify" | sed "s/'/''/g") [ -n "$updates" ] && updates="$updates, " if [ "$verify" = "none" ] || [ "$verify" = "null" ] || [ "$verify" = "NULL" ]; then updates="${updates}verification_cmd = NULL" else updates="${updates}verification_cmd = '$safe_verify'" fi fi ``` `scripts/cmds/cmd_complete.sh:22-27`: ```bash local verify_cmd verify_cmd=$(sql "SELECT verification_cmd FROM tasks WHERE id = $id;" 2>/dev/null) || true if [ -n "$verify_cmd" ]; then printf '\033[1;33mManual Checkpoint Required:\033[0m %s\n' "$verify_cmd" printf '\033[1;34mNote:\033[0m Auto-execution disabled for security (RCE prevention).\n' fi ``` ### Technical Analysis The task creation and editing commands accept arbitrary text through `--verify` and persist it as `verifica ...[truncated 2620 chars]

Remediation

Vulnerability Patterns
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Rogue AgentSelf-Modification, Session Persistence
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (10)

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
- **Swarm Engine (`task claim`)**: Atomic SQLite `UPDATE ... RETURNING` locks prevent race conditions, allowing native parallel execution across multiple AI workers. Safely honors `depend` relationship mapping.
- **Agent Tracking (`task claim --agent="NAME"`)**: Introduced the `assignee` schema attribute natively to the database. All read-only views (dashboard, list, export) now dynamically trace orchestrator assignment visibility.
- **Kanban Dashboard (`task board`)**: A visual ASCII Kanban board that dynamically aligns active tasks, blocked tasks, and real-time nested assignee identifiers without text wrapping limits.
- **Execution Checkpoints (`--verify`)**: `task create` and `task edit` now accept `--verify="<cmd>"`. Completing the task will automatically execute the bash subshell test, blocking the task completion on non-zero exit codes.
- **Context Persistence (`task note`)**: Agents can now attach timestamped runtime logs or error traces directly to task payloads natively, allowing context to survive agent death dynamically.
- **Data Export Pipelines**:
  - `task list --format=chat`: Bypasses ASCII column padding to synthesize native GitHub-flavored Markdown strings.
Confidence
86% confidence
Finding

The autonomous behavior itself is not automatically a flaw, but here it is tied to automatic execution of verification commands during task completion. In the context of a multi-agent orchestration skill, autonomous execution increases the likelihood that unreviewed or attacker-influenced task data will trigger code execution without a human checkpoint.

Missing User Warnings

Medium
Confidence
95% confidence
Finding

The changelog documents a feature where a user-supplied string passed via --verify is automatically executed in a Bash subshell during task completion. In an agent-oriented task system, task metadata may be created, edited, or consumed across trust boundaries, so treating stored task data as executable shell commands creates a command-injection and arbitrary code execution path.

Lp3

Medium
Category
MCP Least Privilege
Confidence
96% confidence
Finding

The skill explicitly instructs the agent to run shell commands such as bash install.sh, task, and task-heartbeat, but it does not declare any tool scope, permissions, or allowed-tools constraints. That mismatch matters because an agent may execute shell-capable actions without an explicit trust boundary, increasing the chance of unintended command execution from a skill that is treated as documentation rather than privileged code.

Session Persistence

Medium
Category
Rogue Agent
Content
# Install (creates DB only, no PATH changes)
bash install.sh

# Or install AND create easy CLI symlinks in ~/.local/bin
bash install.sh --symlink

# Create and work tasks
Confidence
89% confidence
Finding

The skill offers an install mode that creates CLI symlinks in ~/.local/bin, which is a persistent modification to the user's environment outside the project workspace. Persistent changes are risky because they can outlive the session, affect future command resolution, and make it easier for a compromised or tampered install script to plant long-lived execution paths.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
if ! command -v sqlite3 &>/dev/null; then
  die "sqlite3 is required but not found. Install it:
    Debian/Ubuntu: sudo apt install sqlite3
    Arch:          sudo pacman -S sqlite
    macOS:         brew install sqlite"
fi
Confidence
70% confidence
Finding

Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
if ! command -v sqlite3 &>/dev/null; then
  die "sqlite3 is required but not found. Install it:
    Debian/Ubuntu: sudo apt install sqlite3
    Arch:          sudo pacman -S sqlite
    macOS:         brew install sqlite"
fi
Confidence
70% confidence
Finding

Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Session Persistence

Medium
Category
Rogue Agent
Content
ok "sqlite3 found: $(sqlite3 --version | head -1)"

# ── 2. Create seed database with schema (for testing) ───────────────────────

DB="$PWD/.tasks.db"
if [ -f "$DB" ]; then
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.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding

The script sources every matching shell file from the cmds directory at startup, which executes their contents with the privileges of the current user. If an attacker can place or modify a file in that directory, running the task tool becomes arbitrary code execution; this is especially risky because the skill presents itself primarily as a local SQLite task manager, not as a plugin executor.

Context-Inappropriate Capability

Medium
Confidence
93% confidence
Finding

Broad runtime sourcing is more permissive than necessary for a task-management utility and expands the trusted code base to any *.sh file in the target directory. In agent environments where skills may be unpacked, updated, or combined automatically, this increases the chance that an unexpected file leads to code execution or behavior tampering.

Missing User Warnings

Low
Confidence
88% confidence
Finding

This code creates and modifies the SQLite database file automatically via sqlite3 and ALTER TABLE statements. Although the script's purpose is task management, these filesystem and data-changing operations are not disclosed to the user through a visible runtime message, confirmation, or nearby comment explaining that the command may initialize or migrate the database.

Static analysis

Detected: suspicious.dynamic_code_execution

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
install.sh:4

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/task-heartbeat.sh:4