Back to skill

Security audit

Notes (Local, Apple, Notion, Obsidian & more)

Security checks for vulnerabilities and agentic risk

Overview

This notes skill is mostly purpose-aligned, but it gives agents broad persistent write authority and contains risky deletion and credential-handling instructions users should review carefully.

Install only if you are comfortable with a note assistant that keeps durable local memory and may update actions, contacts, projects, indexes, and review files. Before using it on sensitive notes, disable or require confirmation for deletion/triage sweeps, avoid the fixed /tmp note examples, prefer safer credential handling for Notion, and pin or independently review any third-party CLIs you install.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
Findings (4)

T09 · Insecure Skill Coding Practices

Error
Location
apple-notes.md:35
Finding
Predictable Shared Temporary File Enables Note Disclosure and Symlink-Based File Overwrite<![CDATA[ ## Vulnerability Details **File Location**: `apple-notes.md:35-50`; the same pattern also appears in `evernote.md:40-54` **Vulnerability Type**: Predictable temporary file, insecure permissions, and symlink following **Risk Level**: High ### Complete Code Snippet ```bash cat > /tmp/note.md << 'EOF' # Pricing: staying at three tiers — 2026-07-26 **Present:** Alice, Bob ## Decisions - Three tiers stay; revisit at 500 customers — @alice, effective 2026-07-26 ## Actions - [ ] @alice: send the pricing deck — 2026-08-04 EOF pbcopy < /tmp/note.md memo notes -a "2026-07-26 Pricing three tiers" ``` ```markdown - **Delete the temp file after pasting.** `/tmp` is world-readable on a shared machine, and a meeting note left there outlives the session. ``` Evernote repeats the vulnerable construction: ```bash cat > /tmp/note.md << 'EOF' # Pricing: staying at three tiers — 2026-07-26 **Present:** Alice, Bob ## Decisions - Three tiers stay; revisit at 500 customers — @alice, effective 2026-07-26 ## Actions - [ ] @alice: send the pricing deck — 2026-08-04 EOF clinote note create --title "2026-07-26 Pricing three tiers" --file /tmp/note.md --notebook "Meetings" ``` ### Technical Analysis The fixed path `/tmp/note.md` is shared across all invocations and users. Shell redirection with `>` follows symbolic links. If an attacker can create `/tmp/note.md` as a symbolic link before the command runs, note creation will truncate and overwrite the linked file with the privileges of the agent process. The resulting file may also inherit a permissive process umask, commonly producing a mode such as `0644`. In that configuration, other local users can read the note before it is deleted. Deleting the file after use narrows the exposure window but does not prevent either pre-creation attacks or concurrent reads. The instructions explicitly acknowledge that `/tmp` is unsafe, but recommend post-operation deletion rather than secure creation. They also do not show an actu ...[truncated 1260 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Avoid temporary files entirely when the destination supports standard input. - Where a file is mandatory, create an unpredictable, owner-only file: ```bash umask 077 tmp_file="$(mktemp "${TMPDIR:-/tmp}/clawic-note.XXXXXXXX")" || exit 1 trap 'rm -f -- "$tmp_file"' EXIT HUP INT TERM cat > "$tmp_file" <<'EOF' ... EOF ``` - Verify that the created object is a regular file and not a symbolic link. - Keep the temporary filename quoted in every command. - Use a per-user private runtime directory where available. - Ensure cleanup runs on both success and failure through a shell trap. - Replace every occurrence of the fixed `/tmp/note.md` path, including the Apple Notes and Evernote workflows. - Document that sensitive content must not be placed on the clipboard unless the user explicitly selected the clipboard-based workflow, because clipboard managers may retain it. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
action-items.md:50
Finding
Action Items and Captures Can Be Deleted Automatically Without User Authorization<![CDATA[ ## Vulnerability Details **File Location**: `action-items.md:50-74`; related automatic deletion appears in `capture.md:81-94` and `memory-template.md:24-49` **Vulnerability Type**: Unauthorized destructive data lifecycle and contradictory confirmation policy **Risk Level**: High ### Complete Code Snippet ```markdown | Age | State | What happens | |---|---|---| | Due in future | open | Nothing | | Due today or overdue 1-2 days | overdue | Named in the next session's opening line, once | | Overdue 3-6 days | overdue, flagged | Offer the four verdicts: done, new date, blocked-with-owner, delete | | Overdue 7-13 days | stale | The date was wrong. A new date is required; keeping the old one is a lie the tracker tells daily | | Overdue 14+ days | dead | Delete it, or convert it to a project (`projects.md`). Nothing survives two weeks overdue by accident | ``` ```markdown ## The Weekly Sweep Runs inside the weekly review (`journal.md`), as its first pass: 1. Every row past due gets one of four verdicts: done, new date, blocked-with-owner, deleted. 2. Completed rows are moved into the week block in `reviews/<year>.md` and deleted from the tracker. A tracker that keeps every completed item stops being readable at about 80 rows. 3. Count what was deleted and say it. "Four items deleted, all 14+ days overdue" is the honest signal that the intake is too loose. 4. Anything carried three weeks running is deleted regardless of protest — the fourth carry is the practice lying to itself. ``` The capture policy contains another automatic deletion rule: ```markdown | Delete | It has not been touched in 30 days and no action came out of it | Delete it, and say how many were deleted | Nothing stays in `quick/` after triage. An item that survives two triages untouched is a delete, not a keep — that is the whole signal. ``` The persistence template further states: ```markdown No permission needed; every write is announced in one line that names the file. ``` These ...[truncated 2535 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove the instruction “deleted regardless of protest.” - Never use age alone as authority for permanent deletion. - Require explicit, current confirmation before deleting each item or a clearly displayed batch. - Present a deletion plan containing exact paths, row identities, reasons, and counts before making changes. - Replace deletion with a reversible state transition: - Mark stale actions as `archived` or `cancelled`. - Move old captures into a dated archive directory. - Preserve source pointers and original dates. - Apply a retention period to an archive or trash area before permanent removal. - Make the top-level confirmation policy authoritative in every subordinate document. - Add a transactional procedure: 1. Read and validate current state. 2. Create a backup or journal of proposed changes. 3. Obtain confirmation. 4. Apply changes. 5. Verify counts and paths. - Validate dates against the user's timezone and reject implausible values. - Do not allow untrusted imported content to directly determine deletion state. ]]>

T08 · Insecure Dependencies

Warning
Location
bear.md:11
Finding
Unpinned Third-Party CLI Installation Instructions Create a Supply-Chain Execution Risk<![CDATA[ ## Vulnerability Details **File Location**: `bear.md:11`; equivalent unpinned instructions appear in `evernote.md:11`, `apple-notes.md:11`, and `obsidian.md:11` **Vulnerability Type**: Mutable third-party dependencies installed without version or integrity verification **Risk Level**: Medium ### Complete Code Snippet ```markdown macOS or iOS with Bear installed and **running**, plus the user's own installation of the `grizzly` CLI (`go install github.com/tylerwince/grizzly/cmd/grizzly@latest`). Nothing is installed on the user's behalf. ``` Equivalent instructions include: ```markdown An Evernote account and the user's own installation of `clinote` (`go install github.com/TcM1911/clinote@latest`), authenticated once with `clinote login`. ``` ```markdown macOS, Notes.app, and the user's own installation of the `memo` CLI (`brew tap antoniorodr/memo && brew install antoniorodr/memo/memo`). ``` ```markdown Obsidian installed, plus the user's own installation of `obsidian-cli` (`brew install yakitrak/yakitrak/obsidian-cli`). ``` ### Technical Analysis The Go instructions explicitly use `@latest`, so the reviewed skill does not determine which source revision will be downloaded, compiled, and executed. The Homebrew instructions similarly refer to mutable third-party taps without a pinned formula revision, checksum, or verified release artifact. Although the skill states that it does not install software automatically, it gives users authoritative installation commands as prerequisites. Following those commands executes dependency-controlled build and runtime code. A compromised maintainer account, repository, release process, Go module, transitive dependency, or Homebrew tap can therefore alter the effective payload after this skill has been audited. The affected tools receive valuable access: - `grizzly` can access Bear notes and Bear API credentials. - `clinote` receives Evernote authentication and note content. - `memo` obtains macOS Automatio ...[truncated 1399 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Pin Go tools to a reviewed immutable version rather than `@latest`, for example a specific semantic version. - Record the expected module checksum and verify it against a trusted release channel. - Pin Homebrew formulas or provide versioned release artifacts with SHA-256 checksums. - Prefer official vendor-maintained tools and repositories where available. - Document the repository owner, reviewed version, release date, expected checksum, and required permissions. - Re-audit before changing a pinned version. - Recommend installation in a constrained environment where feasible. - Apply least privilege: - Limit integrations to only required notebooks, databases, or vaults. - Avoid granting broad Automation access unless necessary. - Revoke tokens and application permissions when integrations are no longer used. - Clearly distinguish optional user installation guidance from commands the agent is permitted to execute. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
notion.md:25
Finding
Notion API Token Is Exposed Through Process Command-Line Arguments<![CDATA[ ## Vulnerability Details **File Location**: `notion.md:25-29` and `notion.md:43-68` **Vulnerability Type**: Credential exposure through command-line arguments **Risk Level**: Medium ### Complete Code Snippet ```bash NOTION_KEY=$(cat ~/.config/notion/api_key) # the user's own file; never copied into ~/Clawic/data/ AUTH=(-H "Authorization: Bearer $NOTION_KEY" -H "Notion-Version: 2025-09-03" -H "Content-Type: application/json") ``` The array is expanded into each `curl` invocation: ```bash # search curl -sX POST "https://api.notion.com/v1/search" "${AUTH[@]}" \ -d '{"query": "pricing"}' # create a note as a database row curl -sX POST "https://api.notion.com/v1/pages" "${AUTH[@]}" \ -d '{ "parent": {"database_id": "'"$DB"'"}, "properties": { "Name": {"title": [{"text": {"content": "Pricing: staying at three tiers"}}]}, "Date": {"date": {"start": "2026-07-26"}}, "Type": {"select": {"name": "Meeting"}}, "Tags": {"multi_select": [{"name": "product"}, {"name": "pricing"}]} } }' # add body content to that page curl -sX PATCH "https://api.notion.com/v1/blocks/$PAGE_ID/children" "${AUTH[@]}" \ -d '{"children": [ {"type":"heading_2","heading_2":{"rich_text":[{"text":{"content":"Decisions"}}]}}, {"type":"bulleted_list_item","bulleted_list_item":{"rich_text":[{"text":{"content":"Three tiers stay; revisit at 500 customers"}}]}}, {"type":"to_do","to_do":{"rich_text":[{"text":{"content":"@alice: send the pricing deck — 2026-08-04"}}],"checked":false}} ]}' # read a page and its content curl -s "https://api.notion.com/v1/pages/$PAGE_ID" "${AUTH[@]}" curl -s "https://api.notion.com/v1/blocks/$PAGE_ID/children" "${AUTH[@]}" ``` ### Technical Analysis A shell array does not conceal its values from the operating system. Expanding `"${AUTH[@]}"` causes the full `Authorization: Bearer ...` header to become an argument in the `curl` process command line. Depending on the operating system and process-monitorin ...[truncated 1698 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Do not place bearer tokens directly in command-line arguments. - Use a protected temporary curl configuration file: ```bash umask 077 curl_cfg="$(mktemp "${TMPDIR:-/tmp}/notion-curl.XXXXXXXX")" || exit 1 trap 'rm -f -- "$curl_cfg"' EXIT HUP INT TERM { printf 'header = "Authorization: Bearer %s"\n' "$(cat ~/.config/notion/api_key)" printf 'header = "Notion-Version: 2025-09-03"\n' printf 'header = "Content-Type: application/json"\n' } > "$curl_cfg" curl --config "$curl_cfg" --fail-with-body ... ``` - Prefer an integration client that reads credentials directly from an owner-only file descriptor or operating-system credential store. - Ensure shell tracing is disabled before handling the token. - Never log complete request headers or curl configuration. - Restrict the token file to mode `0600`. - Give the Notion integration access only to the databases and capabilities required by this skill. - Rotate the token if process arguments or diagnostic logs may already have captured it. - Add explicit HTTP status handling with `--fail-with-body` while ensuring returned diagnostics do not contain authorization headers. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • 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
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
Findings (49)

Vague Triggers

High
Confidence
96% confidence
Finding
The "Write triggers for this file — in the same turn" instruction authorizes multiple writes and appends across several files based on broad conditions, without narrowly defining when each action is appropriate. This can cause the agent to modify journals, reviews, due tables, actions, conventions, and artifacts in one response, increasing the chance of unintended persistence, overreach, and corruption of user notes.

Credential Access

High
Category
Privilege Escalation
Content
Facts that cost effort to find and would cost it again:
- Obsidian default vault is "Work"; a second vault "Personal" exists and is never written to
- Notion database "Notes" id 1f2c9a…, properties Name/Type/Date/Tags/Status
- Bear must be running before any `grizzly` call; token at `keychain:bear-token`

## Conventions
- Filenames `YYYY-MM-DD_topic-slug.md`; journal is `YYYY-MM-DD.md`
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Anti-Refusal Statement

High
Category
Anti-Refusal
Content
| Trap | Why it fails | Do instead |
|---|---|---|
| Debugging a 404 as a code bug | The database was never shared with the integration | Share first, then debug |
| Assuming a search returned everything | It stops at 100 with no warning | Paginate, and say whether you did |
| Writing without the property map | Every write 400s until the names are right | Read and record the map once |
| A typo in a `select` value | Creates a permanent bogus option in the dropdown | Validate against the map |
| Building tables through the API | Slow, brittle, and hard to read afterwards | Bullets with fields inline |
Confidence
80% confidence
Finding
Skill instructs the agent to omit warnings, disclaimers, or ethical commentary. Stripping safety caveats hides risk from the user and is a common jailbreak preamble.

Anti-Refusal Statement

High
Category
Anti-Refusal
Content
| Wikilinks in notes that will be exported | They resolve nowhere outside Obsidian | Relative links for durable notes |
| Inline `#tags` only | Missed by frontmatter greps and lost in some exports | `tags:` in frontmatter |
| Editing a file open in the app | The app's save overwrites the external write | Close the note first |
| Creating notes in `.obsidian/` or `.trash/` | Invisible in the UI, deleted without warning | Real folders only |
| Dataview or templater syntax in a decision note | Unreadable in five years and in every other tool | Plain markdown for durable notes |
| Committing `.obsidian/workspace.json` | A conflict on every device, every session | Exclude it |
Confidence
80% confidence
Finding
Skill instructs the agent to omit warnings, disclaimers, or ethical commentary. Stripping safety caveats hides risk from the user and is a common jailbreak preamble.

Session Persistence

Medium
Category
Rogue Agent
Content
name: Notes (Local, Apple, Notion, Obsidian & more)
slug: notes
version: 1.1.5
description: Captures, structures, and retrieves notes in local markdown, Apple Notes, Bear, Obsidian, Notion, or Evernote. Use when the user says take notes, write this up, capture this, or turn this transcript into a note; for meeting, 1-on-1, decision, journal, project, or research notes; when a note must land in a specific app or vault; when action items need owners and real dates; when a note cannot be found again and titles, tags, folders, or an index are the problem; when quick captures pile up untriaged; when a decision needs a durable record; when a vault shows conflicted copies, duplicates, or links broken by a rename; when notes must move between apps, be exported, or be backed up; and when something is too sensitive to write down at all. Not for journaling practice and prompts (`journal`), meeting facilitation and agendas (`meetings`), Notion API development (`notion-api-integration`), running a to-do list (`task-list`), or growing a linked atomic-note knowledge base (`pkm`).
homepage: https://clawic.com/skills/notes
changelog: "Clearer disclosure of what is stored and where"
metadata:
Confidence
95% confidence
Finding
This skill is explicitly designed for session persistence: it reads prior memory, writes durable notes before session end, and maintains action, contact, and project records across sessions. While persistence is core functionality rather than overtly malicious, it creates real privacy and data-retention risk if invoked unintentionally or used on sensitive content, particularly since some configured routes may send note content to third-party platforms like Notion or Evernote.

Vague Triggers

Medium
Confidence
94% confidence
Finding
The skill description contains very broad activation phrases such as 'take notes', 'write this up', and 'capture this', which overlap with ordinary conversation. That can cause unintended invocation and automatic persistence of sensitive user content into local files or external note platforms, especially because the skill is designed to store durable records and may route content across multiple destinations.

Vague Triggers

Medium
Confidence
93% confidence
Finding
The note-type trigger table includes generic phrases like 'we talked about', 'status', 'remember', and 'today I', which lack sufficient scope constraints. Because these triggers drive type selection and storage behavior, they increase the chance of misclassification or unintended note creation, potentially placing sensitive content into persistent files or synced services.

Context-Inappropriate Capability

Medium
Confidence
88% confidence
Finding
The guidance explicitly instructs the skill to update shared contact records (`contacts.md`) as part of chasing action items, which expands behavior beyond note capture/retrieval into cross-file state mutation about people. That scope expansion can cause unintended side effects, stale or privacy-sensitive metadata changes, and silent corruption of a separate source of truth without a direct user request.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
These instructions direct deletion and modification of tracker content based on age and review rules, including deleting overdue items and moving completed rows, but do not require an explicit warning or confirmation before destructive changes. In a note-management context, silent deletions are especially risky because users may treat the tracker as an authoritative historical record and lose information they expected to keep.

Vague Triggers

Medium
Confidence
94% confidence
Finding
The 'Write triggers for this file — in the same turn' instruction creates a broad automatic-write policy that can fire on many ordinary conversations about commitments, completions, dates, contacts, reviews, and open threads. Because it couples interpretation with immediate writes across multiple files, it increases the chance of unintended invocation, surprise persistence, and cascading edits or deletions without a clearly scoped user command.

Unsafe Defaults

Medium
Category
Tool Misuse
Content
memo notes -a "2026-07-26 Pricing three tiers"
```

- **Delete the temp file after pasting.** `/tmp` is world-readable on a shared machine, and a meeting note left there outlives the session.
- **Put the date in the title**, because Apple Notes sorts by modification and shows no filename. Without it, the note is dated by whenever it was last touched.
- Markdown is rendered on paste for headings and lists; tables are not supported and arrive as plain text. Keep tables out of notes routed here — use bullets with a date suffix instead.
Confidence
70% confidence
Finding
Tool defaults are unsafe or overly permissive (e.g. disabled TLS verification, no authentication, world-writable permissions). Unsafe defaults widen the attack surface.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The skill instructs writing to local files as fallback and bookkeeping behavior without a clear user-facing warning that these files will be modified. Users may believe only Apple Notes is affected, while the skill actually changes local memory/configuration artifacts, undermining informed consent and auditability.

Context-Inappropriate Capability

Medium
Confidence
95% confidence
Finding
The file directs the skill to modify unrelated local state files (`memory.md`, `config.yaml`, `Note Map`, and `actions.md`) as part of handling Apple Notes. That expands the skill’s authority beyond note capture/retrieval and can silently persist or alter user state in ways the user did not explicitly request, creating a confused-deputy/persistent side-effect risk.

Vague Triggers

Medium
Confidence
93% confidence
Finding
The "write triggers" instruction is broad and automatic, requiring updates to multiple files in the same turn based on loosely defined conditions such as folder names, routing choice, and action items found in notes. This can cause unintended propagation of note content and metadata into several local files, increasing the chance of overcollection, corruption, or privacy leakage.

Description-Behavior Mismatch

Medium
Confidence
95% confidence
Finding
The skill goes beyond Bear note capture/retrieval and instructs writes to several local control files such as memory.md, config.yaml, Note Map, actions.md, and artifacts/tag-taxonomy.md. This creates hidden side effects outside the user’s apparent request scope, increasing the chance of unintended persistence, configuration drift, or modification of unrelated local state.

Context-Inappropriate Capability

Medium
Confidence
96% confidence
Finding
The instruction to extract every action item from Bear notes into actions.md expands the skill into task management, which the metadata explicitly says is out of scope. This can silently create or alter a task system based on note contents, causing unintended data propagation and potentially exposing sensitive note content in another file.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The trigger section mandates additional writes to local files without an explicit user-facing warning, so the user may believe they are only interacting with Bear while the agent also mutates other files. Hidden writes are dangerous because they undermine informed consent, make auditing harder, and can persist sensitive metadata or operational state unexpectedly.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill handles transcripts, dictated notes, recordings of other people, and potentially secrets such as PINs, passwords, and card numbers, but it does not present a clear front-door warning that using the skill may store sensitive content. Although the file contains some internal cautions, they are buried in operational guidance rather than exposed as a user-facing safeguard, so users may unintentionally cause sensitive data to be written to local files or external note systems.

Vague Triggers

Medium
Confidence
96% confidence
Finding
The phrase 'in the same turn, no ceremony' combined with multiple automatic write triggers can cause the skill to persist user content immediately without an explicit confirmation step. In a note-capture skill, that increases the chance of unintended activation or accidental storage of conversational content, especially when the user is discussing rather than explicitly requesting durable storage.

Context-Inappropriate Capability

Medium
Confidence
91% confidence
Finding
The instruction to write the decider and dissenter into a shared contacts database expands the scope of a note-taking skill into maintaining a people dossier without clear necessity or consent boundaries. This can cause unnecessary collection and propagation of sensitive interpersonal metadata, especially because dissent in decisions may be reputationally sensitive and the write is framed as automatic 'in the same turn.'

Vague Triggers

Medium
Confidence
95% confidence
Finding
The 'Write triggers for this file — in the same turn' instruction authorizes a wide set of follow-on writes across multiple files (`decisions`, project notes, contacts, actions, memory) based on a single note action. Because the trigger is broad and underspecified, an agent could perform unintended state changes, propagate mistakes across the knowledge base, or modify unrelated records without explicit confirmation from the user.

Vague Triggers

Medium
Confidence
90% confidence
Finding
The instruction to act "at the start of a session" creates an implicit auto-activation path that can trigger behavior before the user has clearly requested journaling or review work. Because it includes checking local note state and announcing overdue reviews, the skill may run in contexts unrelated to notes, causing unintended access to user data and surprising behavior.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The skill directs the agent to perform several persistent file modifications but does not instruct it to warn the user or obtain consent before doing so. In a notes skill, persistent writes are expected, but silent multi-file side effects are still dangerous because they can alter task trackers, review history, and conventions beyond what the user intended.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
|---|---|---|
| Unquoted colon in a title | Invalid YAML; every frontmatter grep silently misses the note | Quote titles containing colons |
| Trusting the filesystem date | Copy, sync, or restore rewrites it | `date:` in frontmatter |
| Renaming without checking inbound links | Dead links found a month later, cause forgotten | Grep, move, update, same turn |
| Wikilinks in plain files | Resolve nowhere outside a wikilink-aware app | Relative markdown links |
| Spaces and accents in filenames | Break shell pipelines and some sync clients | Lowercase, hyphens, ASCII slug |
| A folder per subject | A note has three subjects and one folder | Folder by type (`retrieval.md`) |
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.

Vague Triggers

Medium
Confidence
90% confidence
Finding
The phrase 'Write triggers for this file — in the same turn' creates an implicit instruction for the agent to perform multiple file mutations whenever this document is used, without explicit user confirmation or tight scoping. In a notes skill that operates on local files, this can cause unintended writes to multiple files (the note, memory.md, index.md, and status counters), increasing the risk of overreach, silent state changes, and prompt-driven unauthorized file modification.

Static analysis

Detected: suspicious.exposed_secret_literal

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
sensitive.md:52