Back to skill

Security audit

Cobo Agentic Wallet

Security checks for vulnerabilities and agentic risk

Overview

The skill is for legitimate Cobo wallet automation, but it combines high-impact crypto authority with unsafe update, install, credential, and automatic pact behaviors that need review before use.

Install only if you trust Cobo's distribution channel and are comfortable granting an agent wallet-operation authority. Before use, require explicit confirmation before new pacts or updates, avoid unpinned npx/npm/pip installs, do not put API keys in project scripts, review any generated pact policy for exact amount/recipient/contract limits, and be aware that original transaction requests may be sent to the Cobo service.

Vulnerability Patterns
  • 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
  • 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
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
Findings (5)

T03 · Remote Payload Retrieval and Execution

Error
Location
scripts/bootstrap-env.sh:9
Finding
<![CDATA[Downloaded Wallet and TSS Executables Lack Independent Authenticity Verification]]><![CDATA[ ## Vulnerability Details **File Location**: `scripts/bootstrap-env.sh:9-12, 116, 151-178, 331-362` **Vulnerability Type**: Remote payload retrieval and insecure software supply chain **Risk Level**: High ### Vulnerable Code ```bash CAW_BASE_URL="${CAW_BASE_URL:-https://download.agenticwallet.cobo.com/binary-release}" CAW_VERSION="${CAW_VERSION:-v0.2.84}" TSS_BASE_URL="${TSS_BASE_URL:-https://download.tss.cobo.com/binary-release/latest}" ``` ```bash download_with_resume() { local url="$1" local dest="$2" mkdir -p "$(dirname "$dest")" curl --fail --location --silent --show-error --continue-at - --output "$dest" "$url" } ``` ```bash extract_tss_assets() { local tarball="$1" local tmp_dir tmp_dir="$(mktemp -d)" trap 'rm -rf "$tmp_dir"' RETURN tar -xzf "$tarball" -C "$tmp_dir" local tss_bin tss_bin="$(find "$tmp_dir" -type f -name "cobo-tss-node" | head -n 1)" if [[ -z "$tss_bin" ]]; then echo "cobo-tss-node binary not found in tarball" >&2 exit 1 fi mkdir -p "$CACHE_TSS_DIR" cp "$tss_bin" "$CACHE_TSS_DIR/cobo-tss-node" chmod 755 "$CACHE_TSS_DIR/cobo-tss-node" sha256_file "$CACHE_TSS_DIR/cobo-tss-node" > "$CACHE_TSS_DIR/cobo-tss-node.sha256" chmod 600 "$CACHE_TSS_DIR/cobo-tss-node.sha256" } ``` ```bash download_with_resume "$caw_url" "$caw_tmp_tar" echo "Verifying checksum..." download_with_resume "${caw_url}.sha256" "$caw_tmp_sum" local expected_sum actual_sum expected_sum="$(awk '{print $1}' "$caw_tmp_sum")" actual_sum="$(sha256_file "$caw_tmp_tar")" if [[ "$actual_sum" != "$expected_sum" ]]; then echo "Checksum mismatch: expected $expected_sum, got $actual_sum" >&2 exit 1 fi extract_caw_assets "$caw_tmp_tar" "$BIN_DIR" ``` ```bash download_with_resume "$tss_url" "$tss_tmp_tar" extract_tss_assets "$tss_tmp_tar" ``` ### Technical Analysis The bootstrap script retrieves native wallet and threshold-signature executables from remote URLs and installs them as executable files. CAW archives are checked ...[truncated 2001 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Publish a signed release manifest and verify it with a public key bundled through an independent, trusted channel. 2. Pin approved versions and cryptographic digests in reviewed Skill content or another independently protected source. 3. Add equivalent pre-extraction verification for the TSS archive. 4. Reject URL overrides that do not use HTTPS and restrict production downloads to an explicit hostname allowlist. 5. Treat custom mirrors as an advanced option requiring explicit user confirmation and a caller-provided trusted digest or signature. 6. Extract into a staging directory, validate archive paths and expected contents, and install atomically only after verification succeeds. 7. Refuse archives containing symbolic links, path traversal entries, unexpected executables, or extra files. 8. Preserve and audit the verified version, signer identity, and digest after installation. ]]>

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:239
Finding
<![CDATA[Mutable Packages and Externally Discovered Skill Instructions Are Automatically Trusted]]><![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:239-243`; `references/sdk-scripting.md:31-42, 220-225` **Vulnerability Type**: Mutable dependency installation and instruction-channel hijacking **Risk Level**: High ### Vulnerable Code From `SKILL.md`: ```markdown ### `"update": true` in response If any `caw` JSON response contains `"update": true`, immediately: 1. Run `npx skills update` to update the skill 2. Re-read this SKILL.md to pick up any changed instructions 3. Re-run the original command with the current CLI ``` From `references/sdk-scripting.md`: ```markdown ## Prerequisites - `python3` — required for the Python SDK - `node` / `npm` — required for the TypeScript SDK and DeFi calldata encoding. Install from https://nodejs.org if absent. - `ethers` — required by several DeFi recipes: `npm install ethers` ## Install **Python:** ```bash pip install cobo-agentic-wallet ``` **TypeScript / JavaScript:** ```bash npm install @cobo/agentic-wallet ``` ``` ```markdown **2. External skill packages** (clawhub registry, requires install): ```bash npx skills find CoboGlobal/cobo-agentic-wallet "<protocol-name> <chain>" # or: npx clawhub@latest search "cobo <protocol>" ``` If a matching skill package is found, install it and follow its instructions. Use this when `caw recipe search` returns no results. ``` ### Technical Analysis The Skill permits a server-controlled response field to trigger an immediate Skill update, after which the Agent re-reads and follows changed instructions. This allows content outside the reviewed package to change the Agent's operational rules after audit. The scripting reference also installs dependencies without exact version or integrity pinning and explicitly uses `@latest` for registry tooling. Most significantly, it directs the Agent to install externally discovered Skill packages and follow their instructions without requiring review, provenance validation, or user approval. This combines a mutable code suppl ...[truncated 1444 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not let an API response unilaterally trigger replacement of trusted Agent instructions. 2. Require explicit owner approval before every Skill update or external Skill installation. 3. Download updates into a staging area and perform a static security review before activation. 4. Pin all Python and npm dependencies to reviewed versions and enforce lockfiles with integrity metadata. 5. Avoid `@latest`; pin registry tools to exact versions and verified package hashes. 6. Require cryptographic signatures and trusted publisher identities for external Skills. 7. Display the proposed package name, version, publisher, permissions, and source before installation. 8. Treat external Skill text as untrusted data until reviewed; never immediately “install and follow” discovered instructions. 9. Disable or strictly control package lifecycle scripts where feasible. 10. Run package installation and generated scripts in a sandbox without wallet secrets unless access is explicitly required. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
references/sdk-scripting.md:45
Finding
<![CDATA[SDK Guidance Encourages Printing and Hardcoding Wallet API Credentials]]><![CDATA[ ## Vulnerability Details **File Location**: `references/sdk-scripting.md:45-82` **Vulnerability Type**: Plaintext credential exposure **Risk Level**: High ### Vulnerable Code ```markdown ## Get Credentials After onboarding, retrieve your API key and wallet UUID from the CLI: ```bash caw wallet current # -> api_key, api_url, wallet_uuid caw wallet list # -> list all local wallet profiles (includes wallet_uuid per entry) ``` ``` ```python import asyncio from cobo_agentic_wallet.client import WalletAPIClient API_URL = "https://api.agenticwallet.cobo.com" API_KEY = "your-api-key" WALLET_UUID = "your-wallet-uuid" async def main(): async with WalletAPIClient(base_url=API_URL, api_key=API_KEY) as client: # your operations here pass asyncio.run(main()) ``` ```typescript import { Configuration, TransactionsApi, BalanceApi, WalletsApi } from "@cobo/agentic-wallet"; const API_URL = "https://api.agenticwallet.cobo.com"; const API_KEY = "your-api-key"; const WALLET_UUID = "your-wallet-uuid"; const config = new Configuration({ basePath: API_URL, apiKey: API_KEY, }); ``` ### Technical Analysis The reference instructs the Agent to retrieve an API key through ordinary CLI output and provides templates that place the key directly in source code. The same document requires generated scripts to be stored under the project's `scripts/` directory, making accidental source-control inclusion or project sharing more likely. Secrets printed to standard output can be captured in terminal history, tool transcripts, CI logs, screen recordings, debugging systems, or chat context. Hardcoded keys can subsequently appear in commits, backups, build artifacts, code-review systems, or generated bundles. Although placeholders are used in the examples, the surrounding workflow directs the user or Agent to replace them with retrieved credentials rather than using a secret-management mechanism. ### Attack Path 1. The Agent runs `caw wallet curr ...[truncated 879 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not return API keys from general wallet metadata commands. Provide a dedicated credential-injection mechanism instead. 2. Change all templates to read secrets from a protected environment variable or operating-system secret store, for example `COBO_API_KEY`. 3. Never print the resolved secret value in generated scripts, logs, exceptions, or user-facing responses. 4. Use short-lived, narrowly scoped credentials where supported and rotate any key that may have entered logs or source control. 5. Add project-level ignore rules for secret-bearing files such as `.env`, while clarifying that ignore rules do not replace secret management. 6. If a local credential file is unavoidable, create it with mode `0600` and store it outside the project tree. 7. Add automated secret scanning to commits and CI. 8. Redact authorization headers and API keys from SDK exceptions and debug output. 9. Separate read-only credentials from transaction-capable credentials according to least privilege. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
references/pact.md:163
Finding
<![CDATA[Example Swap Pact Grants Broader Contract-Call Authority Than the Stated Transaction Requires]]><![CDATA[ ## Vulnerability Details **File Location**: `references/pact.md:163-213` **Vulnerability Type**: Excessive wallet authorization scope **Risk Level**: High ### Vulnerable Code ```markdown ### Example: USDC → ETH Swap on Base **Step 1 — Intent:** - Action: swap USDC → ETH - Asset/amount: $5000 USDC - Chain: Base - Timeframe: one-time - Unclear: slippage tolerance not specified ``` ```markdown **Step 3 — Plan:** 1. Check wallet USDC balance ≥ $5000 2. Query Uniswap V3 USDC/ETH pool on Base for current rate 3. Amount $5000 < $10k threshold → no split needed 4. Execute swap with 0.5% slippage tolerance, 5-minute deadline 5. Monitor tx; retry up to 2x on gas spike or slippage rejection 6. Verify swap receipt on-chain ``` ```json [ { "name": "usdc-eth-swap", "type": "contract_call", "rules": { "effect": "allow", "when": { "chain_in": ["BASE_ETH"], "target_in": [ { "chain_id": "BASE_ETH", "contract_addr": "0x2626664c2603336E57B271c5C0b26F421741e481" }, { "chain_id": "BASE_ETH", "contract_addr": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" } ] }, "deny_if": { "usage_limits": { "rolling_24h": { "tx_count_gt": 3 } } } } } ] ``` ```markdown Completion condition — one-time swap: `{"type": "tx_count", "threshold": "1"}` ``` ### Technical Analysis The example's stated goal is a one-time swap of $5,000 USDC to ETH. However, the proposed policy restricts only the chain, two callable contract addresses, and a rolling transaction count. It does not bind authorization to: - A maximum USDC amount or USD value. - Specific function selectors or permitted calldata structures. - The intended output asset. - An exact approval allowance. - An authorized recipient. - The stated deadline or minimum output. - A confirmed slippage tolerance. Consequently, the policy can authorize contract calls that differ materially from the transaction described to the owner. The inclu ...[truncated 1612 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Bind the policy to the exact input token and a maximum spend of $5,000 USDC. 2. Restrict calls to approved function selectors and validate relevant calldata fields. 3. For token approval, constrain the spender to the intended router and the allowance to the exact required amount or a tightly bounded maximum. 4. Constrain the expected output token, recipient, minimum output, and deadline. 5. Ask the user to approve slippage tolerance instead of silently selecting 0.5%. 6. Align completion conditions with the actual operation sequence, accounting for a possible approval transaction and the swap transaction. 7. Prefer amount-spent and transaction-count completion conditions together where the policy language supports them. 8. Ensure retries do not increase aggregate authorized spend beyond the original intent. 9. Replace this documentation example with a demonstrably least-privilege policy so downstream generated pacts do not inherit unsafe defaults. ]]>

other

Warning
Location
SKILL.md:254
Finding
<![CDATA[Verbatim User Requests Are Transmitted to the External Wallet Service Without Data Minimization]]><![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:254-263` **Vulnerability Type**: Excessive disclosure of user-provided sensitive information **Risk Level**: Medium ### Vulnerable Code ```bash caw pact submit \ --intent "<agent-facing description of the goal>" \ --original-intent "<user's original request verbatim>" \ --name "<short pact name>" \ --recipe-slugs <recipe-slug> \ --policies '<policies-json>' \ --completion-conditions '<completion-conditions-json>' \ --execution-plan "<execution-plan>" ``` ### Technical Analysis Pact creation necessarily sends transaction-related information to the Cobo wallet service, including policy and execution-plan data. However, the `--original-intent` argument explicitly requires the user's original request verbatim. A user request can contain information unrelated to transaction enforcement, such as personal names, internal business context, invoice details, account identifiers, confidential notes, or inadvertently pasted credentials. Sending the entire message violates data-minimization principles because a normalized transaction intent and structured fields are sufficient for the declared wallet function. The sensitive-network behavior identified by the static pre-scan is therefore partly necessary, but transmitting unrelated verbatim content exceeds the minimum information needed to create and approve a pact. ### Attack Path 1. A user requests a wallet transaction and includes confidential or personally identifying context in the same message. 2. The Agent constructs `caw pact submit` using the entire original message as `--original-intent`. 3. The CAW CLI transmits the argument to the external wallet service. 4. The text may enter service-side application logs, databases, monitoring systems, support tools, analytics, or backups. 5. Anyone with authorized or unauthorized access to those systems may obtain information unrelated to the wallet transaction. ### Impact Assessment The iss ...[truncated 384 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace verbatim forwarding with a locally generated, transaction-specific summary. 2. Send structured fields such as action, chain, token, amount, destination, duration, and approved constraints instead of the complete message. 3. Remove secrets, personal data, unrelated context, and free-form attachments before submission. 4. If the raw request is operationally required, clearly disclose the destination and obtain explicit user consent before transmission. 5. Define and document retention, access, deletion, and logging policies for submitted intent data. 6. Apply server-side redaction to request logs and monitoring systems. 7. Add local detection that blocks submission when `--original-intent` appears to contain API keys, private keys, seed phrases, passwords, or other credentials. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (24)

Intent-Code Divergence

High
Confidence
97% confidence
Finding
The file says 'Never initiate additional transactions that the user did not request' but later instructs the agent to automatically create a pact when a transfer is denied by a daily limit. Pact creation is itself a new onchain/approval operation that changes wallet state and escalates privileges without explicit user authorization, undermining the stated safety boundary.

Lp3

Medium
Category
MCP Least Privilege
Confidence
89% confidence
Finding
The skill can invoke shell-based capabilities (`caw`, `npx`) but does not declare an explicit tool scope or allowed-tools boundary. In a wallet-management skill that can move funds, the absence of a restrictive tool manifest increases the blast radius if the agent is induced to run unintended commands or if the runtime grants broader shell access than expected.

Vague Triggers

Medium
Confidence
95% confidence
Finding
The trigger criteria are very broad (`caw`, `Cobo`, `pact`, or any crypto wallet operation for AI agents), which increases the chance the skill activates in conversations where it is only tangentially relevant. In a skill capable of autonomous on-chain actions, accidental activation raises the likelihood of unsafe command generation, overreach, or confusion with unrelated wallet contexts.

Unbounded Resource Access

Medium
Category
Excessive Agency
Content
- **When status becomes `active`**: reply immediately, then execute as a background task — do not synchronously wait for the transaction result before replying. See [Act on Result](./references/pact.md#act-on-result).
- **Rejected** → tell the owner, offer to revise with narrower scope and resubmit.
- **Revoked / expired / completed** → stop immediately, notify the owner, offer a new pact if the goal is unmet.
- **Approval not arriving** → if a pact has been waiting in `pending_approval` longer than expected, stop polling and surface the situation to the owner. Do not loop indefinitely.

#### 3. Execute
All transactions (transfers, contract calls, message signing) run inside a pact. Shared decision rules:
Confidence
75% confidence
Finding
Skill allows unbounded resource consumption (API calls, storage, compute). Without rate limits or quotas, a compromised or misbehaving agent can cause denial-of-service or cost overruns.

Unbounded Resource Access

Medium
Category
Excessive Agency
Content
- **When status becomes `active`**: reply immediately, then execute as a background task — do not synchronously wait for the transaction result before replying. See [Act on Result](./references/pact.md#act-on-result).
- **Rejected** → tell the owner, offer to revise with narrower scope and resubmit.
- **Revoked / expired / completed** → stop immediately, notify the owner, offer a new pact if the goal is unmet.
- **Approval not arriving** → if a pact has been waiting in `pending_approval` longer than expected, stop polling and surface the situation to the owner. Do not loop indefinitely.

#### 3. Execute
All transactions (transfers, contract calls, message signing) run inside a pact. Shared decision rules:
Confidence
75% confidence
Finding
Skill allows unbounded resource consumption (API calls, storage, compute). Without rate limits or quotas, a compromised or misbehaving agent can cause denial-of-service or cost overruns.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
- `exit 0` → command ran; check `.success` in the JSON payload
- `exit != 0` → command failed to run; read stderr for details

**NEVER claim success without checking `.success` in the response.**

### Retry Policy
- Same command fails 3 times → STOP retrying
Confidence
75% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Rp1

Medium
Category
MCP Rug Pull
Confidence
92% confidence
Finding
The instruction to run `npx skills update` pulls and executes code without a pinned version or integrity control. In a high-privilege wallet skill, this creates a supply-chain risk where a compromised or changed upstream package could execute arbitrary code or alter wallet-handling behavior mid-session.

Description-Behavior Mismatch

Medium
Confidence
90% confidence
Finding
The manifest frames the skill as being for autonomous onchain wallet operations and explicitly says it is not for fiat payments or bank transfers. While testnet funding is still crypto-adjacent, `caw faucet deposit` extends the documented examples into testnet asset acquisition, which is not described in the manifest's stated scope and goes beyond the listed operational categories.

Intent-Code Divergence

Medium
Confidence
97% confidence
Finding
The document explicitly says not to branch on the natural-language `.error.suggestion` field because wording may change, then later directs recovery logic based on whether that text contains phrases like 'retry with' or 'ask the wallet owner'. This creates inconsistent control-flow guidance that can cause brittle automation, misclassification of denial reasons, and unsafe retries or missed stops when backend wording changes.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The documentation tells the agent to inform the user and then 'immediately submit a new pact' for the blocked transfer, but notification is not equivalent to consent. In a wallet-management skill, automatically creating approval requests can trigger governance workflows, social-engineering pressure on owners, and unintended authorizations without the user's explicit confirmation.

Ssd 4

Medium
Confidence
94% confidence
Finding
The guidance escalates from a denied transfer into a different privileged workflow—submitting a pact—without a separate authorization checkpoint. In the context of agentic wallet operations, such escalation broadens the agent's effective authority and can be exploited to convert a blocked action into an approval-seeking action that the user did not specifically authorize.

Rp1

Medium
Category
MCP Rug Pull
Confidence
93% confidence
Finding
The documentation instructs users to execute `npx skills` without pinning an exact package name/version, which can fetch and run whatever package currently resolves from the registry. In a wallet-management skill, that creates a meaningful supply-chain risk: a compromised, typosquatted, or newly published package could execute arbitrary code in an environment likely to contain API keys, wallet identifiers, scripts, and transaction workflows.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The command `npx clawhub@latest` explicitly pulls and executes the latest available package version at runtime, which is unsafe because behavior can change unexpectedly and a compromised release would execute immediately. Given this skill is for agentic crypto wallets and DeFi actions, successful exploitation could lead to credential theft, script tampering, malicious transaction generation, or redirection of on-chain operations.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
mkdir -p "$dest_dir"
  cp "$caw_bin" "$dest_dir/caw"
  chmod 755 "$dest_dir/caw"
}

extract_tss_assets() {
Confidence
80% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
mkdir -p "$dest_dir"
  cp "$caw_bin" "$dest_dir/caw"
  chmod 755 "$dest_dir/caw"
}

extract_tss_assets() {
Confidence
80% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
cp "$tss_bin" "$CACHE_TSS_DIR/cobo-tss-node"
  chmod 755 "$CACHE_TSS_DIR/cobo-tss-node"
  sha256_file "$CACHE_TSS_DIR/cobo-tss-node" > "$CACHE_TSS_DIR/cobo-tss-node.sha256"
  chmod 600 "$CACHE_TSS_DIR/cobo-tss-node.sha256"

  local tpl
  tpl="$(find "$tmp_dir" -type f -name "*.yaml.template" ! -name "._*" | head -n 1 || true)"
Confidence
80% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
cp "$tss_bin" "$CACHE_TSS_DIR/cobo-tss-node"
  chmod 755 "$CACHE_TSS_DIR/cobo-tss-node"
  sha256_file "$CACHE_TSS_DIR/cobo-tss-node" > "$CACHE_TSS_DIR/cobo-tss-node.sha256"
  chmod 600 "$CACHE_TSS_DIR/cobo-tss-node.sha256"

  local tpl
  tpl="$(find "$tmp_dir" -type f -name "*.yaml.template" ! -name "._*" | head -n 1 || true)"
Confidence
80% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
The script persistently modifies shell startup files and PATH by appending entries to .bashrc, .bash_profile, .zshrc, .zprofile, .profile, or fish config without an explicit confirmation step. This exceeds a narrow 'download assets' action and creates lasting changes to the user's execution environment, which increases risk if the installed binary is later replaced, compromised, or unexpectedly shadows another command.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The script changes user shell configuration files to alter PATH without prior warning or consent. Silent persistent environment modification is risky because it can affect future shells, change command resolution behavior, and make users trust a newly downloaded executable across sessions without a deliberate installation decision.

Scope Creep

Low
Category
Excessive Agency
Content
□ Destination is an unknown personal address (not a recognized protocol contract) · □ Amount is large relative to the wallet's balance or the pact's limits · □ Token, chain, or amount is not explicitly stated · □ Pact has expired, is near expiry, or the wallet is frozen · □ Testnet and mainnet would mix — never use testnet addresses for mainnet operations and vice versa · □ Request came from automated input rather than a direct user message · □ Operation would affect pact scope or policy configuration

**Agent cannot, by design:**
✗ Act as approver — you propose pacts, the owner approves · ✗ Execute beyond the scope of an active, owner-approved pact · ✗ Exceed spending limits · ✗ Act without pact coverage — every on-chain operation must fall within an active, owner-approved pact

When denied: report what was blocked and why.
When expired or frozen: stop all operations and notify the owner immediately. Do not attempt workarounds — repeated attempts on a denied or out-of-scope operation may trigger a wallet freeze.
Confidence
70% confidence
Finding
Skill's behavior or capabilities extend beyond its stated purpose. Scope creep allows an agent to perform actions unrelated to its documented functionality, increasing the attack surface.

Intent-Code Divergence

Low
Confidence
77% confidence
Finding
Earlier lines document a transaction lifecycle ending in `Completed` and require exact equality checks against that status, but later lines instruct polling until status advances past `Processing` and report success at `Success`. Those documented states contradict each other, creating intent-code/documentation divergence about how transaction completion is determined.

Natural-Language Policy Violations

Low
Confidence
78% confidence
Finding
Line L053 requires showing the transaction result in plain language, and the surrounding examples and prescribed reply text are all in English. The file does not explicitly force English-only output, but it also does not offer a language or locale choice, which can conflict with a language/locale policy requiring user opt-in.

Scope Creep

Low
Category
Excessive Agency
Content
> Thinking mode: least privilege

Your job: Derive `--policies` and `--completion-conditions` strictly from what the user described. Do not infer, add, or assume beyond the stated intent.   

**Policy** — use the recipe from Step 2 as a guide. Anything not explicitly matched by a `when` condition will be denied — there is no implicit pass-through. See [Policy Reference](#policy-reference---policies) for supported fields and schema.
Confidence
70% confidence
Finding
Skill's behavior or capabilities extend beyond its stated purpose. Scope creep allows an agent to perform actions unrelated to its documented functionality, increasing the attack surface.

Description-Behavior Mismatch

Low
Confidence
79% confidence
Finding
The manifest centers on using the caw CLI for wallet onboarding, transfers, contract calls, and DeFi execution. This script additionally provisions a separate cobo-tss-node binary and related config templates into a local cache, which introduces local infrastructure setup behavior not clearly expressed in the manifest description. While related to MPC/TSS, it is a broader install/bootstrap function than the described end-user wallet actions.

Static analysis

No suspicious patterns detected.