@wahack/pi-coding-agent 15.11.0

package/src/prompts/tools/patch.md

@@ -0,0 +1,70 @@
+Patches files given diff hunks. Primary tool for existing-file edits.
+
+<instruction>
+**Hunk Headers:**
+- `@@` — bare header when context lines unique
+- `@@ $ANCHOR` — anchor copied verbatim from file (full line or unique substring)
+**Anchor Selection:**
+1. Prefer bare `@@` when context lines alone are unique; otherwise choose highly specific anchor copied from file:
+   - full function signature
+   - class declaration
+   - unique string literal/error message
+   - config key with uncommon name
+2. On "Found multiple matches": add context lines, use multiple hunks with separate anchors, or use longer anchor substring
+**Context Lines:**
+Use enough ` `-prefixed lines to make match unique (usually 2–8)
+When editing structured blocks (nested braces, tags, indented regions), include opening and closing lines so edit stays inside block
+</instruction>
+
+<parameters>
+```ts
+// Input is { path: string, edits: Entry[] }. `path` is required and applies to every entry.
+type Entry =
+   // Diff is one or more hunks for the top-level path.
+   // - Each hunk begins with "@@" (anchor optional).
+   // - Each hunk body only has lines starting with ' ' | '+' | '-'.
+   // - Each hunk includes at least one change (+ or -).
+   | { op: "update", diff: string }
+   // Diff is full file content, no prefixes.
+   | { op: "create", diff: string }
+   // No diff for delete.
+   | { op: "delete" }
+   // New path for update+move from the top-level path.
+   | { op: "update", rename: string, diff: string }
+```
+</parameters>
+
+<output>
+Returns success/failure; on failure, error message indicates:
+- "Found multiple matches" — anchor/context not unique enough
+- "No match found" — context lines don't exist in file (wrong content or stale read)
+- Syntax errors in diff format
+</output>
+
+<critical>
+- You MUST read the target file before editing
+- You MUST copy anchors and context lines verbatim (including whitespace)
+- You NEVER use anchors as comments (no line numbers, location labels, placeholders like `@@ @@`)
+- You NEVER place new lines outside the intended block
+- If edit fails or breaks structure, you MUST re-read the file and produce a new patch from current content — you NEVER retry the same diff
+- NEVER use edit to fix indentation, whitespace, or reformat code. Formatting is a single command run once at the end (`bun fmt`, `cargo fmt`, `prettier --write`, etc.) — not N individual edits. If you see inconsistent indentation after an edit, leave it; the formatter will fix all of it in one pass.
+</critical>
+
+<examples>
+# Create
+`edit {"path":"hello.txt","edits":[{"op":"create","diff":"Hello\n"}]}`
+# Update
+`edit {"path":"src/app.py","edits":[{"op":"update","diff":"@@ def greet():\n def greet():\n-print('Hi')\n+print('Hello')\n"}]}`
+# Rename
+`edit {"path":"src/app.py","edits":[{"op":"update","rename":"src/main.py","diff":"@@\n …\n"}]}`
+# Delete
+`edit {"path":"obsolete.txt","edits":[{"op":"delete"}]}`
+# Multiple entries
+All entries in one call apply to the top-level `path`; use separate calls for different files.
+</examples>
+
+<avoid>
+- Generic anchors: `import`, `export`, `describe`, `function`, `const`
+- Repeating same addition in multiple hunks (duplicate blocks)
+- Full-file overwrites for minor changes (acceptable for major restructures or short files)
+</avoid>

package/src/prompts/tools/read.md

@@ -0,0 +1,84 @@
+Read files, directories, archives, SQLite databases, images, documents, internal resources, and web URLs through a single `path` string.
+
+<instruction>
+- One tool for filesystem, archives, SQLite, images, documents (PDF/DOCX/PPTX/XLSX/RTF/EPUB/ipynb), internal URIs, and web URLs (reader-mode by default).
+- You SHOULD parallelize independent reads when exploring related files.
+- You SHOULD reach for `read` — not a browser/puppeteer tool — for fetching web content.
+</instruction>
+
+## Parameters
+
+- `path` — required. Local path, internal URI (`skill://`, `agent://`, `artifact://`, `history://`, `memory://`, `rule://`, `local://`, `vault://`, `mcp://`, `omp://`, `issue://`, `pr://`), or URL. Append `:<sel>` for line ranges, raw mode, or special modes (e.g. `src/foo.ts:50-200`, `src/foo.ts:raw`, `db.sqlite:users:42`).
+
+## Selectors
+
+Append `:<sel>` to `path`. The bare path falls back to the default mode.
+
+- _(none)_ — parseable code → structural summary (signatures kept, bodies elided); other files → read from the start (up to {{DEFAULT_LIMIT}} lines).
+- `:50` / `:50-` — read from line 50 onward.
+- `:50-200` — lines 50–200 inclusive.
+- `:50+150` — 150 lines starting at line 50.
+- `:20+1` — anchor on line 20 (single-range reads expand by ≤1 leading and ≤3 trailing context lines).
+- `:5-16,960-973` — multiple ranges in one call (sorted, overlaps merged). Multi-range mode returns exact bounds with no context padding.
+- `:raw` — verbatim text; no anchors, no summary, no line prefixes.
+- `:2-4:raw` or `:raw:2-4` — range AND verbatim; the two compose in either order.
+- `:conflicts` — one-line-per-block index of every unresolved git merge conflict.
+
+# Files
+
+- Reading a directory path returns a depth-limited dirent listing.
+{{#if IS_HL_MODE}}
+- Reading a file with an explicit selector emits a file snapshot tag header and numbered lines: `[src/foo.ts#1A2B]` then `41:def alpha():`. Copy the `[PATH#TAG]` header for anchored edits; ops use bare line numbers. NEVER fabricate the tag.
+{{else}}
+{{#if IS_LINE_NUMBER_MODE}}
+- Reading a file with an explicit selector returns lines prefixed with line numbers: `41|def alpha():`.
+{{/if}}
+{{/if}}
+- Parseable code without a selector returns a **structural summary**: declarations kept, large bodies collapsed to `..` (merged brace pair) or `…` (standalone). Summarized output ends with a footer demonstrating the multi-range selector you can use to recover the elided bodies, e.g.:
+
+  `[NN lines elided; re-read needed ranges, e.g. <path>:5-16,40-80]`
+
+  Re-issue **only the relevant range(s)** using the multi-range selector (e.g. `<path>:5-16,120-200`). NEVER guess what's inside `..` / `…` — those markers carry no content. NEVER re-read the whole file or use `:raw` when targeted ranges suffice.
+
+# Documents & Notebooks
+
+Extracts text from PDF, Word, PowerPoint, Excel, RTF, and EPUB. Notebooks (`.ipynb`) are shown as editable `# %% [type] cell:N` text; edits round-trip back to the underlying JSON preserving notebook metadata. Add `:raw` to a notebook to bypass the converter and read the JSON directly.
+
+# Images
+
+{{#if INSPECT_IMAGE_ENABLED}}
+Reading an image path returns metadata (mime, bytes, dimensions, channels, alpha). For actual visual analysis, call `inspect_image` with the path and a question describing what to inspect.
+{{else}}
+Reading an image path returns the decoded image inline (PNG, JPEG, GIF, WEBP) for direct visual analysis.
+{{/if}}
+
+# Archives
+
+Supports `.tar`, `.tar.gz`, `.tgz`, `.zip`. Use `archive.ext:path/inside/archive` to read a member, and append a normal selector to the inner path: `archive.zip:dir/file.ts:50-60`.
+
+# SQLite
+
+For `.sqlite`, `.sqlite3`, `.db`, `.db3`:
+- `file.db` — list tables with row counts
+- `file.db:table` — schema + sample rows
+- `file.db:table:key` — single row by primary key
+- `file.db:table?limit=50&offset=100` — paginated rows
+- `file.db:table?where=status='active'&order=created:desc` — filtered rows
+- `file.db?q=SELECT …` — read-only SELECT query
+
+# URLs
+
+- Default reader-mode: HTML pages, GitHub issues/PRs, Stack Overflow, Wikipedia, Reddit, NPM, arXiv, RSS/Atom, JSON endpoints, PDFs → clean text/markdown.
+- `:raw` returns untouched HTML; line selectors (`:50`, `:50-100`, `:50+150`) paginate the cached fetched output.
+- Bare `host:port` URLs collide with the selector grammar — add a trailing slash before the selector: `https://example.com/:80`.
+
+# Internal URIs
+
+`skill://<name>`, `agent://<id>`, `artifact://<id>`, `history://<agentId>`, `memory://root`, `rule://<name>`, `local://<name>.md`, `vault://<vault>/<path>`, `mcp://<uri>`, `omp://<doc>.md`, `issue://<N>`, and `pr://<N>` resolve transparently and accept the same line selectors as filesystem paths. Use `artifact://<id>` to recover full output that a previous bash/eval/tool result spilled or truncated. `history://<agentId>` is an agent's transcript as concise markdown; bare `history://` lists agents.
+
+<critical>
+- You MUST use `read` for every file, directory, archive, and URL inspection. `cat`, `head`, `tail`, `less`, `more`, `ls`, `tar`, `unzip`, `curl`, `wget` are FORBIDDEN — any such bash call is a bug, regardless of how short or convenient it looks.
+- You MUST prefer `read` over a browser/puppeteer tool for URL content; only reach for a browser when `read` cannot deliver reasonable content.
+- For line ranges, append the selector to `path` (`path="src/foo.ts:50-200"`, `path="src/foo.ts:50+150"`). NEVER substitute `sed -n`, `awk NR`, or `head`/`tail` pipelines.
+- Summary footer names ranges to re-read? Re-issue ONLY the ranges you need via the multi-range selector. NEVER guess what's inside `..` / `…` markers — they carry no content.
+</critical>

package/src/prompts/tools/recall.md

@@ -0,0 +1,5 @@
+Search long-term memory for relevant information. Returns raw matching entries ranked by relevance.
+
+Use proactively — before answering questions about past conversations, user preferences, project decisions, or any topic where prior context would help accuracy. When in doubt, recall first.
+
+Prefer `recall` when you need specific facts or entries. Use `reflect` instead when you need a synthesized answer across many memories.

package/src/prompts/tools/reflect.md

@@ -0,0 +1,5 @@
+Generate a synthesized answer by reasoning over long-term memory. Unlike `recall`, `reflect` blends relevant memories into a coherent response.
+
+Use for open-ended questions spanning many stored facts: "What do you know about this user?", "Summarize project decisions.", "What are my preferences for X?"
+
+Optional `context` parameter focuses the synthesis on a specific angle or sub-topic.

package/src/prompts/tools/render-mermaid.md

@@ -0,0 +1,9 @@
+Convert Mermaid graph source into ASCII diagram output.
+
+Parameters:
+- `mermaid` (required): Mermaid graph text to render.
+- `config` (optional): JSON render configuration (spacing and layout options).
+
+Behavior:
+- Returns ASCII diagram text.
+- Saves full output to `artifact://<id>`.

package/src/prompts/tools/replace.md

@@ -0,0 +1,30 @@
+Performs string replacements in files with fuzzy whitespace matching.
+
+<instruction>
+- Params MUST be `{ path, edits }`; `path` is required at the top level and applies to every replacement
+- You MUST use the smallest `old_text` that uniquely identifies the change
+- If `old_text` is not unique, you MUST expand it with more context or use `all: true` to replace all occurrences
+- You SHOULD prefer editing existing files over creating new ones
+</instruction>
+
+<output>
+Returns success/failure status. On success, file modified in place with replacement applied. On failure (e.g., `old_text` not found or matches multiple locations without `all: true`), returns error describing issue.
+</output>
+
+<critical>
+- You MUST read the file at least once in the conversation before editing. Tool errors if you attempt edit without reading file first.
+</critical>
+
+<bash-alternatives>
+Replace is content-addressed — you identify *what* to change by its text.
+
+For pattern-addressed bulk changes, bash is more efficient:
+
+|Operation|Command|
+|---|---|
+|Regex replace|`sd 'pattern' 'replacement' file`|
+|Bulk replace across files|`sd 'pattern' 'replacement' **/*.ts`|
+
+Use Replace when _content itself_ identifies location; use `ast_edit` for structure-aware codemods.
+NEVER use `sed -i`/`perl -i`/heredoc redirection for edits — those calls are blocked; use this tool or `write`.
+</bash-alternatives>

package/src/prompts/tools/resolve.md

@@ -0,0 +1,9 @@
+Resolves a pending action by either applying or discarding it.
+- `action` is required:
+  - `"apply"` persists / submits the pending action.
+  - `"discard"` rejects the pending action.
+- `reason` is required: one short complete sentence explaining why, starting with a capital letter and ending with a period.
+- `extra` (optional) is free-form metadata passed to the resolving tool. When the pending action is a plan-approval gate, supply `extra.title` (kebab/PascalCase slug for the approved plan filename). For preview-style pending actions (e.g. `ast_edit`), `extra` is unused.
+
+Valid whenever a pending action exists — either a preview-style staging (e.g. `ast_edit`) or a long-lived approval gate.
+Call fails with an error when no pending action exists.

package/src/prompts/tools/retain.md

@@ -0,0 +1,6 @@
+Store one or more facts in long-term memory for future sessions.
+
+Use for durable, reusable knowledge: user preferences, project decisions, architectural choices, anything that improves future responses.
+Ephemeral task state does not belong here.
+
+Each item MUST be specific and self-contained — include who, what, when, and why. Batch related facts in a single call; they are deduplicated and consolidated.

package/src/prompts/tools/rewind.md

@@ -0,0 +1,13 @@
+End an active checkpoint. Rewind context to it, replacing intermediate exploration with your report.
+
+Call immediately after `checkpoint`-started investigative work.
+
+Requirements:
+- `report` is REQUIRED and MUST be concise, factual, and actionable.
+- Include key findings, decisions, and any unresolved risks.
+- AVOID raw scratch logs unless essential.
+- You MUST call this before yielding if a checkpoint is active.
+
+Behavior:
+- If no checkpoint is active, this tool errors.
+- On success, the session rewinds and keeps your report as retained context.

package/src/prompts/tools/search-tool-bm25.md

@@ -0,0 +1,32 @@
+Search hidden tool metadata to discover and activate tools.
+
+Activate hidden tools (MCP and built-in) when you need a capability not in your active tool set.
+{{#if hasDiscoverableMCPServers}}
+Discoverable MCP servers in this session: {{#list discoverableMCPServerSummaries join=", "}}{{this}}{{/list}}.
+{{/if}}
+{{#if hasDiscoverableBuiltinTools}}
+Discoverable built-in tools: {{#list discoverableBuiltinToolNames join=", "}}{{this}}{{/list}}.
+{{/if}}
+{{#if discoverableToolCount}}
+Total discoverable tools available: {{discoverableToolCount}}.
+{{/if}}
+Input:
+- `query` — required natural-language or keyword query
+- `limit` — optional maximum number of tools to return and activate (default `8`)
+
+Behavior:
+- Matches against tool name, label, server name, description/summary, and input schema keys
+- Activates the top matching tools for the rest of the current session
+- Repeated searches add to the active tool set; they do not remove earlier selections
+- Newly activated tools become available before the next model call in the same overall turn
+
+Notes:
+- Start with `limit` 5–10 if unsure.
+
+Not for repository/file/code search. Tool discovery only.
+
+Returns JSON with:
+- `query`
+- `activated_tools` — tools activated by this search call
+- `match_count` — number of ranked matches returned by the search
+- `total_tools`

package/src/prompts/tools/search.md

@@ -0,0 +1,24 @@
+Searches files using powerful regex matching.
+
+<instruction>
+- Supports Rust regex syntax (RE2-style — no lookaround or backreferences). Use line anchors or post-filters instead of (?!…)/(?<!…)
+- `paths` accepts either one string or an array of files, directories, globs, or internal URLs. Optional: when omitted or empty it searches the workspace root (`.`). Prefer scoping to specific paths when you know them.
+- For multiple targets, pass an array with one target per element: `["src", "tests"]`.
+- Cross-line patterns are detected from literal `\n` or escaped `\\n` in `pattern`
+</instruction>
+
+<output>
+{{#if IS_HL_MODE}}
+- Text output emits a file snapshot tag header per matched file plus numbered lines: `[src/login.ts#1A2B]`, `*42:if (user.id) {` (match), ` 43:return user;` (context). Copy the header for anchored edits; ops use bare line numbers.
+{{else}}
+{{#if IS_LINE_NUMBER_MODE}}
+- Text output is line-number-prefixed
+{{/if}}
+{{/if}}
+</output>
+
+<critical>
+- You MUST use the built-in `search` tool for any content search. NEVER shell out to `grep`, `rg`, `ripgrep`, `ag`, `ack`, `git grep`, `awk`, `sed`-for-search, or any other CLI search via Bash — even for a single match, even "just to check quickly", even piped through other commands.
+- Bash `grep`/`rg` loses `.gitignore` semantics, bypasses result limits, and wastes tokens. The `search` tool is faster, structured, and already wired into the workspace — there is no scenario where Bash search is preferable.
+- If the search is open-ended, requiring multiple rounds, you MUST use the Task tool with the explore subagent instead of chaining `search` calls yourself.
+</critical>

package/src/prompts/tools/ssh.md

@@ -0,0 +1,31 @@
+Runs commands on remote hosts.
+
+<commands>
+**linux/bash, linux/zsh, macos/bash, macos/zsh** — Unix-like:
+- Files: `ls`, `cat`, `head`, `tail`, `grep`, `find`
+- System: `ps`, `top`, `df`, `uname` (all), `free` (Linux only)
+- Navigation: `cd`, `pwd`
+**windows/bash, windows/sh** — Windows Unix layer (WSL, Cygwin, Git Bash):
+- Files/System/Navigation: same as Unix-like above, minus `free`
+**windows/powershell** — PowerShell:
+- Files: `Get-ChildItem`, `Get-Content`, `Select-String`
+- System: `Get-Process`, `Get-ComputerInfo`
+- Navigation: `Set-Location`, `Get-Location`
+**windows/cmd** — Command Prompt:
+- Files: `dir`, `type`, `findstr`, `where`
+- System: `tasklist`, `systeminfo`
+- Navigation: `cd`, `echo %CD%`
+</commands>
+
+<critical>
+You MUST verify the shell type from "Available hosts" and use matching commands.
+</critical>
+
+<examples>
+# List files: Linux
+Host: server1 (10.0.0.1) | linux/bash. Command: `ls -la /home/user`
+# Show running processes: Windows cmd
+Host: winbox (192.168.1.5) | windows/cmd. Command: `tasklist /v`
+# Get system info: macOS
+Host: macbook (10.0.0.20) | macos/zsh. Command: `uname -a && sw_vers`
+</examples>

package/src/prompts/tools/task-summary.md

@@ -0,0 +1,17 @@
+<task-result id="{{id}}" agent="{{agentName}}" status="{{status}}" duration="{{duration}}">
+{{#if meta}}<meta lines="{{meta.lineCount}}" size="{{meta.charSize}}" />{{/if}}
+{{#if truncated}}
+<preview full-output="agent://{{id}}">
+{{preview}}
+</preview>
+{{else}}
+<output>
+{{preview}}
+</output>
+{{/if}}
+{{#if mergeSummary}}
+<merge-summary>
+{{mergeSummary}}
+</merge-summary>
+{{/if}}
+</task-result>

package/src/prompts/tools/task.md

@@ -0,0 +1,88 @@
+{{#if batchEnabled}}Spawns subagents to work in the background — one per `tasks[]` item; a single spawn is a one-item batch.{{else}}Spawns ONE subagent per call to work in the background.{{/if}}
+
+- Spawning is non-blocking: the call returns immediately with the agent id{{#if batchEnabled}}s{{/if}} and job id{{#if batchEnabled}}s{{/if}}; each result is delivered automatically when that agent yields.
+- Parallelism = {{#if batchEnabled}}`tasks[]` items in one call, and/or multiple `task` calls in one assistant message{{else}}multiple `task` calls in one assistant message{{/if}}. Concurrency is bounded at {{MAX_CONCURRENCY}} running subagents per session.
+- If genuinely blocked on a result, wait with `job poll`; otherwise keep working. `job cancel` terminates a task and **cannot carry a message** — only for stalled/abandoned work.
+{{#if ircEnabled}}
+- Coordinate with running agents via `irc` using their ids. Agents reach you and their siblings live the same way.
+{{/if}}
+
+<lifecycle>
+- Finished agents stay alive: `idle` first, then `parked` after a TTL.{{#if ircEnabled}} Both remain addressable and revivable: messaging one via `irc` wakes it and runs your message as a follow-up turn. **Prefer messaging an agent that already holds the relevant context over spawning fresh** — check `irc` op:"list" for candidates.{{/if}}
+- `history://<id>` is the agent's transcript; `agent://<id>` its latest output artifact.
+</lifecycle>
+
+<parameters>
+- `agent`: agent type to spawn
+{{#if batchEnabled}}
+- `context`: shared background prepended to every assignment — goal, constraints, shared contract (see context-fmt); REQUIRED, session-specific only
+- `tasks`: tasks to spawn — one subagent per item, all in parallel:
+  - `assignment`: complete self-contained instructions; one-liners and missing acceptance criteria are PROHIBITED
+  - `id`: stable agent id, CamelCase, ≤32 chars; generated when omitted
+  - `description`: UI label only — subagent never sees it
+{{#if isolationEnabled}}
+  - `isolated`: run this spawn in an isolated env; returns patches. Isolated agents are torn down at completion — not addressable afterwards
+{{/if}}
+{{else}}
+- `id`: stable agent id, CamelCase, ≤32 chars; generated when omitted
+- `description`: UI label only — subagent never sees it
+- `assignment`: complete self-contained instructions; one-liners and missing acceptance criteria are PROHIBITED
+{{#if isolationEnabled}}
+- `isolated`: run in isolated env; returns patches. Isolated agents are torn down at completion — not addressable afterwards
+{{/if}}
+{{/if}}
+</parameters>
+
+<rules>
+- **Maximize fan-out.** Issue the widest {{#if batchEnabled}}`tasks[]` batch (or set of parallel `task` calls){{else}}set of parallel `task` calls{{/if}} the work decomposes into. NEVER serialize work that could run concurrently.
+- **Subagents do not verify, lint, or format.** Every assignment MUST instruct the subagent to skip all gates, formatters, and project-wide build/test/lint. You run them once at the end across the union of changed files.
+- No globs, no "update all", no package-wide scope. Fan out.
+- NEVER slow down or serialize because tasks might overlap on some files. Agents resolve collisions among themselves in real time.
+- Subagents have no conversation history. Every fact, file path, and direction they need MUST be explicit in {{#if batchEnabled}}`context` or the item's `assignment`{{else}}the `assignment`{{/if}}.
+{{#if batchEnabled}}
+- **Shared background** lives in `context` once — never duplicated across assignments. Pass large payloads via `local://<path>` URIs, not inline.
+{{else}}
+- **Shared background**: write it ONCE to a `local://` file (e.g. `local://ctx.md`) and reference that path in each assignment. Pass large payloads via `local://<path>` URIs, not inline.
+{{/if}}
+- Prefer agents that investigate **and** edit in one pass; only spin a read-only discovery step when affected files are genuinely unknown.
+- **Read-only agents**: Agents tagged READ-ONLY (e.g. `explore`) have no edit/write/command tools. NEVER hand them an assignment that requires changing files or running commands. Use them to investigate and report back; do the edits yourself or delegate to a writing agent (`task`, `oracle`, `designer`).
+- **No reasoning offload**: NEVER offload reasoning, analysis, design, or decision-making to `quick_task` or `explore` — they run minimal-effort / small models for mechanical lookups and data collection only. Keep judgment and synthesis in your own context; delegate hard thinking to `task`, `plan`, or `oracle`.
+</rules>
+
+<parallelization>
+{{#if ircEnabled}}
+Test: can task B run correctly without seeing A's output? If no, sequence A → B — **unless** B can reasonably ask A for the missing piece over `irc`. Live coordination beats a serial waterfall when the contract is small and easy to describe in a DM.
+Still sequence when one task produces a large, evolving contract (generated types, schema migration, core module API) the other consumes wholesale — IRC round-trips do not replace a finished artifact.
+Parallel when tasks touch disjoint files, are independent refactors/tests, or only need occasional clarification that can be resolved peer-to-peer.
+{{else}}
+Test: can task B run correctly without seeing A's output? If no, sequence A → B.
+Sequential when one task produces a contract (types, API, schema, core module) the other consumes.
+Parallel when tasks touch disjoint files or are independent refactors/tests.
+{{/if}}
+{{#if ircEnabled}}Sequenced follow-ups SHOULD message the agent that produced the prerequisite — it already holds the context.{{/if}}
+</parallelization>
+
+{{#if batchEnabled}}
+<context-fmt>
+# Goal         ← one sentence: what the batch accomplishes
+# Constraints  ← MUST/NEVER rules and session decisions
+# Contract     ← exact types/signatures if tasks share an interface
+</context-fmt>
+{{/if}}
+
+<assignment-fmt>
+# Target       ← exact files and symbols; explicit non-goals
+# Change       ← step-by-step add/remove/rename; APIs and patterns
+# Acceptance   ← observable result; no project-wide commands
+</assignment-fmt>
+
+<agents>
+{{#if spawningDisabled}}
+Agent spawning is disabled for this context.
+{{else}}
+{{#list agents join="\n"}}
+# {{name}}{{#if readOnly}} — READ-ONLY (no edit/write/exec tools){{/if}}
+{{description}}
+{{/list}}
+{{/if}}
+</agents>

package/src/prompts/tools/todo.md

@@ -0,0 +1,62 @@
+**Tasks are referenced by their verbatim content string, not by any auto-generated ID. There is no "task-1"/"task-N" identifier — the tool never emits one. Pass the task's content text in the `task` field.**
+
+Manages a phased task list. Pass `ops`: a flat array of operations.
+The next pending task is auto-promoted to `in_progress` after each completion.
+Allowed `op` values are only `init`, `start`, `done`, `drop`, `rm`, `append`, `note`, and `view`. `pending` is a task status, not an `op`; leave not-yet-started tasks implicit in `init`/`append` lists.
+
+## Operations
+
+|`op`|Required fields|Effect|
+|---|---|---|
+|`init`|`list: [{phase, items: string[]}]`|Initialize the full list (replaces any existing list)|
+|`start`|`task`|Mark in progress|
+|`done`|`task` or `phase`|Mark completed|
+|`drop`|`task` or `phase`|Mark abandoned|
+|`rm`|`task` or `phase` (optional)|Remove task or phase's tasks; omit both to clear the entire list|
+|`append`|`phase`, `items: string[]`|Append tasks to `phase`; lazily creates phase|
+|`note`|`task`, `text`|Append a note to a task. Reminders for future-you only.|
+|`view`|—|Read-only: echo the current list without modifying it|
+
+## Anatomy
+- **Task content**: 5–10 words, what is being done, not how. Used as the task identifier — unique.
+- **Phase name**: short noun phrase (e.g. `Foundation`, `Auth`, `Verification`). Used as the phase identifier — unique. Do not add prefixes like `1.`, `A)`, `Phase 1:`, etc.
+
+## Rules
+- Mark tasks done immediately after finishing.
+- Complete phases in order.
+- On blockers, `append` a new task to the active phase to unblock yourself, or `drop`.
+- `task` and `phase` fields reference content/name verbatim; keep them stable once introduced.
+- Lost track of exact task text? `view` echoes the full list — NEVER guess content from memory; a mismatched `task` string is an error.
+
+## When to create a list
+- Task requires 3+ distinct steps
+- User explicitly requests one
+- User provides a set of tasks to complete
+- New instructions arrive mid-task — capture before proceeding
+
+<examples>
+# Initial setup (multi-phase)
+`{"ops":[{"op":"init","list":[{"phase":"Foundation","items":["Scaffold crate","Wire workspace"]},{"phase":"Auth","items":["Port credential store","Wire OAuth providers"]},{"phase":"Verification","items":["Run cargo test"]}]}]}`
+# View current state (read-only)
+`{"ops":[{"op":"view"}]}`
+# Initial setup (single phase)
+`{"ops":[{"op":"init","list":[{"phase":"Implementation","items":["Apply fix","Run tests"]}]}]}`
+# Complete one task
+`{"ops":[{"op":"done","task":"Wire workspace"}]}`
+# Complete a whole phase
+`{"ops":[{"op":"done","phase":"Auth"}]}`
+# Remove all tasks
+`{"ops":[{"op":"rm"}]}`
+# Drop one task
+`{"ops":[{"op":"drop","task":"Run cargo test"}]}`
+# Append tasks to a phase
+`{"ops":[{"op":"append","phase":"Auth","items":["Handle retries","Run tests"]}]}`
+</examples>
+
+<critical>
+When the user hands you a multi-step plan — a phased todo, a numbered or bulleted checklist, or "N bugs/items/tasks" to work through:
+- You MUST `init` the list with EVERY item as its own task before doing the work.
+- Enumerate all of them;
+- NEVER summarize the plan into fewer tasks, sample "the important ones", drop items, or rely on memory to track the rest.
+The entire point is to remember every one.
+</critical>

package/src/prompts/tools/web-search.md

@@ -0,0 +1,10 @@
+Searches the web for up-to-date information beyond knowledge cutoff.
+
+<instruction>
+- You SHOULD prefer primary sources (papers, official docs) and corroborate key claims with multiple sources
+- You MUST include links for cited sources in the final response
+</instruction>
+
+<caution>
+Searches are performed automatically within a single API call—no pagination or follow-up requests needed.
+</caution>

package/src/prompts/tools/write.md

@@ -0,0 +1,14 @@
+Creates or overwrites file at specified path.
+
+<conditions>
+- Creating new files explicitly required by task
+- Replacing entire file contents when editing would be more complex
+- Supports `.tar`, `.tar.gz`, `.tgz`, and `.zip` archive entries via `archive.ext:path/inside/archive`
+- Supports SQLite row operations via `db.sqlite:table` (insert), `db.sqlite:table:key` (update with JSON content, delete with empty content)
+</conditions>
+
+<critical>
+- You SHOULD use Edit tool for modifying existing files (more precise, preserves formatting)
+- You NEVER create documentation files (*.md, README) unless explicitly requested
+- You NEVER use emojis unless requested
+</critical>