Back to skill

Security audit

Proprioception

Security checks for vulnerabilities and agentic risk

Overview

This skill is local and not overtly malicious, but it silently intercepts every turn and can change or delay agent responses based on broad heuristics while handling sensitive conversation text.

Install only if you want an always-on, local response-quality monitor that may interrupt or reshape answers. Avoid using it with sensitive conversations unless the host provides opt-in controls, limits retained history, and changes the engine input method away from command-line arguments.

Vulnerability Patterns
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • 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 (2)

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:207
Finding
Always-On Skill Instructions Override the Agent's Primary Response Behavior<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:207-238` **Vulnerability Type**: `T01: Skill Instruction Hijacking` **Risk Level**: High ### Vulnerable Code ```markdown When this skill is active, the agent MUST follow this protocol on **every conversation turn**: ### Step 1: Extract & Lock the Root Intent On the first user message, identify and internally store the user's **root intent** — the fundamental goal behind their request. Update this only if the user explicitly redirects. ### Step 2: Run the Proprioceptive Scan Before finalizing each response, run the proprioception engine by executing: ```bash node "$(dirname "$SKILL_PATH")/scripts/proprioception-engine.js" \ --root-intent "$ROOT_INTENT" \ --current-response "$CURRENT_RESPONSE" \ --turn-number "$TURN_NUMBER" \ --prior-signals "$PRIOR_SIGNALS_JSON" ``` This outputs a JSON object with scores for all five senses plus any triggered alerts. ### Step 3: Act on Alerts If any proprioceptive alerts fire, the agent MUST address them **before** delivering its primary response. Proprioceptive corrections take priority because a misaligned response actively harms the user, no matter how polished it is. ### Step 4: Update Signal History After each turn, append the current proprioceptive readings to the session's signal history. This enables trend detection across the full conversation. ### Step 5: Silent Unless Triggered Do NOT show proprioceptive data to the user unless: ``` The mandatory instructions are reinforced by fixed corrective directives elsewhere in the skill and by the executable alert templates in `scripts/alerts.js:43-142`. ### Technical Analysis The skill does not merely expose an optional diagnostic function. It instructs the host agent to intercept every conversation turn, analyze every drafted response, and prioritize the skill's corrective behavior over the user's primary request. The terms `MUST`, `every conversation turn`, and `take priority` establis ...[truncated 2573 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Change the skill from mandatory interception to an explicitly invoked or host-configured advisory feature. 2. Remove language asserting that the skill's corrections take priority over the primary response. 3. State explicitly that system instructions, platform safety rules, and the user's current request always retain precedence. 4. Return structured diagnostic data to the host agent rather than mandatory natural-language actions. 5. Require the host agent to independently validate an alert before changing, blocking, or delaying a response. 6. Present confidence and drift scores as heuristic indicators, not factual determinations. 7. Make automatic mode opt-in and disclose when it is active. 8. Provide a configuration option that prevents alerts from modifying response content. 9. Replace fixed phrases such as “full stop,” “block execution,” or “must address” with nonbinding recommendations. 10. Add tests for false positives involving cautious wording, legitimate topic changes, corrections, short answers, and vocabulary variation. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:215
Finding
Sensitive Conversation Content Is Passed Through Process Command-Line Arguments<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:215-223` **Vulnerability Type**: `T09: Insecure Skill Coding Practices` **Risk Level**: Medium ### Vulnerable Code ```markdown Before finalizing each response, run the proprioception engine by executing: ```bash node "$(dirname "$SKILL_PATH")/scripts/proprioception-engine.js" \ --root-intent "$ROOT_INTENT" \ --current-response "$CURRENT_RESPONSE" \ --turn-number "$TURN_NUMBER" \ --prior-signals "$PRIOR_SIGNALS_JSON" ``` This outputs a JSON object with scores for all five senses plus any triggered alerts. ``` The receiving code parses these values directly from the process argument vector in `scripts/proprioception-engine.js:39-65`: ```javascript const options = { "root-intent": { type: "string" }, "current-response": { type: "string" }, "turn-number": { type: "string" }, "prior-signals": { type: "string" }, dashboard: { type: "boolean", default: false }, }; let args; try { args = parseArgs({ options, allowPositionals: false }).values; } catch { console.error( "Usage: proprioception-engine.js --root-intent <text> --current-response <text> --turn-number <n> [--prior-signals <json>] [--dashboard]" ); process.exit(1); } const rootIntent = args["root-intent"] || ""; const currentResponse = args["current-response"] || ""; const turnNumber = parseInt(args["turn-number"] || "1", 10); const priorSignals = args["prior-signals"] ? JSON.parse(args["prior-signals"]) : []; ``` ### Technical Analysis The prescribed invocation places the user's root intent, the complete drafted response, and serialized prior-session telemetry in the child process's argument vector. Command-line arguments are not an appropriate transport for potentially confidential conversation content. Depending on the host operating system and process isolation configuration, arguments can be exposed through process inspection interfaces, monitoring agents, diagnostic tooling, audit logs, crash repor ...[truncated 2364 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Accept a single structured JSON document through standard input instead of command-line arguments. 2. Update the engine to read from file descriptor 0, parse the JSON under explicit error handling, and reject malformed input safely. 3. Invoke Node directly through an argument-array API rather than constructing a shell command. 4. Apply strict byte-size limits to root intent, current response, and prior history before processing. 5. Retain only the minimum historical fields needed for trend calculations rather than serializing complete session objects. 6. Avoid placing conversation content in environment variables, which may have similar visibility and size concerns. 7. Ensure standard input and output are not copied into verbose logs, crash reports, or telemetry by default. 8. Document the local trust boundary and warn operators that the input may contain sensitive information. 9. Catch JSON parsing and input-size errors and return a controlled diagnostic instead of terminating unexpectedly. 10. Add tests for large histories, multiline Unicode content, malformed JSON, empty input, and platform-specific process limits. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (7)

Tp4

High
Category
MCP Tool Poisoning
Confidence
94% confidence
Finding
The description presents a comprehensive situational/self-awareness system covering goal alignment, confidence boundaries, conversation trajectory, and output quality. The code only examines a single response string for lexical markers of certainty/uncertainty and returns a confidence score with per-sentence zones. While this partially matches the 'confidence boundaries' aspect, it does not implement the broader claimed capabilities, making the declared purpose materially overstated relative to actual behavior.

Tp4

High
Category
MCP Tool Poisoning
Confidence
92% confidence
Finding
The description is significantly broader and more conceptual than the code's actual behavior. The code only analyzes the agent's current response against prior responses to detect three anti-patterns: repetition, tangential drift, and declining lexical diversity, then derives a drift score and simple arc phase. It does not inspect user goals, model confidence, knowledge limits, or comprehensive output quality, all of which are central to the declared 'self-spatial awareness' capability. While conversation trajectory is partially represented by drift scoring and arc-phase estimation, the implementation is materially narrower than the declared purpose.

Tp4

High
Category
MCP Tool Poisoning
Confidence
90% confidence
Finding
The code is narrowly focused on scoring response/session quality from response text and prior signal history. It evaluates relevance, precision, novelty, efficiency, and derives a trend such as improving or declining. While this overlaps slightly with the declared mention of conversation trajectory and output quality, it does not implement core claimed capabilities like awareness of the user's goal alignment, the agent's confidence boundaries, or a broader 'self-spatial awareness' model. The primary purpose is materially different and much narrower than the description.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
The code chunk only provides low-level string and token analysis helpers. While such utilities could support a larger system related to conversation analysis, this code itself does not implement the declared capability of real-time self-spatial awareness, confidence sensing, goal-relative positioning, or quality monitoring. Its primary purpose is generic text utility/NLP preprocessing, which is materially different from the ambitious declared description.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The skill instructs the agent to run silent background analysis on every conversation turn without any user-facing disclosure. Even if processing is local, continuously deriving metadata from all user content without notice can violate privacy expectations and create hidden profiling of user behavior, intent, and confidence-sensitive content.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The skill describes appending proprioceptive readings to session signal history, which amounts to retaining conversation-derived behavioral metadata across turns without a stated retention notice or policy. This can expose sensitive inferred data about the user or session if logs are later inspected, persisted, or reused beyond the immediate interaction.

Context-Inappropriate Capability

Medium
Confidence
88% confidence
Finding
The documented 'Data Flywheel Potential' goes beyond transient self-awareness for a single session and explicitly proposes aggregating telemetry across thousands of sessions to build model/domain reliability maps and conversation behavior datasets. Even though this is framed as product or research value, it creates a clear privacy and scope-expansion risk because session-level behavioral metadata can become sensitive when retained, correlated, or repurposed beyond the user-facing function of the skill.

Static analysis

No suspicious patterns detected.