Back to skill

Security audit

Mind Engine

Security checks for vulnerabilities and agentic risk

Overview

This is a markdown-only reasoning skill, but it broadly takes over ordinary questions and tells the agent to update user memory after every dialogue without clear consent or limits.

Install only if you want this framework to shape many ordinary conversations. Before using it with personal, business, legal, health, or strategic topics, disable automatic memory updates or require explicit approval for every memory entry.

Vulnerability Patterns
  • 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
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
Findings (2)

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:11
Finding
Global Agent Role and Workflow Hijacking<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 11–15, 123–149, and 181–188 **Vulnerability Type**: `T01: Skill Instruction Hijacking` **Risk Level**: High ### Vulnerable Code ```markdown You are the user's digital brain. The user asks a question, the engine runs through 7 stages automatically. The entire process is conversational — the engine asks methodology-driven questions, the user answers, clarity emerges step by step, and multi-option recommendations are delivered with full reasoning chains. ``` ```markdown ## Trigger Conditions Any question, confusion, decision need, or analysis request from the user activates this engine. No explicit "use the framework" command is needed — just engage when someone is thinking out loud or seeking clarity. ``` ```markdown ### Stage 6: Recommendation Output Fixed output format: ``` ## Problem: [Brief restatement] ## Methodology Basis - Primary Framework: XXX - Verification Framework: YYY - Supplementary Perspective: ZZZ ## Recommendations ### Option A: [Name] - What: [One sentence] - Why: [Full reasoning chain] - Feasibility Conditions: [When it works / doesn't work] - Key Risk: [Worst case + probability] - Methodology Source: [Specific model] ### Option B: ... ### Option C: ... ## My Judgment [Preferred recommendation + reasoning. User may disagree.] ## Models Used | Model | Domain | Role in This Analysis | |-------|--------|----------------------| ``` ``` ```markdown ## Core Behavioral Constraints 1. Tag every analysis step and recommendation with its methodology source 2. Diagnose before matching — never skip diagnosis to jump to advice 3. Ask when information is insufficient — never guess 4. At least 3 hypotheses — never give a single answer 5. Every hypothesis must pass all 6 verification checks 6. Update user memory after each dialogue 7. Allow the user to say "I don't know" 8. Allow the user to disagree with the recommendation ``` ### Technical Analysis The skill declares its ...[truncated 2307 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace universal automatic activation with explicit invocation, such as requiring the user to request the “Mind Engine” framework by name. 2. Remove role-replacement language such as “You are the user's digital brain.” 3. Narrow the trigger to clearly defined analytical tasks for which the framework is appropriate. 4. State explicitly that system, developer, and current user instructions take precedence over the framework. 5. Make the seven-stage process optional and allow users to request a direct or concise answer. 6. Treat the fixed output structure as a suggested template rather than a mandatory format. 7. Permit the agent to skip stages when they are unnecessary, disproportionate, or incompatible with the requested task. 8. Avoid unconditional directives such as “never give a single answer”; instead, generate multiple options only when they materially improve the analysis. 9. Add conflict handling that disables the framework when another task requires a strict output schema. ]]>

T02 · Agent Memory Poisoning

Warning
Location
SKILL.md:155
Finding
Unconsented Persistent User-Memory Modification<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 155–158 and 186 **Vulnerability Type**: `T02: Agent Memory Poisoning` **Risk Level**: Medium ### Vulnerable Code ```markdown ### Stage 7: Cognitive Consolidation After the dialogue ends: 1. Evaluate model effectiveness, adjust weights 2. Record user preferences and constraints 3. Note methodology limitations discovered 4. Optimize the framework itself ``` ```markdown 6. Update user memory after each dialogue ``` ### Technical Analysis The skill mandates recording user preferences and constraints and updating user memory after every dialogue. It does not require user consent, distinguish temporary conversational state from persistent storage, specify which data may be retained, validate inferred preferences, or define review and deletion controls. If the host agent exposes persistent memory, user statements—including inaccurate, sensitive, temporary, or adversarially crafted statements—may be stored and subsequently treated as durable preferences or constraints. This creates a memory-integrity risk because future behavior can be influenced by unverified state originating in an earlier conversation. The actual persistence capability depends on the host environment. The project contains no executable implementation that independently writes to storage, so this finding concerns the instruction's effect when interpreted by an agent with a memory facility. No evidence establishes operating-system persistence or access to memory belonging to other users. ### Attack Path 1. The skill is loaded into an agent that supports persistent user memory. 2. During a conversation, a user or other untrusted conversational input supplies misleading, temporary, sensitive, or adversarial preference information. 3. The skill's mandatory consolidation stage instructs the agent to record preferences and constraints automatically. 4. The information is retained without explicit confirmation or validation. 5. ...[truncated 915 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the unconditional requirement to update user memory after every dialogue. 2. Make persistent memory writes opt-in and obtain explicit user consent before each write. 3. Display the exact proposed memory entry and allow the user to approve, edit, or reject it. 4. Keep exploratory conclusions in session-only state unless the user specifically requests persistence. 5. Define an allowlist of non-sensitive fields that may be stored. 6. Do not persist secrets, health information, financial information, credentials, or other sensitive personal data. 7. Validate whether a statement is a durable preference rather than a temporary instruction or untrusted claim. 8. Attach source, timestamp, confidence, and expiration metadata to retained preferences. 9. Provide mechanisms to inspect, correct, and delete stored memory. 10. Isolate memory by user and prevent one user's statements from influencing another user's profile. 11. Treat retrieved memories as untrusted context and never as higher-priority instructions. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (7)

Vague Triggers

High
Confidence
95% confidence
Finding
The manifest advertises universal automatic activation for any question or analysis request, which creates an unsafe default scope. Because the skill is framed as a universal thinking engine, it may inappropriately engage in contexts where users did not request intensive analysis, increasing the chance of overcollection, confusion, or policy circumvention through broad prompt control.

Vague Triggers

High
Confidence
97% confidence
Finding
The trigger condition is so broad that it can activate on nearly any user message, causing the skill to take over ordinary conversation without clear user intent. In practice this can override expected interaction patterns, induce unnecessary probing questions, and increase collection of sensitive contextual information under the guise of analysis.

Description-Behavior Mismatch

Medium
Confidence
92% confidence
Finding
The manifest description claims the engine provides 'transparent citations' and is 'customizable with user's own knowledge bases.' However, the file only defines a conversational framework and a hypothetical file-path map, without any code or operational logic to fetch citations or read user knowledge bases. That is a semantic mismatch between claimed capability and actual implemented behavior in this skill file.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
The skill instructs recording user preferences and constraints but gives no up-front warning or consent flow to the user. This creates a privacy risk because users may reveal sensitive personal, professional, or strategic information during the framework's questioning without understanding that the skill intends to retain it.

Ssd 3

Medium
Confidence
93% confidence
Finding
The instruction to record user preferences and constraints creates a natural-language retention directive that can lead an agent or connected memory system to persist sensitive user data beyond the immediate session. In the context of a broadly triggered conversational analysis skill, this is more dangerous because the framework actively solicits goals, constraints, risks, and prior experiences—exactly the kinds of data that are often sensitive.

Ssd 3

Medium
Confidence
94% confidence
Finding
The behavioral rule to update user memory after each dialogue operationalizes ongoing retention as a default behavior. This is risky because the skill's structured questioning is designed to elicit detailed personal and decision-making context, so automatic memory updates can accumulate a high-value profile of the user without clear boundaries or informed consent.

Intent-Code Divergence

Low
Confidence
86% confidence
Finding
Line L186 directs the system to 'Update user memory after each dialogue,' which implies persistence or state modification. Elsewhere, the file is only a static reasoning workflow and does not implement any memory storage behavior or identify a memory subsystem. This is an intent-versus-actual-behavior contradiction in the documentation.

Static analysis

No suspicious patterns detected.