T01 · Skill Instruction Hijacking
- Location
install.js:147- Finding
Persistent Agent Instruction, Memory, and Tool-Registry Hijacking
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
This skill is openly meant to make agents remember and self-modify, but it installs broad persistent instructions across agent workspaces automatically and without enough user control.
Install only if you intentionally want this package to change agent instructions across your OpenClaw workspaces. Review the exact AGENTS.md patch first, avoid storing secrets or private infrastructure details in MEMORY.md, and do not run the release script unless you have audited and isolated its Git and publishing credentials.
install.js:147Persistent Agent Instruction, Memory, and Tool-Registry Hijacking
package.json:7Automatic Cross-Workspace Modification During Package Installation
scripts/publish.js:17Shell Command Injection Through Unvalidated Release Version
scripts/publish.js:54Unpinned Third-Party Package Execution in Release Workflow
The declared purpose does not disclose repository commits, pushes, tag creation, package publication, or authentication-affecting behavior such as deleting GitHub token variables. These actions can alter source history, exfiltrate code to remotes, publish unreviewed artifacts, and interfere with credentials, making the hidden behavior especially risky.
The declared purpose does not disclose repository commits, pushes, tag creation, package publication, or authentication-affecting behavior such as deleting GitHub token variables. These actions can alter source history, exfiltrate code to remotes, publish unreviewed artifacts, and interfere with credentials, making the hidden behavior especially risky.
The injected AGENTS.md block is written in Vietnamese and imposes that instruction set on all affected agents without any user opt-in or localization check. Forcing a language/locale can impair user understanding and review of persistent agent instructions, reducing transparency and increasing the chance that risky behavioral changes go unnoticed.
The patch mandates persistent recording of user-specific preferences, habits, and prior issues into MEMORY.md automatically at the end of sessions. This creates a standing data retention policy for potentially sensitive personal or operational information without consent, minimization, or access controls, increasing privacy and data leakage risk across future sessions.
The README explicitly promotes real-time writes to persistent memory and autonomous creation of scripts under skills/ without any guardrails, approval flow, or warning about data retention and code-generation risks. In an agent-skill context, encouraging durable storage plus self-modifying automation increases the chance of sensitive data capture, unsafe persistence of instructions, and unreviewed tool creation.
The installer is described as patching all active agent workspaces, but the README does not clearly warn that this is a bulk modification affecting multiple agents and instruction files. In practice, broad prompt patching can propagate unsafe behaviors, overwrite local policy, or make rollback and attribution difficult across the environment.
The documentation encourages permanent storage of user-provided rules, preferences, and operational details in a long-term memory file. This is risky because users may supply secrets, internal procedures, or regulated data that then persist beyond the immediate task and could be reused, exposed, or propagated later.
The example prompt tells the agent to permanently remember a backup server IP for future troubleshooting, which normalizes retention of private infrastructure metadata. Even a single internal IP can aid environment mapping, lateral movement planning, or disclosure of otherwise non-public network details if memory is later exposed.
The example workflow encourages processing member phone numbers and saving derived results into reusable automation artifacts for future runs. In context, this increases privacy and compliance risk because personal data becomes part of durable tooling or outputs, potentially expanding retention, access, and reuse beyond the original purpose.
The skill directs the agent to edit files, create scripts, update registries, and run an installer, but it declares no explicit tool scope or permissions. That mismatch is dangerous because it obscures the skill’s real capabilities and increases the chance an agent will perform filesystem or environment-sensitive actions without clear operator consent or sandboxing.
The skill instructs automatic writes to long-term memory files whenever new rules, debug outcomes, user behavior, or system changes are observed, without warning that workspace data will be modified. This is dangerous because it enables silent persistence of possibly sensitive or inaccurate information and may alter project state unexpectedly.
The instructions require default persistence of user behavior and other session-derived information into long-term memory. Storing such information by default creates privacy and data-minimization risks, especially when the user has not consented and retention limits are undefined.
The skill directs autonomous creation of helper scripts and updates to TOOLS.md without warning about workspace changes. Automatically generating executable automation in a workspace can introduce unsafe code paths, persistence mechanisms, or maintenance burden without human review.
The self-reflection workflow explicitly tells the agent to remember user habits and store them in long-term memory, which normalizes behavioral profiling. In this context, the skill is more dangerous because its purpose is persistence and autonomous evolution, so privacy-invasive storage is framed as routine rather than exceptional.
The install instructions say to apply the rules to all running agents in the system, which goes far beyond the skill’s stated local memory-management purpose. System-wide patching magnifies blast radius: a single invocation could change behavior across multiple agents and workspaces without targeted review.
The install instructions omit that running the installer may patch all running agents, so the operational impact is materially understated. Users may execute the command expecting a local setup step, while it actually performs broad behavioral modification across the environment.
The code enumerates every agent workspace from openclaw.json and applies modifications across all of them, rather than targeting a single explicitly selected workspace. This broad environment-wide write capability increases blast radius and can unexpectedly alter unrelated agents, making persistence and policy injection affect more of the system than users may realize.
The installer writes modified AGENTS.md content directly to user workspaces with no interactive confirmation, preview, or approval step. Silent policy injection into agent instruction files is dangerous because it changes future agent behavior persistently and may not be noticed until after subsequent sessions are affected.
The installer injects new standing instructions into AGENTS.md that go beyond passive memory maintenance and explicitly require autonomous creation of JavaScript helper scripts plus updates to TOOLS.md. That materially expands the agent’s future authority and behavior surface without per-task consent, creating a persistence and capability-escalation mechanism that can lead to unauthorized code generation and execution pathways in later sessions.
The injected self-reflection loop tells the agent to report back self-learned updates about the user after modifying memory, reinforcing collection and disclosure of user-related inferences. This encourages synthesis and propagation of personal or behavioral data beyond immediate task needs, which can amplify privacy harm if the memory contents are inaccurate, sensitive, or shared.
The package description explicitly advertises 'autonomous long-term memory updates' and 'self-evolving skill synthesis' without any stated scope limits, approval requirements, or trigger constraints. In an agent skill context, broad self-modifying and persistent-memory behavior increases the risk of uncontrolled state changes, prompt-injection persistence, and hard-to-audit behavior even if the text is only metadata.
The manifest says the skill performs autonomous updates to MEMORY.md, which is persistent user or workspace data, but provides no warning, consent model, or disclosure about when that data is modified. In a long-term memory skill, silent persistent writes are dangerous because they can store poisoned instructions, sensitive data, or misleading state that affects future agent behavior.
The script deletes GITHUB_TOKEN and GH_TOKEN so Git operations fall back to the locally logged-in account, bypassing explicit credential selection and policy controls. This is dangerous because it can cause privileged actions to run under a developer's personal account unexpectedly, reducing auditability and potentially pushing or tagging with broader permissions than intended.
The manifest description says the skill's purpose is to evolve MEMORY.md long-term memory and automatically package the skill. This script goes beyond packaging by committing to Git, pushing branches and tags to GitHub, and publishing externally to ClawHub, which are release/distribution operations not described in the manifest.
The script invokes npx clawhub publish without pinning an exact package version, so execution can resolve to whatever clawhub package/version is available at runtime. In a release workflow with publish and push privileges, this creates a supply-chain risk where a compromised or unexpected package version could execute arbitrary code and exfiltrate credentials or tamper with releases.