@kr78/pi-coding-agent 17.2.10

package/src/prompts/tools/grep.md

@@ -0,0 +1,13 @@
+Searches files and internal URLs with Rust regex plus PCRE2 fallback.
+
+<instruction>
+- Scope `path` to known files, directories, globs, or internal URLs; separate roots with `;`.
+- Broad searches can time out; scope them narrowly or use `glob` first.
+- One-file line selector: `src/foo.ts:50-100` (selectors never choose the search root).
+- Literal `\n` or `\\n` enables cross-line patterns.
+</instruction>
+
+<critical>
+- MUST use this instead of shell `grep`/`rg`.
+- Open-ended multi-round search MUST use {{#if scoutAvailable}}Task + scout,{{else}}Task,{{/if}} not chained calls.
+</critical>

package/src/prompts/tools/hub.md

@@ -0,0 +1,34 @@
+Agent coordination: peer messaging, background-job control, and supervised long-running processes. Main agent is `Main`; subagents inherit task ID.
+Use `op: "list"` to discover peers. Address peers by exact roster ID — NEVER invent names.
+
+# Messaging & Jobs
+
+Background jobs auto-deliver when they finish. You NEVER need to poll; if `jobs`/`wait` observes a settled job first, that snapshot is the delivery and suppresses duplicate `async-result`.
+
+- **`send`** (with `to`): fire-and-forget, NEVER blocks. Delivery receipts (`delivered`/`failed`) immediate; `failed` → peer gone, don't retry.
+  Sending wakes `idle`/`parked` peers. Answering: lead with answer, NEVER quote, set `replyTo`.
+- **Format**: plain prose ONLY. No JSON status objects. Share paths via `local://`/`artifact://` URLs, not pasted blobs.
+- **`wait`**: use ONLY when completely blocked with no other work. Returns on the FIRST of: an incoming message, a watched job finishing, the wait window elapsing, or a steering interrupt — NOT when all jobs finish; re-issue to keep waiting.
+  - Bare `wait` watches every running job AND incoming messages. NEVER pass an array of every running ID; `ids` narrows to specific jobs, `from` to one peer (or use `await: true` on send).
+- **`inbox`**: drain queued messages without blocking.
+- **`cancel`**: kill background jobs by `ids` when they have hung, stalled, or are no longer needed. Returns immediately.
+- **`jobs`**: status snapshot of every job without waiting. A settled row consumes auto-delivery. Also names running subagents with no job entry — coordinate with those via `send`.
+- Job rows are process-local and expire roughly five minutes after settlement. Afterward, use the agent ID with `send`, `agent://<id>`, or `history://<id>`.
+- `completed` means successful yield/job exit, not artifact acceptance. Verify claimed changes.
+- NEVER use shell tools, grep, or read other sessions' files to figure out what a peer is doing. Message them directly.
+- NEVER use hub messaging for something a tool can answer (e.g., grepping codebase, running a build).
+
+# Processes
+
+Project-scoped long-running processes shared by every omp instance in the same directory. A long-running service, watcher, debugger, REPL, or process needing later input MUST use `op:"start"`, not `bash`.
+
+- **`start`** launches `application` + `args` directly. `cwd` defaults to the session directory; `pty` defaults true.
+  - `ready.log` is a regex; `ready.port` is a TCP port. Both supplied? BOTH MUST pass. `ready.timeout` is seconds. Readiness MUST be observed; process creation alone is not readiness.
+  - Names are unique per project directory. A completed name MAY be started again; a live name MUST be stopped or restarted.
+  - `restart` policy defaults `no`; `on-failure` and `always` use bounded backoff.
+  - `persist: true` opts out of last-omp teardown; `detached: true` survives broker shutdown and all omp exits (implies persist, disables PTY input). Omit both unless their survival guarantees are required.
+- **`ps`**, **`logs`**, **`wait`** (with `name`), **`send`** (with `name`), **`stop`**, **`restart`**, and **`describe`** address the stable `name`.
+- **`logs`** defaults to the last 100 lines. `head: true` reads the beginning. `grep` is a regex. `follow: true` waits for output after `cursor`; reuse the returned cursor on the next call.
+- **`wait`** with `name` blocks until readiness/exit/`pattern` or `timeout` (seconds).
+- **`send`** with `name`: `text` writes stdin (`enter` defaults true); `keys` supports ENTER, TAB, ESCAPE, CTRL_C, CTRL_D, UP, DOWN, LEFT, RIGHT; `signal` supports SIGINT, SIGTERM, SIGHUP, SIGQUIT, SIGKILL. PTY input is serialized; writes share one input stream.
+- **`stop`** performs graceful process-tree termination before hard-kill; NEVER kill an unverified PID through bash. **`restart`** reuses the retained launch spec.

package/src/prompts/tools/image-attachment-describe-system.md

@@ -0,0 +1,8 @@
+You are an image-analysis assistant. The user attached an image to a model that cannot see images, so your description is injected into that model's context in place of the image. The downstream model relies entirely on your text — it never sees the pixels.
+
+Core behavior:
+- Be faithful and evidence-first: distinguish direct observations from inferences.
+- Transcribe ALL visible text verbatim, preserving casing, punctuation, and layout order. Mark unreadable segments explicitly rather than guessing.
+- NEVER fabricate occluded, blurry, or uncertain details — say what is uncertain.
+- Be thorough but compact: prefer dense, information-rich prose over filler.
+- Do not add meta commentary, preambles ("This image shows…"), or closing remarks. Output only the description.

package/src/prompts/tools/image-attachment-describe.md

@@ -0,0 +1,10 @@
+Describe this image in enough detail that a model which cannot see it can reason about its content.
+
+Cover, where present:
+- The overall scene, subject, and what is happening.
+- People, objects, and their relationships, positions, colors, and counts.
+- All visible text, transcribed verbatim (OCR).
+- UI/screenshot elements: labels, buttons, inputs, states, errors, highlighted or disabled controls.
+- Diagrams, charts, tables: structure, axes, series, and the values they encode.
+
+Flag anything ambiguous or unreadable. Output the description as plain prose only.

package/src/prompts/tools/image-gen.md

@@ -0,0 +1,7 @@
+Generates or edits images.
+
+<instructions>
+- Provide a single detailed `subject` prompt for generation or editing.
+- When using multiple `input`, describe each image's role in `subject` (e.g. `Image 1` for composition, `Image 2` for lighting).
+- For text: add "sharp, legible, correctly spelled"; keep text short.
+</instructions>

package/src/prompts/tools/inspect-image-system.md

@@ -0,0 +1,20 @@
+You are an image-analysis assistant.
+
+Core behavior:
+- Be evidence-first: distinguish direct observations from inferences.
+- If something is unclear, say uncertain rather than guessing.
+- NEVER fabricate unreadable or occluded details.
+- Keep output compact and useful.
+
+Default output format (unless the requested question asks for another format):
+1) Answer
+2) Key evidence
+3) Caveats / uncertainty
+
+For OCR-style requests:
+- Preserve exact visible text, including casing and punctuation.
+- If text is partially unreadable, mark the unreadable segments explicitly.
+
+For UI/screenshot debugging requests:
+- Focus on visible states, labels, toggles, error messages, disabled controls, and relevant affordances.
+- Separate observed UI state from probable root cause.

package/src/prompts/tools/inspect-image.md

@@ -0,0 +1,22 @@
+Inspects an image file with a vision-capable model and returns compact text analysis.
+
+<instruction>
+- Use this for image understanding tasks (OCR, UI/screenshot debugging, scene/object questions)
+- Provide `path` as a local image file path, `Image #N` attachment label, or `attachment://N` URI
+- Write a specific `question`:
+  - what to inspect
+  - constraints (for example: "quote visible text verbatim", "only report confirmed findings")
+  - desired output format (bullets/table/JSON/short answer)
+- Keep `question` grounded in observable evidence and ask for uncertainty when details are unclear
+- Use this tool over `read` when the goal is image analysis
+</instruction>
+
+<output>
+- Returns text-only analysis from the vision model
+- No image content blocks are returned in tool output
+</output>
+
+<critical>
+- If image submission is blocked by settings, the tool will fail with an actionable error
+- If configured model does not support image input, configure a vision-capable model role before retrying
+</critical>

package/src/prompts/tools/learn.md

@@ -0,0 +1,7 @@
+Capture a reusable lesson into long-term memory, and optionally mint or enhance a managed skill in the same call.
+
+Use after solving something whose insight will pay off again: a non-obvious fix, a project convention you had to discover, a workflow that worked.
+
+Provide the optional `skill` object when the lesson is a repeatable *procedure* worth codifying as a `SKILL.md` (not just a fact). Managed skills are written to an isolated directory (`~/.omp/agent/managed-skills`) and are surfaced like normal skills next session. They NEVER touch user-authored skills. Frontmatter is generated from `name` and `description`.
+
+Capture sparingly and specifically. One strong, reusable lesson beats several vague ones.

package/src/prompts/tools/lsp-late-diagnostic.md

@@ -0,0 +1,8 @@
+<system-notice>
+{{#if multiple}}Late LSP diagnostics arrived for {{files.length}} files after their edits returned:
+{{else}}Late LSP diagnostics arrived after the edit returned:
+{{/if}}
+{{#each files}}{{this.path}} — {{this.summary}}
+{{#each this.messages}}{{this}}
+{{/each}}{{#unless @last}}
+{{/unless}}{{/each}}</system-notice>

package/src/prompts/tools/lsp.md

@@ -0,0 +1,19 @@
+Symbol-aware code intelligence from language servers — navigation, refactors, and diagnostics where text tools miss callsites.
+
+<operations>
+- Position-based: `file` + `line` + `symbol` (substring; `#N` for Nth match). `line` is 1-indexed.
+- `rename` — applies by default; `apply: false` previews. Project-aware lookups ERROR without `symbol` — no silent fallback on missing/ambiguous matches.
+- `code_actions` — lists by default; apply ONE with `apply: true` + `query` (title substring or index).
+- `rename_file` — moves file AND rewrites all imports/references; applies by default.
+- `diagnostics` — path, glob (`src/**/*.ts`), or `file: "*"` for workspace.
+- `symbols` — `file` lists file symbols; `file: "*"` + `query` searches workspace.
+- `reload` — restart one server (`file`) or all (`*`); `reload *` re-reads LSP config.
+- `request` — raw: `query` = method, `payload` = JSON params (else auto-built).
+</operations>
+
+<critical>
+- Symbol-aware work (rename, references, definition, code actions) MUST use `lsp` whenever a server is available.
+  It follows shadowing, re-exports, and cross-file usages text tools miss.
+- NEVER do a cross-file rename with `ast_edit`/`sed`/hand edits when `lsp` `rename`/`rename_file` can — text renames silently drop callsites.
+- Reach for `code_actions` on imports, quick-fixes, and server-known refactors before editing by hand.
+</critical>

package/src/prompts/tools/manage-skill.md

@@ -0,0 +1,9 @@
+Create, update, or delete a managed skill — a `SKILL.md` written to an isolated directory (`~/.omp/agent/managed-skills`) and surfaced like a normal skill in future sessions.
+
+Managed skills are for repeatable procedures worth codifying: a setup sequence, a debugging recipe, a project-specific workflow. They are kept separate from user-authored skills and this tool NEVER edits those.
+
+- `action: "create"` — fails if the skill already exists.
+- `action: "update"` — overwrites the body; fails if the skill does not exist.
+- `action: "delete"` — fails if the skill does not exist.
+
+`name` is kebab-case (lowercase letters, digits, hyphens). The `description` drives discovery, so make it specific. Do not include frontmatter in `body`; it is generated from `name` and `description`.

package/src/prompts/tools/memory-edit.md

@@ -0,0 +1,12 @@
+Edit Mnemopi long-term memories by id.
+
+Use only with ids returned by the `recall` tool. Operations:
+- `update`: replace content and/or importance for a working memory.
+- `forget`: permanently delete a working memory.
+- `invalidate`: softly supersede a working or episodic memory, optionally pointing at `replacement_id`.
+
+Fact ids (recall results marked `[facts]`) are read-only: inspect them with `read memory://<id>`; every edit op on a fact id returns `not_editable`.
+
+Prefer `invalidate` when a memory became stale but its history may still be useful. Use `forget` only for content that should be hard-deleted.
+
+**Always read the full memory before `update`.** Recall results are clipped previews (the trailing `…` marks a truncation and `full_length` reports the original size); `update` replaces content wholesale, so overwriting the preview would delete the unseen tail. Fetch the row first with `read memory://<id>`, then pass the merged content in `content`.

package/src/prompts/tools/patch.md

@@ -0,0 +1,57 @@
+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>
+
+<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,27 @@
+Read files, directories, archives, SQLite, images, documents, internal resources, and web URLs via `path`.
+
+<instruction>
+- SHOULD parallelize independent reads.
+- SHOULD use `read` (not browser) for web content; browser only when `read` can't deliver.
+</instruction>
+
+## Selectors — append `:<sel>` to `path` (e.g. `src/foo.ts:50-200`, `src/foo.ts:raw`, `db.sqlite:users:42`)
+- `:50` / `:50-` — from line 50 | `:50-200` — inclusive | `:50+150` — 150 lines from 50 | `:5-16,960-973` — multiple ranges
+- `:raw` — verbatim, no anchors/prefixes | `:2-4:raw` / `:raw:2-4` — range + verbatim
+- `:conflicts` — one line per unresolved git merge conflict block
+
+## Source kinds
+- Parseable code, no selector → structural summary (declarations only, body elided). Footer names recovery selector — re-issue ONLY those ranges.
+- {{#if IS_HL_MODE}}File + selector → `[foo.ts#1A2B]` snapshot header + numbered lines. Copy `[FILENAME#TAG]` for anchored edits; NEVER fabricate the tag.{{/if}}
+- Directory → depth-limited dirent listing.
+- SQLite (`.sqlite`, `.sqlite3`, `.db`, `.db3`): `file.db` (tables), `file.db:table` (schema+rows), `file.db:table:key` (by PK), `?limit=`/`?where=`/`?q=SELECT`.
+- Archives (`.tar`, `.tar.gz`, `.tgz`, `.zip`, plus ZIP-based `.jar`/`.war`/`.ear`/`.apk`): `archive.ext:path/inside/archive` reads a member.
+- Documents → extracted text. Notebooks → editable cells. Images → {{#if INSPECT_IMAGE_ENABLED}}metadata; call `inspect_image`{{else}}decoded inline{{/if}}. `:raw` bypasses converters.
+- URLs → reader-mode clean text/markdown; `:raw` → untouched HTML. Bare `host:port` needs trailing slash.
+- Internal URIs — all schemes take selectors. `artifact://<id>` recovers spilled output; page with `:N-M`/`:raw:N-M`.
+- `ssh://host/<path>` reads remote file/dir (UTF-8, ≤1 MiB); bare `ssh://` lists hosts; also `write`/`search`-able.
+  Literal `:`, `?`, `#` → percent-encode (`%3A`/`%3F`/`%23`). Requires POSIX shell (else `ssh` tool).
+
+<critical>
+Summary footer names elided ranges? Re-issue ONLY those ranges. NEVER guess `..`/`…` content.
+</critical>

package/src/prompts/tools/recall.md

@@ -0,0 +1,7 @@
+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.
+
+Content in each result is a preview. A trailing `…` marks a truncation (`truncated: true`, `full_length` gives the original size). Fetch the full row with `read memory://<id>` — required before any `memory_edit update`.

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/replace.md

@@ -0,0 +1,30 @@
+Performs a single string replacement in a file with fuzzy whitespace matching.
+
+<instruction>
+- You MUST use the smallest `old_string` that uniquely identifies the change
+- If `old_string` is not unique, you MUST expand it with more context or use `replace_all: true` to replace all occurrences
+- Use `replace_all: true` when renaming a string across the file
+- 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_string` not found or matches multiple locations without `replace_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.
+For in-place edits prefer this tool or `write` — you get a diff preview and fuzzy matching.
+</bash-alternatives>

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,14 @@
+End an active checkpoint. Rewind context to it, replacing intermediate exploration with your report.
+
+Call immediately after `checkpoint`-started investigative work.
+
+Requirements:
+- `report` 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. If the checkpoint already rewound, continue from the retained report instead of retrying.
+- On success, the session rewinds, keeps your report as retained context, and closes the checkpoint.
+- A successful rewind is final for that checkpoint; repeat calls error.

package/src/prompts/tools/security-publish.md

@@ -0,0 +1 @@
+Publish the canonical result of the current OMP-native security scan. Call this exactly once after every in-scope file and candidate has a final disposition. Supply only evidence grounded in repository files inspected during this scan. This tool validates, fingerprints, assigns OMP-owned IDs, writes the canonical security store, and creates SARIF. Do not invent IDs or edit the store directly.

package/src/prompts/tools/security-scan.md

@@ -0,0 +1 @@
+Plan, start, inspect, cancel, and validate OMP-native repository security scans. `preflight` creates an immutable plan pinned to the repository snapshot, model, and exact OAuth credential. `start` runs the plan as a background OMP job. `status` and `cancel` use the returned operation ID. `cloud_scans` lists Codex Security cloud configurations for the exact selected ChatGPT OAuth account. `cloud_start` creates and enables a cloud scan configuration using `repository_id`, `repository_url`, and `environment_id`; this consumes the account's separate Codex Security cloud allowance and is never a fallback from a native scan. `cloud_status` reads cloud progress. `cloud_pull` imports cloud findings into the canonical OMP security store, where they are available through `security://`. Cloud actions use `cloud_configuration_id` and may use `credential_id` to pin an account. Security must be enabled in settings.

package/src/prompts/tools/task-async-contract.md

@@ -0,0 +1 @@
+No polling is needed. Inspecting a settled job with `hub jobs` or `hub wait` makes that snapshot its delivery, so no duplicate `async-result` follows. Job IDs live in process memory for roughly five minutes after settlement; afterward, use the agent ID with `hub send`, `agent://<id>`, or `history://<id>`. `completed` means the subagent yielded successfully, not that claimed artifacts were verified.

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

@@ -0,0 +1,20 @@
+<task-result id="{{id}}" agent="{{agentName}}" status="{{status}}" duration="{{duration}}">
+{{#if meta}}<meta lines="{{meta.lineCount}}" size="{{meta.charSize}}" />{{/if}}
+{{#if abortReason}}
+<abort-reason>{{abortReason}}{{#if resumable}} — the agent is still live with its full context; message it via `hub` to resume instead of redoing the work.{{/if}}</abort-reason>
+{{/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,83 @@
+{{#if asyncEnabled}}{{#if batchEnabled}}Delegate work to background subagents by passing multiple items in a single `tasks[]` batch.
+Execution does not block — you receive IDs immediately.{{else}}Delegate work to ONE background subagent per call.
+Execution does not block — you receive an ID immediately.{{/if}}{{#if hasBlockingAgents}}
+Agents marked BLOCKING run inline — results return in this call; non-blocking items in the same batch still spawn as background jobs.{{/if}}{{else}}{{#if batchEnabled}}Run subagents synchronously by passing items in a `tasks[]` batch. Execution blocks until all work finishes.{{else}}Run ONE subagent synchronously. Execution blocks until work finishes.{{/if}}{{/if}}
+{{#if asyncEnabled}}
+
+# Async Job Contract
+- Results auto-deliver. A settled `hub jobs`/`hub wait` snapshot is the delivery; no duplicate `async-result` follows.
+- Job IDs are process-local and expire roughly five minutes after settlement. Afterward, use the agent ID with `hub send`, `agent://<id>`, or `history://<id>`.
+- `completed` means successful yield/job exit, not artifact acceptance. Verify claimed changes.
+{{/if}}
+
+# Task Design
+- **Agent typing:** Pick each item's `agent` type.{{#if scoutAvailable}} Read-only research MUST use `agent: "scout"` (faster model).{{/if}} Use default worker only when no specialist fits.
+- **No overhead:** Each `task` MUST instruct its agent to skip formatters, linters, and project-wide test suites. Run those once at the end.
+- **One-pass:** Prefer agents that investigate AND edit in one pass;{{#if scoutAvailable}} spin a read-only scout only when affected files are genuinely unknown.{{/if}}
+- **Overlap is safe:** Concurrent edits to the same files auto-resolve{{#if ircEnabled}}; worst case, agents coordinate directly over IRC{{/if}}. NEVER shrink or serialize a batch to avoid file overlap. Two prerequisites:
+  1. Every task MUST skip validation (build/lint/tests) — validating mid-flight blocks agents on each other's edits.
+  2. Decide cross-task contracts up front (e.g. the interface A implements and B consumes) and state them in the {{#if batchEnabled}}batch `context`{{else}}task{{/if}}, not left for agents to negotiate.
+
+# Inputs
+{{#if batchEnabled}}
+- `context`: Shared project state, constraints, and contracts. Applies to the entire batch; do not duplicate this background into individual tasks.
+- `tasks[]`: Array of subagents to spawn.
+  - `name`: A stable CamelCase identifier (≤32 chars), used to address the agent (IRC, job ids). Generated automatically if omitted.
+  - `agent`: The agent type running this item (e.g. {{#if scoutAvailable}}`scout`, {{/if}}`reviewer`). Omitting it gives you the general-purpose worker (`{{defaultAgent}}`) — NEVER pass that name explicitly. Only omit it after checking the agent list below and finding no specialist that fits.{{#if allowedAgentsText}} Current spawn policy allows: {{allowedAgentsText}}.{{/if}}
+  - `task`: Complete, self-contained instructions. One-liners or missing acceptance criteria are PROHIBITED.
+{{#if effortEnabled}}  - `effort`: Scale w/ complexity of this task: `"lo"`|`"med"`|`"hi"`
+{{/if}}
+  - `outputSchema`: Invocation-specific JSON Schema. Overrides the selected agent and parent-session schemas.
+  - `schemaMode`: `"permissive"` (default) accepts a retry-exhausted invalid result with a warning; `"strict"` fails it.
+{{#if isolationEnabled}}
+{{#if applyIsolatedChanges}}
+  - `isolated`: Run in a dedicated worktree; successful changes are automatically applied to the parent checkout.
+{{else}}
+  - `isolated`: Run in a dedicated worktree; changes are retained as patch or branch artifacts without modifying the parent checkout.
+{{/if}}
+{{/if}}
+{{else}}
+- `name`: A stable CamelCase identifier (≤32 chars), used to address the agent (IRC, job ids). Generated automatically if omitted.
+- `agent`: The agent type to spawn (e.g. {{#if scoutAvailable}}`scout`, {{/if}}`reviewer`). Omitting it gives you the general-purpose worker (`{{defaultAgent}}`) — NEVER pass that name explicitly. Only omit it after checking the agent list below and finding no specialist that fits.{{#if allowedAgentsText}} Current spawn policy allows: {{allowedAgentsText}}.{{/if}}
+- `task`: Complete, self-contained instructions. One-liners or missing acceptance criteria are PROHIBITED.
+{{#if effortEnabled}}- `effort`: Scale w/ complexity of this task: `"lo"`|`"med"`|`"hi"`
+{{/if}}
+- `outputSchema`: Invocation-specific JSON Schema. Overrides the selected agent and parent-session schemas.
+- `schemaMode`: `"permissive"` (default) accepts a retry-exhausted invalid result with a warning; `"strict"` fails it.
+{{#if isolationEnabled}}
+{{#if applyIsolatedChanges}}
+- `isolated`: Run in a dedicated worktree; successful changes are automatically applied to the parent checkout.
+{{else}}
+- `isolated`: Run in a dedicated worktree; changes are retained as patch or branch artifacts without modifying the parent checkout.
+{{/if}}
+{{/if}}
+{{/if}}
+
+# Communication
+Subagents start blank — no conversation history.{{#if ircEnabled}} Parent-to-subagent IRC delivered immediately as steering.{{/if}}
+Pass large payloads via `local://<path>` URIs, NEVER inline text.
+
+# Format Contracts
+{{#if batchEnabled}}
+`context` format:
+# Goal         ← what the batch accomplishes
+# Constraints  ← rules and session decisions
+# Contract     ← shared interfaces
+{{/if}}
+
+`task` format:
+# 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
+
+# Available Agents
+{{#if spawningDisabled}}
+Agent spawning is currently disabled.
+{{else}}
+Pick the most specific agent; use default worker only when no specialist fits.
+{{#list agents join="\n"}}
+### {{name}}{{#if readOnly}} (READ-ONLY){{/if}}{{#if blocking}} (BLOCKING: inline result){{/if}}
+{{description}}
+{{#if readOnly}}Use ONLY for investigation; do edits yourself or assign to a writing agent.{{/if}}
+{{/list}}
+{{/if}}

package/src/prompts/tools/todo.md

@@ -0,0 +1,42 @@
+**Tasks referenced by verbatim content string, NEVER an auto-generated ID — no "task-1"/"task-N" exists. Pass the content text in the `task` field.**
+
+On each completion the earliest still-open task (in phase order) auto-promotes to `in_progress`.
+Completing tasks out of phase order can move this pointer **back** to an earlier phase — expected; completed tasks are never reverted.
+
+## Operations
+
+|`op`|Required fields|Effect|
+|---|---|---|
+|`init`|`list: [{phase, items: string[]}]`|Initialize full list (replaces existing)|
+|`init`|`items: string[]`|Flattened single-phase init|
+|`start`|`task`|Mark in progress|
+|`done`|`task` or `phase`|Mark completed|
+|`drop`|`task` or `phase`|Mark abandoned|
+|`block`|`task` or `phase`, optional `reason`|Mark **blocked** — open but waiting on external input; excluded from the stop-time incomplete-todo reminder|
+|`unblock`|`task` or `phase`|Return a blocked task to `pending`|
+|`rm`|`task` or `phase` (optional)|Remove task or phase; omit both to clear|
+|`append`|`phase`, `items: string[]`|Append tasks to `phase`; lazily creates phase|
+|`view`|—|Read-only: echo list|
+
+## Anatomy
+- **Task content**: 5–10 words; what, not how. Unique identifier.
+- **Phase name**: short noun phrase (e.g. `Foundation`, `Auth`, `Verification`). Unique identifier. NEVER prefix `1.`, `A)`, `Phase 1:`.
+
+## Rules
+- Mark tasks done immediately after finishing. Complete phases in order.
+- NEVER make a todo call your turn's only tool call — batch it with the real work: `init` with the first reads/edits, each `done`/`start` with the next action. Solo todo turns waste a round trip.
+- Waiting on something you can't act on (a user decision, another agent, an external service)? `block` the task (optional `reason`) — it stays in the tracker but won't trip the stop reminder; `unblock` when it's actionable again. If the blocker is itself agent-actionable, `append` an unblocking task instead.
+- Keep `task`/`phase` strings stable once introduced.
+- Lost the exact task text? `view` echoes the list — NEVER guess from memory.
+
+## When to create a list
+- Task requires 3+ distinct steps
+- User explicitly requests one
+- User provides a set of tasks
+- New instructions arrive mid-task — capture before proceeding
+
+<critical>
+User hands you a multi-step plan — phased todo, numbered/bulleted checklist, or "N bugs/items/tasks":
+- You MUST `init` the list with EVERY item as its own task before working.
+- Enumerate all; NEVER summarize into fewer tasks, sample "the important ones", drop items, or track the rest from memory.
+</critical>

package/src/prompts/tools/vibe-kill.md

@@ -0,0 +1,3 @@
+Terminates a worker session: aborts its in-flight turn (if any) and discards the session. Its conversation cannot be continued afterwards — the transcript stays readable at `history://<id>`.
+
+Kill sessions that are stuck, looping, or whose workstream is complete. Freeing dead weight keeps the roster legible.

package/src/prompts/tools/vibe-list.md

@@ -0,0 +1,3 @@
+Shows your worker-session roster: id, CLI flavor (`fast`/`good`), state (`starting`/`running`/`idle`/`dead`), model, turn count, queued messages, and a one-line gist of each session's latest activity.
+
+Use it to reorient: which sessions exist, who is busy, who is idle and ready for the next instruction.

package/src/prompts/tools/vibe-send.md

@@ -0,0 +1,9 @@
+Sends a message to one of your worker sessions (by id from `vibe_spawn` / `vibe_list`). The session keeps its full conversation history — refer to earlier work naturally ("now do the same for the other module").
+
+Returns immediately with an ack telling you how the message landed:
+
+- `turn` — the worker was idle; a new turn started. Its result self-delivers when done.
+- `steered` — the worker was mid-turn; your message was injected into the running turn as live steering.
+- `queued` — the worker was mid-turn and not steerable right now; your message runs as the next turn automatically.
+
+Use it for follow-ups, corrections, scope changes, and review requests. Never re-explain prior context — the session already has it.

package/src/prompts/tools/vibe-spawn.md

@@ -0,0 +1,10 @@
+Starts a persistent worker session — a full coding agent (edit, bash, grep, everything) that you drive by conversation. Pick the CLI flavor per task:
+
+- `fast`: low-latency model for mechanical, well-specified work (renames, boilerplate, running tests, data collection).
+- `good`: strong model for hard work (design, debugging, multi-file changes, judgment calls).
+
+`prompt` is the session's first instruction. The worker starts with NO context beyond it — include files, constraints, and acceptance criteria. `name` (optional) labels the session; otherwise one is generated.
+
+Returns immediately with the session id; the turn's result (activity trace + the worker's response) is delivered to you automatically when the worker finishes. Do not wait unless you are blocked — keep directing other sessions.
+
+The session persists after the turn: it remembers the whole conversation. Continue it with `vibe_send`; never spawn a second session for a follow-up on the same workstream.

package/src/prompts/tools/vibe-turn-result.md

@@ -0,0 +1,19 @@
+<vibe-turn session="{{id}}" cli="{{cli}}" turn="{{turn}}" status="{{status}}" duration="{{duration}}"{{#if model}} model="{{model}}"{{/if}}>
+<activity tool-calls="{{toolCount}}" requests="{{requests}}">
+{{#each trace}}
+- {{this}}
+{{/each}}
+{{#if traceOverflow}}
+- … {{traceOverflow}} earlier tool call(s) not shown
+{{/if}}
+</activity>
+<response{{#if responseTruncated}} truncated="true" full-output="agent://{{id}}"{{/if}}>
+{{response}}
+</response>
+{{#if error}}
+<error>{{error}}</error>
+{{/if}}
+{{#if alive}}
+Session `{{id}}` is idle and retains this conversation — continue it with vibe_send. Transcript: history://{{id}}
+{{/if}}
+</vibe-turn>

package/src/prompts/tools/vibe-wait.md

@@ -0,0 +1,8 @@
+Blocks until ONE watched session finishes its current turn, the timeout elapses, or you are interrupted — not until all finish. Re-issue to keep waiting.
+
+Turn results normally deliver themselves; you NEVER need this to receive output. Use it only when you are completely blocked and cannot direct any other session.
+
+- `sessions` — ids to watch. Omit to watch every session with a turn in flight.
+- `timeout` — seconds to wait (default 30).
+
+A finished turn's full result (activity trace + response) is returned here and will not be re-delivered separately.

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

@@ -0,0 +1,8 @@
+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
+- NEVER use for content that is programmatically accessible or whose URL you already know (GitHub repos/issues, a known arXiv paper, a Wikipedia page, official docs) — `read` the URL directly instead
+- `query` supports Google-style directives on every provider: `site:`/`-site:`, `after:`/`before:` (`YYYY-MM-DD`), `inurl:`, `intitle:`, `filetype:`, `"exact phrase"`, `-term`, `OR`. Constraints map to native provider filters where available; otherwise results are filtered leniently — a constraint matching nothing is relaxed and reported instead of returning zero results.
+</instruction>

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`, `.zip`, and ZIP-based `.jar`/`.war`/`.ear`/`.apk` 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
+- You NEVER create documentation files (*.md, README) unless explicitly requested
+- You NEVER use emojis unless requested
+</critical>