@jawcode-dev/coding-agent 1.1.0

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

@@ -0,0 +1,37 @@
+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 discoverableMCPToolCount}}Total discoverable tools available: {{discoverableMCPToolCount}}.{{/if}}
+{{#if hasDiscoverableToolSnapshot}}
+Available tools (search by name or keyword to activate):
+{{#list discoverableToolSnapshot join="\n"}}{{this}}{{/list}}
+{{/if}}
+Input:
+- `query` — required natural-language or keyword query
+- `limit` — optional maximum number of tools to return and activate (default `8`)
+
+Behavior:
+- Searches hidden tool metadata using BM25-style relevance ranking
+- 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.
+- `query` is matched against tool metadata fields:
+  - `name`
+  - `label`
+  - `server_name` (MCP tools)
+  - `mcp_tool_name` (MCP tools)
+  - `description` / `summary`
+  - input schema property keys (`schema_keys`)
+
+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,25 @@
+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` is required and accepts an array of files, directories, globs, or internal URLs
+- `paths` is an array; do not embed commas or spaces inside a single entry. Pass `["src", "tests"]` not `["src,tests"]`.
+- Cross-line patterns are detected from literal `\n` or escaped `\\n` in `pattern`
+</instruction>
+
+<output>
+{{#if IS_HL_MODE}}
+- Text output is anchor-prefixed: `*5th|content` (match) or ` 9x}|content` (context, leading space). The 2-char suffix is a content fingerprint. The `|` before content is a separator, not part of the file content.
+{{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 you catch yourself typing `grep`, `rg`, or `| grep` in a Bash command, stop and re-issue the lookup through the `search` tool instead.
+- 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/skill.md

@@ -0,0 +1,28 @@
+Invoke another available skill in the current turn.
+
+<conditions>
+- A SKILL document instructs you to chain into another skill on completion (e.g. orchestrate p → goal)
+- You finished one skill's workflow and the next step requires another skill's full prompt context
+</conditions>
+
+<instruction>
+- `name` is the skill name as it appears in `/skill:<name>` (e.g. `goal`, `team`, `jaw-interview`)
+- `args` is the free-form argument string the skill would receive after `/skill:<name>` on the command line
+- The skill tool dispatches the callee's SKILL.md as a user-attribution custom message in the current turn (steering the stream when active, appending otherwise). Before dispatch, the tool atomically demotes the caller and promotes the callee in `.jwc/state/` by calling `jwc state <caller> handoff --to <callee>` in-process.
+- The chain is refused unless the caller's `current_phase` is in `{complete, completed, handoff, failed, cancelled, canceled, inactive}`. To prepare the active skill for chaining, write `current_phase: "handoff"` to its mode-state via `jwc state <skill> write --input '{"current_phase":"handoff"}' --json`. The skill tool itself then runs `jwc state <skill> handoff --to <callee>` in-process to atomically demote the caller and promote the callee — you do not need to run the handoff verb separately.
+- Call once per chain step. To chain `A → B → C`, A calls `skill(B)`; B's next agent turn calls `skill(C)`.
+</instruction>
+
+<critical>
+- Do NOT use this tool to "remind yourself" of a skill you're already running. The current SKILL.md is already in your context.
+- Do NOT chain into the same skill recursively. If a skill's flow needs another iteration, follow its in-document instructions.
+- The chained skill's planning/execution-boundary rules still apply. Chaining does not grant execution approval.
+</critical>
+
+<examples>
+# Hand off from orchestrate p to goal after an approved plan
+{"name": "goal", "args": "track execution of .jwc/plans/planphase/<run-id>/pending-approval.md"}
+
+# Trigger jaw-interview with no arguments
+{"name": "jaw-interview"}
+</examples>

package/src/prompts/tools/ssh.md

@@ -0,0 +1,35 @@
+Runs commands on remote hosts.
+
+<instruction>
+You MUST build commands from the reference below
+</instruction>
+
+<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/subagent.md

@@ -0,0 +1,56 @@
+Lists, inspects, awaits, pauses, resumes, steers, or cancels detached task subagents.
+
+Task launches return immediately. Use this tool when you need direct control over those running subagents. Use `background` for non-subagent background row management (monitors, async bash, cron).
+
+`verbosity` controls output size: `receipt` (default) returns status metadata plus a single ≤280-character result/error preview and an `agent://<id>` output ref when available; `preview` returns ≤2000 characters; `full` returns ≤12000 characters and requires explicit `ids`.
+
+# Operations
+
+## `action: "list"`
+Snapshot your visible detached subagents, including `running`, `paused`, `queued`, and terminal subagents when retained. Output is receipt-only by default; use `verbosity: "preview"` for a bounded preview or inspect explicit `ids` with `verbosity: "full"` when fuller retained text is necessary.
+
+## `action: "inspect"`
+Inspect selected subagents by `ids`; omit `ids` to inspect current running subagents. Terminal subagents return receipt-only output by default, with an `agent://<id>` ref when a verified output artifact is available. `verbosity: "full"` requires explicit `ids`.
+
+## `action: "await"`
+Wait for selected subagents by `ids`; omit `ids` to wait for current running subagents.
+- Always set `timeout_ms` when the result is not immediately required forever.
+- Await timeout only bounds this tool call's wait; it does not stop the subagent and is not a failure reason.
+- On timeout, inspect progress and keep doing independent work. Never cancel just because an await timed out; cancel only if the subagent has actually failed, gone off-track, or become unrecoverably wrong.
+- Completed results are receipt-first by default: bounded preview plus `agent://<id>` output ref when available, not full retained output.
+
+## `action: "pause"`
+Request a graceful safe-boundary pause for selected subagents by `ids`.
+- Non-running subagents are a no-op and return their current status snapshot.
+- A paused subagent keeps its session context and can be resumed later.
+
+## `action: "resume"`
+Resume one subagent by `id` (preferred) or a single-item `ids` array.
+- Optional `message` is delivered into that one resumed run.
+- Running subagents are a no-op and return their current status snapshot.
+- Terminal subagents require `message` to start a follow-up resume run; without `message`, the tool returns the current snapshot with guidance.
+- `paused` subagents resume from saved context; `queued` subagents are already waiting for capacity.
+- Multiple targets are rejected because one global `message` must not broadcast to several subagents.
+
+## `action: "steer"`
+Send a non-empty `message` to one subagent by `id` (preferred) or a single-item `ids` array.
+- A running subagent receives the message through its live handle.
+- Optional `pause: true` requests a safe-boundary pause after steering a running subagent.
+- `pause` only matters while the target is running.
+- A non-active subagent (`paused`, `queued`, or terminal) automatically resumes with the message; `pause` is ignored for that target.
+- Multiple targets are rejected because one global `message` must not broadcast to several subagents.
+
+## `action: "cancel"`
+Stop selected subagents by `ids`, including running, paused, or queued subagents.
+- Use only when the subagent has actually failed, gone off-track, or become unrecoverably wrong; an await timeout alone is never a cancellation reason.
+- Cancellation keeps the subagent session file for possible later context recovery.
+
+# Statuses
+
+- `running` — currently executing.
+- `paused` — stopped at a safe boundary with resumable context.
+- `queued` — resume requested and waiting for execution capacity.
+- `completed` — finished successfully.
+- `failed` — finished with an error.
+- `cancelled` — stopped by cancellation.
+- `not_found` — no visible subagent matches the requested id.

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

@@ -0,0 +1,22 @@
+<task-summary>
+<header>{{successCount}}/{{totalCount}} succeeded{{#if hasCancelledNote}} ({{cancelledCount}} cancelled){{/if}} [{{duration}}]</header>
+
+{{#each summaries}}
+<agent id="{{id}}" agent="{{agent}}">
+<status>{{status}}</status>
+{{#if meta}}<meta lines="{{meta.lineCount}}" size="{{meta.charSize}}" />{{/if}}
+<synopsis{{#if outputUri}} ref="{{outputUri}}"{{/if}}>
+{{synopsis}}
+</synopsis>
+</agent>
+{{#unless @last}}
+---
+{{/unless}}
+{{/each}}
+
+{{#if mergeSummary}}
+<merge-summary>
+{{mergeSummary}}
+</merge-summary>
+{{/if}}
+</task-summary>

package/src/prompts/tools/task.md

@@ -0,0 +1,106 @@
+Launches subagents to parallelize workflows.
+
+- Results are delivered automatically when complete.
+- The tool result lists the assigned task ids (e.g. `0-AuthLoader`) — those are the live agent ids.
+- Long-running subagent work appears as background work. After launch, use the `background` tool to list, inspect, follow, or cancel background rows instead of fabricating status.
+- The TUI footer rows (`bg … · ctrl+j`) and `background` tool rows are the same conceptual background work surface.
+{{#if ircEnabled}}
+- Coordinate with running tasks via `irc` using those ids. `subagent` cancel terminates a task and **cannot carry a message** — never cancel because an await timed out; cancel only when the task has actually failed, gone off-track, or become unrecoverably wrong.
+- If genuinely blocked on completion, wait with `subagent` action `await` and a timeout; timeout only bounds your wait and does not stop or fail the subagent.
+{{else}}
+- If genuinely blocked on completion, wait with `subagent` action `await` and a timeout; timeout only bounds your wait and does not stop or fail the subagent.
+- Use `subagent` action `inspect` or `list` to snapshot manager state; `cancel` only when a task has actually failed, gone off-track, or become unrecoverably wrong.
+{{/if}}
+
+{{#if ircEnabled}}
+Subagents have no conversation history, but they can reach you and their siblings live via the `irc` tool. Front-load every fact, file path, and direction they need in {{#if contextEnabled}}`context` or `assignment`{{else}}each `assignment`{{/if}}.
+{{else}}
+Subagents have no conversation history. Every fact, file path, and direction they need MUST be explicit in {{#if contextEnabled}}`context` or `assignment`{{else}}each `assignment`{{/if}}.
+{{/if}}
+
+<parameters>
+- `agent`: callable task role for all tasks. Use `executor` for ordinary parallel implementation/research, `executor_ext` for explicit external/ext/fresh/model-diverse executor work, and `planner`/`architect`/`critic` for explicit specialist lenses.
+- `tasks`: tasks to execute in parallel
+ - `.id`: CamelCase, ≤32 chars
+ - `.description`: UI label only — subagent never sees it
+ - `.assignment`: complete self-contained instructions; one-liners and missing acceptance criteria are PROHIBITED
+{{#if contextEnabled}}- `context`: shared background prepended to every assignment; session-specific only{{/if}}
+- `.model` (optional): model hint for this task. Prefer explicit `provider/modelId[:effort]` when the user names an external or specific model (especially with `executor_ext`), e.g. `openai/gpt-5.4:high`. For `executor_ext`, omitted or empty `.model` means use the configured `EXECUTOR_EXT` / `task.agentModelOverrides.executor_ext` target; only set `.model` for one-off model overrides. For other agents, `"self"` or omitted = parent model. `"cheap:<provider>"` or `"best:<provider>"` = preset lookup; bare/canonical/fuzzy ids may resolve but should not be used in examples for specific external-lane requests.
+{{#if contextEnabled}}
+- `.inheritContext` (optional): fork-context mode for seeding the subagent with sanitized parent conversation. Omit it or set `"none"` for no copied context. `"receipt"` copies a minimal receipt-sized snapshot, `"last-turn"` copies only the latest exchange, `"bounded"` copies the bounded default snapshot, and `"full"` copies a larger snapshot up to the configured/model token cap. Non-`none` modes work only when global `task.forkContext.enabled` is true and the target agent declares `forkContext: allowed`; otherwise the call is rejected. Bundled agents that support it: `executor`, `executor_ext`, and `architect`. Use inherited context only when the subagent's value depends on parent context; cloned tokens are billed to the child as fresh input and surfaced in task receipts as fork-context cloned-token accounting.
+{{/if}}
+{{#if independentMode}}- `.inheritContext`: independent mode cannot inherit parent conversation. Omit it or set `"none"`; any non-`none` value is rejected before scheduling.{{/if}}
+{{#if customSchemaEnabled}}- `schema`: JTD schema for expected structured output (do not put format rules in assignments){{/if}}
+- `spawnPlan` (optional): required before any batch with more than 4 tasks, and before a reviewer agent spawns `explore`; include whyParallel, whyNotLocal, independence, expectedReceiptShape, and maxInlineTokens.
+{{#if isolationEnabled}}- `isolated`: run in isolated env; use when tasks edit overlapping files{{/if}}
+</parameters>
+
+<agent-routing>
+- Generic parallel implementation or research → `executor`.
+- PABCD B-stage implementation slices → `executor` by default so actor/self-fork routing can apply.
+- Generic subagent/worker + named model/version → `executor_ext`, not `executor`; set each task `.model` explicitly as `provider/modelId[:effort]` (infer effort by task risk when omitted), never rely on the `EXECUTOR_EXT` default for that named-model request.
+- Explicit external/ext/fresh/model-diverse executor work with no named model → `executor_ext` with `.model` omitted so the configured `EXECUTOR_EXT` target is used.
+- Explicit external/ext/fresh/model-diverse executor work with a named one-off model → `executor_ext` with `.model: "provider/modelId[:effort]"`.
+- Research-only `executor_ext` assignments must explicitly say read-only/no product mutation in the task `assignment`.
+- Specialist planning/architecture/critique lens → `planner`, `architect`, or `critic`; preserve that role and add `.model` when the user requests an external model for the specialist lens.
+</agent-routing>
+
+External executor one-off model example:
+`{ "agent": "executor_ext", "tasks": [{ "id": "ExternalReview", "description": "External review", "assignment": "Read-only investigation; do not edit files; read-only/no product mutation.", "model": "provider/modelId:effort" }] }`
+Configured external executor example:
+`{ "agent": "executor_ext", "tasks": [{ "id": "ExternalReview", "description": "External review", "assignment": "Read-only investigation; do not edit files; read-only/no product mutation." }] }`
+
+Persistent external executor model target: `EXECUTOR_EXT = provider/modelId[:effort]` / `task.agentModelOverrides.executor_ext`.
+
+<rules>
+- HARD runtime gate: calls with more than 4 tasks are rejected before any child launches unless `spawnPlan` is complete.
+- Reviewer→explore gate: a `reviewer` spawning `explore` is rejected before launch unless `spawnPlan` is complete, even for a single task.
+- NEVER assign tasks to run project-wide build/test/lint. Caller verifies after the batch.
+- **Subagents do not verify, lint, or format.** Every assignment MUST instruct the subagent to skip all gates and formatters. You run them once at the end across the union of changed files — avoids redundant runs and racing formatter passes.
+{{#if ircEnabled}}
+- Each task: ≤3–5 explicit files. Overlapping file sets are tolerable when peers can coordinate via `irc`, but still fan out to a cluster when the scopes are cleanly separable.
+- No globs, no "update all", no package-wide scope.
+{{else}}
+- Each task: ≤3–5 explicit files. No globs, no "update all", no package-wide scope. Fan out to a cluster instead.
+{{/if}}
+- Pass large payloads via `local://<path>` URIs, not inline.
+{{#if contextEnabled}}- Put shared constraints in `context` once; do not duplicate across assignments.{{/if}}
+- Prefer agents that investigate **and** edit in one pass; only spin a read-only discovery step when affected files are genuinely unknown.
+</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}}
+</parallelization>
+
+{{#if contextEnabled}}
+<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}}
+{{description}}
+{{/list}}
+{{/if}}
+</agents>

package/src/prompts/tools/todo-write.md

@@ -0,0 +1,50 @@
+**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`, and `note`. `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`|Remove|
+|`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.|
+
+## 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.
+
+## 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"]}]}]}`
+# 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>

package/src/prompts/tools/vim.md

@@ -0,0 +1,98 @@
+Vim-style `edit` mode. The tool name stays `edit`; every call requires `file`, and the buffer loads automatically on first use.
+- `{"file": "path"}` - view file
+- `{"file": "path", "steps": [{"kbd": ["…"], "insert": "…"}]}` - edit file
+
+**Multi-location edits: always edit highest line number first (bottom-up).** Each insert shifts lines below it.
+
+## steps vs kbd vs insert
+
+`steps` = ordered editing steps. Each step runs `kbd`, then optionally types `insert`.
+`kbd` = Vim commands only (`dd`, `G`, `o`, `cc`, `gg`, etc.).
+`insert` = raw text content to type into the buffer.
+`o`/`O` already create a new line — do not start `insert` with `\n`. A trailing `\n` in `insert` adds an extra blank line.
+
+Never put text content in `kbd`. Only Vim keystrokes go there.
+- BAD: `{"steps": [{"kbd": ["1Gohello world<Esc>"]}]}`
+- BAD: `{"steps": [{"kbd": ["1Go", "hello world"]}]}`
+- BAD: `{"steps": [{"kbd": ["1Ao"], "insert": "text"}]}`
+- GOOD: `{"steps": [{"kbd": ["1Go"], "insert": "hello world"}]}`
+
+If a step uses `insert`, the last `kbd` entry in that step must leave INSERT mode active (`o`, `O`, `i`, `a`, `A`, `cc`, `C`, `s`, `S`).
+
+Each non-final `kbd` entry inside a step must end in NORMAL mode (add `<Esc>`).
+
+Between steps, the tool auto-exits INSERT mode.
+
+Whitespace in `kbd` is literal. Do not use spaces as separators between keys; `ggdGi` is one sequence, not `ggdG i`.
+
+Common mistake: `Ni` means "insert N copies", NOT "insert at line N". To insert at line N, use `NGo` (below) or `NGO` (above).
+## Editing patterns
+
+`NGo` = new line BELOW line N. `NGO` = new line ABOVE line N.
+
+Insert new line after line 3:
+```json
+{"file": "f.py", "steps": [{"kbd": ["3Go"], "insert": "    new line here"}]}
+```
+
+Insert new line before line 3:
+```json
+{"file": "f.py", "steps": [{"kbd": ["3GO"], "insert": "    new line here"}]}
+```
+
+Replace line N:
+```json
+{"file": "f.py", "steps": [{"kbd": ["5Gcc"], "insert": "    replacement content"}]}
+```
+
+Replace entire file. `ggdGi` = go to top, delete all, enter INSERT. Use that exact sequence when rewriting the whole file:
+```json
+{"file": "f.py", "steps": [{"kbd": ["ggdGi"], "insert": "entire new file content"}]}
+```
+
+Multi-location edit — edit **highest line number first** (bottom-up) so inserts don't shift later targets:
+```json
+{"file": "f.py", "steps": [
+  {"kbd": ["8Go"], "insert": "    print(result)"},
+  {"kbd": ["3Go"], "insert": "def helper(x):\n    return x + 1"}
+]}
+```
+Each `o`/`O` insert adds lines, shifting everything below. Bottom-up order keeps all line numbers valid. Use `\n` within `insert` for multi-line content.
+
+Navigation or search step without insert:
+```json
+{"file": "f.py", "steps": [{"kbd": ["/pattern<CR>"]}]}
+```
+
+Find and replace:
+```json
+{"file": "f.py", "steps": [{"kbd": [":%s/old/new/g<CR>"]}]}
+```
+
+Delete line range:
+```json
+{"file": "f.py", "steps": [{"kbd": [":3,5d<CR>"]}]}
+```
+Ex commands always start with `:` and end with `<CR>`. `3,5d` without `:` is NOT an ex command — it is interpreted as normal-mode keystrokes and will fail.
+
+## Undo mistakes
+- `{"file": "f.py", "steps": [{"kbd": ["u"]}]}` - undo last change
+- `{"file": "f.py", "steps": [{"kbd": ["3u"]}]}` - undo last 3 changes
+
+`:e!` reloads from disk. Warning: because non-paused calls auto-save, `:e!` reloads your last saved state, not the original file. Use `u` to undo instead. If stuck, use `ggdGi` with the full desired file content.
+
+## Session persistence
+
+The edit buffer in vim mode persists across tool calls. Cursor position, undo history, and file state are maintained until you close the buffer. Auto-save happens once after all steps in a non-paused call complete.
+
+## Supported
+
+Keys: `<Esc>` `<CR>` `<BS>` `<Tab>` `<C-d>` `<C-u>` `<C-r>` `<C-w>` `<C-o>`
+Motions: `h j k l <Space> w b e 0 $ ^ + - _ gg G { } f F t T % H M L ; ,` with counts
+Operators: `d c y p` with motions and text objects (`iw aw ip ap i" a" i( a( i{ a{`)
+Insert: `i a o O I A cc C s S R` - these all enter INSERT mode; do not add another `i` after them
+Visual: `v V` with `d y c > < ~ r u U p P o J`
+Other: `.` repeat, `u`/`<C-r>` undo/redo, `/pattern<CR>` search, `n N * #`, `gv` `gJ` `gU` `gu` `ZZ` `ZQ`
+Ex: `:w` `:q` `:wq` `:e` `:e!` `:N` `:s///` `:%s///` `:N,Md` `:%d` `:N,Mt N` `:sort` `:j` `:j!` `:g/pattern/d` `:v/pattern/d`
+Addresses: absolute line numbers, `.`, `$`, and `+N`/`-N` relative offsets, including ranges like `:.,$d` and `:.+2,$g/pattern/d`
+More ex: `:up` `:N,My` `:put` `:put!` `:N,Mco $` `:N,Mm $`

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>

package/src/registry/agent-registry.ts

@@ -0,0 +1,140 @@
+/**
+ * AgentRegistry - Process-global registry of live AgentSession instances.
+ *
+ * Tracks every alive agent (the main session plus every subagent) so the
+ * `irc` tool can address peers by id. Sessions are registered explicitly at
+ * creation and removed when the owner releases them.
+ */
+
+import type { AgentSession } from "../session/agent-session";
+
+export const MAIN_AGENT_ID = "0-Main";
+
+export type AgentStatus = "running" | "idle" | "completed" | "aborted";
+export type AgentKind = "main" | "sub";
+
+export interface AgentRef {
+	id: string;
+	displayName: string;
+	kind: AgentKind;
+	parentId?: string;
+	status: AgentStatus;
+	session: AgentSession | null;
+	sessionFile: string | null;
+	createdAt: number;
+	lastActivity: number;
+}
+
+export type RegistryEvent =
+	| { type: "registered"; ref: AgentRef }
+	| { type: "status_changed"; ref: AgentRef }
+	| { type: "removed"; ref: AgentRef };
+
+type RegistryListener = (event: RegistryEvent) => void;
+
+export interface RegisterInput {
+	id: string;
+	displayName: string;
+	kind: AgentKind;
+	parentId?: string;
+	session: AgentSession | null;
+	sessionFile?: string | null;
+	status?: AgentStatus;
+}
+
+export class AgentRegistry {
+	static #global: AgentRegistry | undefined;
+
+	static global(): AgentRegistry {
+		if (!AgentRegistry.#global) {
+			AgentRegistry.#global = new AgentRegistry();
+		}
+		return AgentRegistry.#global;
+	}
+
+	/** Reset the global registry. Test-only. */
+	static resetGlobalForTests(): void {
+		AgentRegistry.#global = new AgentRegistry();
+	}
+
+	readonly #refs = new Map<string, AgentRef>();
+	readonly #listeners = new Set<RegistryListener>();
+
+	register(input: RegisterInput): AgentRef {
+		const now = Date.now();
+		const ref: AgentRef = {
+			id: input.id,
+			displayName: input.displayName,
+			kind: input.kind,
+			parentId: input.parentId,
+			status: input.status ?? "running",
+			session: input.session,
+			sessionFile: input.sessionFile ?? null,
+			createdAt: now,
+			lastActivity: now,
+		};
+		this.#refs.set(ref.id, ref);
+		this.#emit({ type: "registered", ref });
+		return ref;
+	}
+
+	setStatus(id: string, status: AgentStatus): void {
+		const ref = this.#refs.get(id);
+		if (!ref || ref.status === status) return;
+		ref.status = status;
+		ref.lastActivity = Date.now();
+		this.#emit({ type: "status_changed", ref });
+	}
+
+	attachSession(id: string, session: AgentSession, sessionFile?: string | null): void {
+		const ref = this.#refs.get(id);
+		if (!ref) return;
+		ref.session = session;
+		if (sessionFile !== undefined) ref.sessionFile = sessionFile;
+		ref.lastActivity = Date.now();
+	}
+
+	detachSession(id: string): void {
+		const ref = this.#refs.get(id);
+		if (!ref) return;
+		ref.session = null;
+	}
+
+	unregister(id: string): void {
+		const ref = this.#refs.get(id);
+		if (!ref) return;
+		this.#refs.delete(id);
+		this.#emit({ type: "removed", ref });
+	}
+
+	get(id: string): AgentRef | undefined {
+		return this.#refs.get(id);
+	}
+
+	list(): AgentRef[] {
+		return [...this.#refs.values()];
+	}
+
+	/**
+	 * Returns every alive agent (running | idle) except the caller.
+	 * Flat namespace: every agent can see every other agent.
+	 */
+	listVisibleTo(id: string): AgentRef[] {
+		return this.list().filter(ref => ref.id !== id && (ref.status === "running" || ref.status === "idle"));
+	}
+
+	onChange(listener: RegistryListener): () => void {
+		this.#listeners.add(listener);
+		return () => this.#listeners.delete(listener);
+	}
+
+	#emit(event: RegistryEvent): void {
+		for (const listener of this.#listeners) {
+			try {
+				listener(event);
+			} catch {
+				// listeners must not break the dispatch loop
+			}
+		}
+	}
+}