@oh-my-pi-zen/pi-coding-agent 16.3.6-zen.1

package/src/prompts/tools/bash.md

@@ -0,0 +1,57 @@
+Runs bash in a shell session — terminal ops: git, bun, cargo, python.
+
+# When to use bash — and when not to
+
+Bash invokes **real binaries** with simple args. It is NOT a scripting surface.
+
+Use bash ONLY for: a single binary call, or one short pipeline that COMPUTES a fact (`wc -l`, `sort | uniq -c`, `comm`, `diff`, a checksum, `git status`).
+
+Anything below → `eval` cell, not bash:
+- Inline interpreter scripts (`-e`/`-c`/`--eval`) when an eval runtime exists for that language
+- Heredocs (`<<EOF`), `while`/`for`/`if`/`case` shell control flow
+- `$(…)` command substitution nested inside another command
+- Pipelines with more than two stages, or stages that need control flow or quote/JSON escaping
+- Multiline commands, `&&`-chains mixing control flow
+- Quote/JSON escaping that fights the shell
+
+<instruction>
+- `cwd` sets the working dir, not `cd dir && …`
+- `env: { NAME: "…" }` for multiline / quote-heavy / untrusted values; reference `$NAME`
+- Quote expansions (`"$NAME"`) to preserve exact content
+- `pty: true` only when the command needs a real terminal (`sudo`, `ssh` needing input); default `false`
+- `;` only when later commands should run despite earlier failures
+- Multiple bash calls per message run concurrently. NEVER split order-dependent commands across parallel calls — chain with `&&` in one call.
+- Internal URIs (`skill://`, `agent://`, …) auto-resolve to FS paths
+{{#if asyncEnabled}}
+- `async: true` for long-running commands when you don't need immediate output: returns a background job ID; result delivered as a follow-up.
+{{/if}}
+</instruction>
+
+<critical>
+- Bash invokes real binaries with simple args; it is NOT a scripting surface. Loops, conditionals, heredocs, inline interpreter scripts (`-e`/`-c`/`--eval`) when an eval runtime exists, several piped stages, or quote/JSON escaping mean you're writing a program → use `eval` cells: restartable, stateful, and free of shell-quoting traps.
+</critical>
+
+<output>
+- Returns output (stderr merged into stdout); exit code shown on non-zero exit.
+- Truncated output → `artifact://<id>` (linked in metadata).
+</output>
+
+{{#if asyncEnabled}}
+# Timeout and async
+
+- `timeout` (seconds) caps wall-clock duration; the process is killed on elapse.
+- `async: true` defers only reporting — it does NOT extend the timeout; a daemon run with `async: true` is still killed when `timeout` elapses.
+- Long-running daemons (dev servers, watchers): pass a large explicit `timeout`. The shell session persists across calls, so `cmd &` keeps running between bash calls.
+{{/if}}
+{{#if autoBackgroundEnabled}}
+
+## Auto-background
+
+- A long-running foreground call may convert to a background job; the final result arrives as a follow-up tool call. NOT a failure — don't retry or wait synchronously.
+- Need the result inline (e.g. piping into another command)? Raise `timeout` above expected duration{{#if asyncEnabled}}, or set `async: true` up front{{/if}}.
+{{/if}}
+
+# Output minimizer
+
+- Long output truncated; test/lint runner output filtered to failures. When visible text changed, a `[raw output: artifact://<id>]` footer links the full capture — read it if a run looks suspicious or you need exact bytes.
+- No footer = what you see is exactly what the command emitted.

package/src/prompts/tools/browser.md

@@ -0,0 +1,45 @@
+Drives real Chromium tab; full puppeteer access via JS.
+
+<instruction>
+- Static content (articles, docs, issues/PRs, JSON, PDFs, feeds)? `read` the URL. Browser only for JS execution, auth, interactive actions.
+- Three actions:
+  - `open` — acquire/reuse named tab (`name` defaults `"main"`). Optional `url` (navigate once ready), `viewport`, `dialogs: "accept" | "dismiss"` (auto-handle `alert`/`confirm`/`beforeunload`; else page hangs till you wire `page.on('dialog', …)`).
+  - `close` — release tab by `name`, or all with `all: true`. `kill: true` also kills spawned-app process trees.
+  - `run` — execute JS in existing tab. `code` = async function body; `page`, `browser`, `tab`, `display`, `assert`, `wait` in scope. Return value JSON-stringified into result; `display(value)` accumulates text/images.
+- Tabs survive `run` calls and in-process subagents — open once, reuse.
+- Browser kinds (`app` on `open`):
+  - default (no `app`) → headless Chromium with stealth patches.
+  - `app.path` → spawn absolute binary (Electron/CDP). No stealth patches — NEVER tamper with a real desktop app.
+  - `app.cdp_url` → connect to existing CDP endpoint (e.g. `http://127.0.0.1:9222`).
+  - `app.target` (with `path`/`cdp_url`) — substring on url+title picks BrowserWindow.
+- `tab` helpers; drop to raw puppeteer `page` for anything uncovered:
+  - `tab.goto(url, { waitUntil? })` — navigate.
+  - `tab.observe({ includeAll?, viewportOnly? })` — accessibility snapshot: `{ url, title, viewport, scroll, elements: [{ id, role, name, value, states, … }] }`. Ids stable until next observe/goto.
+  - `tab.ariaSnapshot(selector?, { depth?, boxes? })` — Playwright-format ARIA-tree YAML (nested roles + accessible names + `/url`/`/placeholder`), scoped to `selector` or the whole document. Every node carries a `[ref=eN]` id; `[cursor=pointer]` flags clickables. Captures dense, hierarchical structure/text that `observe()`'s flat list flattens away. Refs renumber from e1 each call and stay valid until the next `ariaSnapshot()`.
+  - `tab.ref("e5")` — `[ref=eN]` from the last ariaSnapshot → element handle with the common action methods (`.click()`, `.type()`, `.fill()`, `.hover()`, `.evaluate()`, …); the primary way to act on a ref. For convenience `aria-ref=e5` also works inline in `tab.click`/`type`/`fill`/`waitFor`/`scrollIntoView` (e.g. `tab.click("aria-ref=e5")`).
+  - `tab.id(n)` — id from last observe → `ElementHandle` (`.click()`, `.type()`, …).
+  - `tab.click(selector)` / `tab.type(selector, text)` / `tab.fill(selector, value)` / `tab.press(key, { selector? })` / `tab.scroll(dx, dy)`.
+  - `tab.waitFor(selector, { timeout? })` / `tab.waitForSelector(selector, { timeout?, visible?, hidden? })` — wait until attached (optionally visible/hidden); returns the `ElementHandle`.
+  - `tab.drag(from, to)` — endpoints: selector (center-to-center) or `{ x, y }` viewport point (canvases, sliders).
+  - `tab.scrollIntoView(selector)` — center in viewport; before clicking off-screen elements.
+  - `tab.select(selector, …values)` — set `<select>` option(s); returns selection. `tab.fill` NEVER works for selects.
+  - `tab.uploadFile(selector, …filePaths)` — attach files to `<input type="file">`; paths relative to cwd.
+  - `tab.waitForUrl(pattern, { timeout? })` — substring or `RegExp` (matches SPA pushState nav); returns matched URL.
+  - `tab.waitForResponse(pattern, { timeout? })` — substring, `RegExp`, or `(response) => boolean`; returns puppeteer `HTTPResponse` (`.text()`/`.json()`/`.status()`/`.headers()`).
+  - `tab.waitForNavigation({ waitUntil?, timeout? })` — resolves on the next navigation. Start it BEFORE the click/submit that triggers it; after `tab.goto` (which already waits) use `tab.waitForUrl`/`tab.waitForSelector` instead.
+  - `tab.evaluate(fn, …args)` — `page.evaluate` for ad-hoc DOM reads.
+  - `tab.screenshot({ selector?, fullPage?, save?, silent? })` — capture + attach for viewing (`silent: true` skips). Pass `save` only when a later step needs the file.
+  - `tab.extract(format = "markdown")` — readable page content (`"markdown"` | `"text"`); throws when nothing readable.
+- Selectors: CSS + puppeteer handlers `aria/Sign in`, `text/Continue`, `xpath/…`, `pierce/…`; also Playwright-style `p-aria/…`, `p-text/…`. Playwright-only engines/pseudos (`:has-text()`, `:visible`, …) are rejected — use `text/…` or `aria/…`. A stalled action/wait fails fast with a named `tab.<op> timed out` error, never the whole-cell timeout.
+</instruction>
+
+<critical>
+- MUST `open` before `run` — `run` never creates a tab.
+- Default to `tab.observe()` for page state — structured data, actionable ids. Screenshot ONLY when appearance matters.
+- Navigation invalidates element ids — re-observe before use.
+- `code` runs with full Node access. Treat as your code, not sandboxed.
+</critical>
+
+<output>
+Per call: `display(value)` output, then `code`'s return value. `run` always produces at least a status line.
+</output>

package/src/prompts/tools/checkpoint.md

@@ -0,0 +1,15 @@
+Creates a context checkpoint before exploratory work so you can later rewind and keep only a concise report.
+
+Use this when you need to investigate with many intermediate tool calls (read/grep/glob/lsp/etc.) and want to minimize context cost afterward.
+
+Rules:
+- You MUST call `rewind` before yielding after starting a checkpoint.
+- You NEVER call `checkpoint` while another checkpoint is active.
+- Not available in subagents.
+
+Typical flow:
+1. `checkpoint(goal: …)`
+2. Perform exploratory work
+3. `rewind(report: …)` with concise findings
+
+After rewind, intermediate checkpoint messages are removed from active context and replaced by the report.

package/src/prompts/tools/debug.md

@@ -0,0 +1,17 @@
+Debugger access.
+
+<instruction>
+- You SHOULD prefer this over bash for program state, breakpoints, stepping, thread inspection, or interrupting a running process.
+- `action: "launch"` starts a session; `program` required, `adapter` optional. Python: `adapter: "debugpy"`, `program` = target `.py`, interpreter/script flags in `args`.
+- `action: "attach"` connects to a running process: `pid` (local), `port` (remote), `adapter` forces a specific debugger.
+- **Breakpoints**: `set_breakpoint`/`remove_breakpoint` with source (`file`+`line`) or function (`function`); optional `condition`.
+- **Flow control**: `continue` (resume), `step_over`/`step_in`/`step_out` (single-step), `pause` (interrupt a running program).
+- **Inspect**: `threads`, `stack_trace` (current stopped thread), `scopes` (needs `frame_id` or current stopped frame), `variables` (needs `variable_ref` or `scope_id`), `evaluate` (needs `expression`; `context: "repl"` for raw debugger commands), `output` (stdout/stderr/console), `sessions`, `terminate`.
+</instruction>
+
+<caution>
+- Only one active debug session at a time.
+- Valid `adapter` values: `gdb`, `lldb-dap`, `python -m debugpy.adapter`, `dlv dap` (must be installed locally).
+- `program` must be an executable file or debug target, not a directory or bare interpreter name.
+- Python debugging requires `debugpy`; `pip install debugpy` if unavailable.
+</caution>

package/src/prompts/tools/eval.md

@@ -0,0 +1,72 @@
+Run one step of code in a persistent kernel.
+
+<instruction>
+**One eval call = one cell = one logical step.** State persists per language across separate eval calls, tool calls, and `task` subagents — define helpers/datasets/clients in one call, then later calls reuse them directly.
+
+Work incrementally: imports in one call, define in the next, test, then use — each its own eval call. Re-run setup ONLY after `reset`, a kernel crash, or a `NameError`/`ReferenceError` proving the state is gone. Parallelize work *within* a cell with the `parallel(thunks)` helper, not by batching steps.
+
+Fields:
+
+- `language` — {{#if py}}`"py"` IPython kernel{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}`"js"` persistent JavaScript VM{{/if}}{{#if rb}}{{#ifAny py js}}, {{/ifAny}}`"rb"` persistent Ruby kernel{{/if}}{{#if jl}}{{#ifAny py js rb}}, {{/ifAny}}`"jl"` persistent Julia kernel{{/if}}.
+- `code` — cell body, verbatim. Newlines/quotes JSON-encoded; no fences, no headers.
+- `title` (optional) — short transcript label (e.g. `"imports"`).
+- `timeout` (optional) — seconds. Raise only for heavy compute or long non-agent tool calls.
+- `reset` (optional) — wipe this language's kernel first.{{#ifAll py js}} Per-language: a `py` reset never touches the JS VM.{{/ifAll}}
+
+{{#if py}}Live event loop: use top-level `await` directly; `asyncio.run(…)` raises "cannot be called from a running event loop".{{/if}}
+{{#if js}}JS runs under **Bun**: Bun globals/APIs are available (`Bun.file`, `Bun.write`, `Bun.$`, `fetch`, `Buffer`); top-level `await`/`return` work directly.{{/if}}
+{{#if rb}}Ruby: synchronous; helper options are keyword args (e.g. `output("id", limit: 2)`); the last expression auto-displays unless it is `nil`, an assignment, or a definition (like IRB).{{/if}}
+{{#if jl}}Julia: synchronous; helper options are standard keyword args (e.g. `output("id", limit=2)`); the last expression auto-displays unless it is an assignment or a definition (like the Julia REPL).{{/if}}
+On error, fix and re-run only the failing step — prior calls' state survives.
+</instruction>
+
+<prelude>
+{{#ifAll py js}}Same helpers + arg order, both runtimes. Python: sync, options = trailing kwargs. JS: async/`await`able, options = ONE trailing object literal, never positional (extras throw).{{else}}{{#if py}}Sync; options = trailing kwargs.{{/if}}{{#if js}}Async/`await`able; options = ONE trailing object literal, never positional (extras throw).{{/if}}{{/ifAll}}{{#if rb}} Ruby: sync, options = trailing keyword args.{{/if}}{{#if jl}} Julia: sync, options = trailing keyword args.{{/if}}
+```
+display(value) → None
+    Cell output; figures/images/dataframes shown natively.
+print(value, ...) → None
+    Text output.
+read(path, offset?=1, limit?=None) → str
+    File as text; offset/limit 1-indexed lines. Accepts `local://…`.
+write(path, content) → str
+    Write file (creates parents) → resolved path. `local://…` persists across turns/subagents.
+env(key?=None, value?=None) → str | None | dict
+    No args → full env dict; one → value of `key`; two → set `key=value`, return value.
+output(*ids, format?="raw", query?=None, offset?=None, limit?=None) → str | dict | list[dict]
+    Task/agent output by id; one → text/dict, multiple → list.
+tool.<name>(args) → unknown
+    Invoke any session tool; `args` = its parameter object.
+completion(prompt, model?="default", system?=None, schema?=None) → str | dict
+    Oneshot, stateless (no history/tools). `model`: "smol" fast | "default" session | "slow" most capable. `schema` (JSON-Schema) → structured output, parsed object.
+{{#if spawns}}agent(prompt, agent?="{{spawnDefaultAgent}}", model?=None, label?=None, schema?=None, handle?=False) → str | dict
+    Run a subagent → final output. `agent` picks another discovered agent; omit it to use `{{spawnDefaultAgent}}`.{{#if spawnAllowedAgentsText}} Allowed agents: {{spawnAllowedAgentsText}}.{{/if}} `schema` as in completion(). Background via `local://` files named in the prompt. `handle` → DAG node dict { text, output, handle: "agent://<id>", id, agent } (parsed under `data` when `schema` set).
+{{#if js}}    JS: options are ONE trailing object — agent(prompt, { agent, schema, handle }).
+{{/if}}
+{{/if}}
+parallel(thunks) → list
+    Thunks through a bounded pool (wide as a `task` batch — don't pre-shrink), input order kept; returns when all finish, a throwing thunk propagates.
+pipeline(items, ...stages) → list
+    Map items through one-arg stages left-to-right, barrier between stages; stage 1 gets the item, later stages the previous result.
+log(message) → None
+    Progress line above the status tree.
+phase(title) → None
+    Phase grouping subsequent status lines.
+budget → per-turn token budget
+    {{#if py}}`budget.total` (ceiling or None), `budget.spent()`, `budget.remaining()` (math.inf when no ceiling), `budget.hard`.{{/if}}{{#if js}}`await budget.total()` (ceiling or null), `await budget.spent()`, `await budget.remaining()` (Infinity when no ceiling), `await budget.hard()`.{{/if}}{{#if rb}} Ruby: `budget.total` (ceiling or nil), `budget.spent`, `budget.remaining` (Float::INFINITY when no ceiling), `budget.hard`.{{/if}}{{#if jl}} Julia: `budget.total` (ceiling or nothing), `budget.spent()`, `budget.remaining()` (Inf when no ceiling), `budget.hard`.{{/if}} Ceiling: `+Nk` (advisory) or `+Nk!`/Goal Mode (hard — `agent()` won't spawn past it); spend still tracked.
+```
+</prelude>
+{{#if spawns}}
+<dag>
+Pipe handles through stage helpers to build a dependency graph — acyclic waves:
+- **Name nodes.** Capture each `agent(…, {{#if py}}handle=True{{/if}}{{#if js}}{ handle: true }{{/if}}{{#if jl}}handle=true{{/if}})` result; carries `handle` (`agent://<id>`) + `output`.
+- **Wire edges by reference.** Put an upstream node's `handle`/`output` in the dependent stage's prompt — large transcript never re-inlined. Bulk: `write("local://<name>.md", …)`, pass the URI.
+- **`pipeline(items, *stages)` = staged waves**, barrier between stages (every item clears stage N before any enters N+1). **`parallel(thunks)` = one wave** of independent nodes.
+- **Isolate failure.** A raising node re-raises the lowest-index error, aborts its wave; wrap risky nodes in try/except so a failure degrades only its dependent subtree, independent branches finish.
+- **Acyclic only.** A node never waits on its own descendant.
+</dag>
+{{/if}}
+
+<critical>
+Prior top-level names (`data`, `sessions`, helpers, imports) survive into the next eval call — reuse them; NEVER re-import, re-require, or re-declare a helper. Re-read a file only if it may have changed since the last read. Re-run setup only after `reset`, a crash, or a `NameError`/`ReferenceError`.
+</critical>

package/src/prompts/tools/github.md

@@ -0,0 +1,17 @@
+Op-based `gh` wrapper: repos, PRs, search, checkout, push, Actions watch. Read an issue/PR via `issue://<N>`/`pr://<N>`. PR diffs: `pr://<N>/diff` (file listing), `pr://<N>/diff/<i>` (file slice, 1-indexed), `pr://<N>/diff/all` (full diff).
+
+<instruction>
+Pick op via `op`. Beyond the field descriptions, per op:
+- `repo_view` — omit `repo` to view the current checkout.
+- `pr_create` — `head` defaults to the current branch.
+- `pr_checkout` — checks PR(s) out into dedicated git worktrees, not your working tree; pass an array of `pr` to batch multiple in one call.
+- `pr_push` — requires the branch to have been checked out first via `op: pr_checkout`.
+- `search_issues`/`search_prs`/`search_commits`/`search_repos` — `query` is optional when `since`/`until` is set (omit it for a date-only filter). `search_code` supports neither: `query` is required and `since`/`until` are rejected.
+- `search_*` default `repo` to the current checkout's `owner/repo`; pass a `repo:`/`org:`/`user:` qualifier in `query` to search elsewhere. `search_repos` is the exception — it ignores `repo`; scope it with `org:`/`language:` qualifiers in `query`.
+- `since`/`until` — relative duration (`<n>` + `m`/`h`/`d`/`w`/`mo`/`y`, e.g. `3d`, `2w`), ISO date (`YYYY-MM-DD`), or ISO datetime. `dateField: "updated"` filters on update time (issues/PRs) or push time (repos), not creation.
+- `run_watch` — omit `run` to watch every run for the current HEAD (`branch` falls back to current). Fast-fails on the first job failure.
+</instruction>
+
+<output>
+Concise summary per op. `run_watch` failures save full logs to a session artifact.
+</output>

package/src/prompts/tools/glob.md

@@ -0,0 +1,15 @@
+Globs files and directories via fast pattern matching, any codebase size.
+
+<instruction>
+- `path`: a glob, file, or directory. Search several at once by passing a semicolon-delimited list (`src/**/*.ts; test/**/*.ts`).
+- `gitignore` (default `true`) hides `.gitignore` matches. Set `gitignore: false` to find `.env*`, `*.log`, fresh build outputs, or anything your repo ignores.
+- `hidden` (default `true`); combine with `gitignore: false` to surface dotfiles also gitignored.
+</instruction>
+
+<output>
+Matching paths sorted by mtime (newest first), grouped under `# <dir>/` headers with basenames below; directories get a trailing `/`.
+</output>
+
+<avoid>
+Open-ended searches needing multiple rounds of globbing/searching: you MUST use the Task tool instead.
+</avoid>

package/src/prompts/tools/goal.md

@@ -0,0 +1,11 @@
+Manage the active goal-mode objective.
+
+Use a single `op` field:
+- `create` starts a goal. Requires `objective`; optional `token_budget` must be positive. Use only when no goal exists and no goal is paused.
+- `get` returns the current goal (active or paused) and remaining token budget.
+- `resume` re-activates a paused goal so work can continue.
+- `complete` marks the goal complete after you have verified every deliverable against current evidence.
+- `drop` discards the current goal without completing it.
+
+NEVER call `complete` because a budget is low or a turn is ending. Call it only when the goal is actually done and verified.
+If `get` shows a paused goal, call `resume` before continuing work on it.

package/src/prompts/tools/grep.md

@@ -0,0 +1,22 @@
+Greps files using regex.
+
+<instruction>
+- Rust regex (RE2-style) — no lookaround/backreferences; use line anchors or post-filters instead of (?!…)/(?<!…).
+- `path`: SHOULD scope to a known path (e.g. `src`); pass several as a delimited list (`src; tests`).
+- Cross-line patterns detected from literal `\n` or `\\n` in `pattern`.
+</instruction>
+
+<output>
+{{#if IS_HL_MODE}}
+- Per matched file: snapshot tag header + numbered lines: `[src/login.ts#1A2B]`, `*42:if (user.id) {` (match), ` 43:return user;` (context). Copy header for anchored edits; ops use bare line numbers.
+{{else}}
+{{#if IS_LINE_NUMBER_MODE}}
+- Output is line-number-prefixed.
+{{/if}}
+{{/if}}
+</output>
+
+<critical>
+- MUST use built-in `grep` for any content search. NEVER shell out to `grep`, `rg`, `ripgrep`, `ag`, `ack`, `git grep`, `awk`, `sed`-for-search, or any CLI search via Bash — not even for one match or a quick check.
+- Open-ended search needing multiple rounds? MUST use the Task tool with the explore subagent, NOT chained `grep` calls.
+</critical>

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>
+- You MUST provide a single detailed `subject` prompt for image generation or editing.
+- When using multiple `input`, you SHOULD describe each image's role directly in `subject`, e.g. `Image 1` for composition reference, `Image 2` for lighting reference, `Image 3` for background.
+- For text: you SHOULD add "sharp, legible, correctly spelled" for important text; 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/irc.md

@@ -0,0 +1,24 @@
+Send and receive short text messages between the agents running in this process.
+
+# Addressing and Discovery
+The main agent is always `Main`. Subagents inherit their task ID (e.g., `AuthLoader`). If you don't know who is currently running, use `op: "list"` to view all peers alongside their status, unread message count, and recent activity. Address peers by their exact ID from the roster; NEVER invent names.
+
+# Messaging Rules
+Use `op: "send"` to deliver a message to a specific peer or broadcast to `"all"`.
+- **Fire and forget:** Sending NEVER blocks. You get delivery receipts immediately (`delivered` or `failed`). Do not wait around—send your message and keep working. If a receipt says `failed`, the peer is gone; do not retry.
+- **Waking peers:** Sending a message to an `idle` or `parked` agent automatically wakes them up.
+- **Answering:** When replying to a question, use `op: "send"`, lead directly with your answer (NEVER quote the original message), and set `replyTo` so the recipient can correlate it.
+- **Format:** Messages MUST be plain prose. NEVER send JSON status objects. Keep it terse and share paths via `local://` or `artifact://` URLs, not pasted blobs.
+
+# Waiting and Inboxes
+Messages only arrive when the peer actively sends one—do not interrogate a peer for status.
+- If you are completely blocked and MUST wait for an answer, use `op: "wait"` (or `await: true` on a send). The wait returns when a matching message arrives, the timeout elapses, or any IRC / steering message interrupts the wait. Parent-agent IRC interrupts with steering-level priority.
+- No need to alternate `irc wait`, `irc inbox`, and `job poll`: waits surface cross-channel interrupts promptly. The next turn includes the interrupt reason and message.
+- To check for messages without blocking, use `op: "inbox"` to drain your queue.
+
+# When to Coordinate
+Message peers instead of guessing, duplicating work, or spying.
+- Use IRC when you hit an unexpected state (e.g., missing files) or an out-of-scope decision. DM `Main` or your spawner for guidance.
+- If you overlap with another agent's work or need a file they are touching, DM them before editing.
+- NEVER use shell tools, grep, or read other sessions' files to figure out what a peer is doing. Message them directly.
+- NEVER use IRC for something a tool can answer (e.g., grepping codebase, running a build).

package/src/prompts/tools/job.md

@@ -0,0 +1,11 @@
+Manages async background tasks (e.g. bash scripts, subagents).
+
+Background tasks deliver their results automatically the moment they finish. You NEVER need to poll to retrieve output. Only use this tool if you need to intervene in the lifecycle of a task.
+
+# Interventions
+
+- **Block and wait:** Pass `poll` with specific job IDs when you are completely blocked and cannot do any other work. The call returns as soon as one watched job finishes, the wait window elapses, or an IRC / steering message interrupts the wait — NOT when all jobs finish; re-issue to keep waiting.
+  - To watch EVERY running job, issue a call with NO fields at all (no `poll`, no `cancel`, no `list`). NEVER pass an array of every running ID.
+  - A finished job's output, or the interrupting message and reason, is included in the next turn.
+- **Stop execution:** Pass `cancel` with job IDs to kill jobs that have hung, stalled, or are no longer needed. A cancel-only call returns immediately.
+- **Snapshot:** Pass `list: true` to get the current status of all jobs without waiting.

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,28 @@
+Symbol-aware code intelligence from language servers — the accurate path for navigation, refactors, and diagnostics where text search or edits would miss callsites.
+
+<operations>
+Position-based — pass `file` + `line` + `symbol` (substring on that line; append `#N` for the Nth match, e.g. `kind#2`):
+- `definition`, `type_definition`, `implementation`, `references`, `hover` — standard LSP lookups
+- `rename` — rename the symbol everywhere; **applies by default**, `apply: false` previews; needs `new_name`
+- `code_actions` — quick-fixes/refactors/imports at that position; lists by default (`query` filters by kind, e.g. `quickfix`, `source.organizeImports`), **applies one only with `apply: true` + `query`** (then `query` = action title substring or numeric index)
+
+File / workspace:
+- `diagnostics` — errors/warnings for a path, a glob (`src/**/*.ts`), or the whole workspace (`file: "*"`)
+- `symbols` — `file` lists that file's symbols; `file: "*"` + `query` searches the workspace
+- `rename_file` — move `file` → `new_name` on disk AND rewrite imports/references through the server; applies by default
+
+Servers:
+- `status`, `capabilities` — what's running / per-server capabilities (one via `file`, all via `*`)
+- `reload` — restart one server (`file`) or all (`*`); `reload *` also re-reads project LSP config
+- `request` — raw escape hatch: `query` = method (`rust-analyzer/expandMacro`, `workspace/executeCommand`), `payload` = JSON params (else auto-built from `file`/`line`/`symbol`)
+</operations>
+
+<caution>
+- `line` is 1-indexed. Project-aware `definition`/`references`/`rename` ERROR without `symbol` rather than guess the wrong identifier; a missing match or out-of-range `#N` is an explicit error, never a silent fallback.
+</caution>
+
+<critical>
+- Symbol-aware work (rename, references, definition/type/impl, code actions) MUST use `lsp` whenever a server is available — it follows shadowing, re-exports, and cross-file usages that text tools miss.
+- NEVER do a cross-file rename with `ast_edit`, `sed`, or 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,8 @@
+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`.
+
+Prefer `invalidate` when a memory became stale but its history may still be useful. Use `forget` only for content that should be hard-deleted.

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,77 @@
+Read files, directories, archives, SQLite, images, documents, internal resources, and web URLs via one `path`.
+
+<instruction>
+- SHOULD parallelize independent reads.
+- SHOULD use `read` (not a browser tool) for web content; browser only when `read` can't deliver.
+</instruction>
+
+## Parameters
+
+- `path` — required. Local path, internal URI (`skill://`, `agent://`, `artifact://`, `memory://`, `rule://`, `local://`, `vault://`, `mcp://`, `omp://`, `issue://`, `pr://`, `ssh://`), or URL. Append `:<sel>` for ranges/modes (e.g. `src/foo.ts:50-200`, `src/foo.ts:raw`, `db.sqlite:users:42`).
+
+## Selectors
+
+- _(none)_ — parseable code → structural summary; other files → from start (up to {{DEFAULT_LIMIT}} lines).
+- `:50` / `:50-` — from line 50 onward.
+- `:50-200` — lines 50–200 inclusive.
+- `:50+150` — 150 lines from 50.
+- `:20+1` — anchor line 20.
+- `:5-16,960-973` — multiple ranges in one call.
+- `:raw` — verbatim; no anchors/summary/line prefixes.
+- `:2-4:raw` / `:raw:2-4` — range AND verbatim; either order.
+- `:conflicts` — one line per unresolved git merge conflict block.
+
+# Files
+
+- Directory → depth-limited dirent listing.
+{{#if IS_HL_MODE}}
+- File + selector → filename-only snapshot header + numbered lines: `[foo.ts#1A2B]` then `41:def alpha():`. Copy `[FILENAME#TAG]` for anchored edits; ops use bare line numbers. NEVER fabricate the tag.
+{{else}}
+{{#if IS_LINE_NUMBER_MODE}}
+- File + selector → numbered lines: `41|def alpha():`.
+{{/if}}
+{{/if}}
+- Parseable code, no selector → **structural summary**: declarations kept, body elided with `…`. Footer names the recovery selector; re-issue ONLY the ranges you need.
+
+# Documents & Notebooks
+
+PDF, Word, PowerPoint, Excel, RTF, EPUB → extracted text. Notebooks (`.ipynb`) → editable `# %% [type] cell:N` text. `:raw` bypasses the converter.
+
+# Images
+
+{{#if INSPECT_IMAGE_ENABLED}}
+Image → metadata. Visual analysis: call `inspect_image` with the path and a question.
+{{else}}
+Image → decoded inline (PNG, JPEG, GIF, WEBP) for direct visual analysis.
+{{/if}}
+
+# Archives
+
+`.tar`, `.tar.gz`, `.tgz`, `.zip`. `archive.ext:path/inside/archive` reads a member; inner paths take normal selectors: `archive.zip:dir/file.ts:50-60`.
+
+# SQLite
+
+For `.sqlite`, `.sqlite3`, `.db`, `.db3`:
+- `file.db` — tables with row counts
+- `file.db:table` — schema + sample rows
+- `file.db:table:key` — row by primary key
+- `file.db:table?limit=50&offset=100` — pagination
+- `file.db:table?where=status='active'&order=created:desc` — filter/order
+- `file.db?q=SELECT …` — read-only SELECT
+
+# URLs
+
+- Reader-mode default: HTML, GitHub issues/PRs, Stack Overflow, Wikipedia, Reddit, NPM, arXiv, RSS/Atom, JSON endpoints, PDFs → clean text/markdown.
+- `:raw` → untouched HTML; line selectors (`:50`, `:50-100`, `:50+150`) paginate the fetch.
+- Bare `host:port` collides with selector grammar — add a trailing slash: `https://example.com/:80`.
+
+# Internal URIs
+
+All URI schemes take the same line selectors. `artifact://<id>` recovers spilled output; large artifacts block unbounded `:raw`, so page with `artifact://<id>:N-M` / `artifact://<id>:raw:N-M` and use the reported artifact file path for search/copy workflows.
+
+`ssh://host/<absolute-path>` reads a remote text file (UTF-8, ≤1 MiB) or lists a directory one level deep, on a pre-configured SSH host or `~/.ssh/config` alias; `ssh://host/` lists the remote root and bare `ssh://` lists the configured hosts. Files are also writable via `write` and searchable via `search`; a directory only lists (`search` refuses a directory, `write` refuses to overwrite one). A literal `:`, `?`, or `#` in the remote path must be percent-encoded (`%3A`/`%3F`/`%23`) — a trailing `:sel` is read as a line selector, and `?`/`#` start a URL query/fragment. Requires a POSIX login shell (`sh`/`bash`/`zsh`); a Windows host or a non-POSIX shell (fish, csh/tcsh) is rejected — use the `ssh` tool there.
+
+<critical>
+- Line ranges go in the selector: `path="src/foo.ts:50-200"`.
+- Summary footer names elided ranges? Re-issue ONLY those ranges. NEVER guess `..`/`…` 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.