@jawcode-dev/coding-agent 1.1.0

package/src/prompts/tools/apply-patch.md

@@ -0,0 +1,65 @@
+Use the `apply_patch` shell command to edit files.
+Your patch language is a stripped‑down, file‑oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high‑level envelope:
+
+*** Begin Patch
+[ one or more file sections ]
+*** End Patch
+
+Within that envelope, you get a sequence of file operations.
+You MUST include a header to specify the action you are taking.
+Each operation starts with one of three headers:
+
+*** Add File: <path> - create a new file. Every following line is a + line (the initial contents).
+*** Delete File: <path> - remove an existing file. Nothing follows.
+*** Update File: <path> - patch an existing file in place (optionally with a rename).
+
+May be immediately followed by *** Move to: <new path> if you want to rename the file.
+Then one or more "hunks", each introduced by @@ (optionally followed by a hunk header).
+Within a hunk each line starts with:
+
+For instructions on [context_before] and [context_after]:
+- By default, show 3 lines of code immediately above and 3 lines immediately below each change. If a change is within 3 lines of a previous change, do NOT duplicate the first change's [context_after] lines in the second change's [context_before] lines.
+- If 3 lines of context is insufficient to uniquely identify the snippet of code within the file, use the @@ operator to indicate the class or function to which the snippet belongs. For instance, we might have:
+@@ class BaseClass
+[3 lines of pre-context]
+- [old_code]
++ [new_code]
+[3 lines of post-context]
+- If a code block is repeated so many times in a class or function such that even a single `@@` statement and 3 lines of context cannot uniquely identify the snippet of code, you can use multiple `@@` statements to jump to the right context. For instance:
+
+@@ class BaseClass
+@@ 	 def method():
+[3 lines of pre-context]
+- [old_code]
++ [new_code]
+[3 lines of post-context]
+
+The full grammar definition is below:
+Patch := Begin { FileOp } End
+Begin := "*** Begin Patch" NEWLINE
+End := "*** End Patch" NEWLINE
+FileOp := AddFile | DeleteFile | UpdateFile
+AddFile := "*** Add File: " path NEWLINE { "+" line NEWLINE }
+DeleteFile := "*** Delete File: " path NEWLINE
+UpdateFile := "*** Update File: " path NEWLINE [ MoveTo ] { Hunk }
+MoveTo := "*** Move to: " newPath NEWLINE
+Hunk := "@@" [ header ] NEWLINE { HunkLine } [ "*** End of File" NEWLINE ]
+HunkLine := (" " | "-" | "+") text NEWLINE
+
+A full patch can combine several operations:
+
+*** Begin Patch
+*** Add File: hello.txt
++Hello world
+*** Update File: src/app.py
+*** Move to: src/main.py
+@@ def greet():
+-print("Hi")
++print("Hello, world!")
+*** Delete File: obsolete.txt
+*** End Patch
+
+It is important to remember:
+- You must include a header with your intended action (Add/Delete/Update)
+- You must prefix new lines with `+` even when creating a new file
+- File references can only be relative, NEVER ABSOLUTE.

package/src/prompts/tools/ask.md

@@ -0,0 +1,29 @@
+Asks user when you need clarification or input during task execution.
+
+<conditions>
+- Multiple approaches exist with significantly different tradeoffs user should weigh
+</conditions>
+
+<instruction>
+- Use `recommended: <index>` to mark default (0-indexed); " (Recommended)" added automatically
+- Use `questions` for multiple related questions instead of asking one at a time
+- Set `multi: true` on question to allow multiple selections
+</instruction>
+
+<caution>
+- Provide 2-5 concise, distinct options
+</caution>
+
+<critical>
+- **Default to action.** Resolve ambiguity yourself using repo conventions, existing patterns, and reasonable defaults. Exhaust existing sources (code, configs, docs, history) before asking. Only ask when options have materially different tradeoffs the user must decide.
+- **If multiple choices are acceptable**, pick the most conservative/standard option and proceed; state the choice.
+- **Do NOT include "Other" option** — UI automatically adds "Other (type your own)" to every question.
+</critical>
+
+<examples>
+# Single question
+questions: [{"id": "auth_method", "question": "Which authentication method should this API use?", "options": [{"label": "JWT"}, {"label": "OAuth2"}, {"label": "Session cookies"}], "recommended": 0}]
+
+# Multiple questions
+questions: [{"id": "storage_type", "question": "Which storage backend?", "options": [{"label": "SQLite"}, {"label": "PostgreSQL"}]}, {"id": "auth_method", "question": "Which auth method?", "options": [{"label": "JWT"}, {"label": "Session cookies"}]}]
+</examples>

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

@@ -0,0 +1,39 @@
+Performs structural AST-aware rewrites via native ast-grep.
+
+<instruction>
+- Use for codemods and structural rewrites where plain text replace is unsafe
+- `paths` is required and accepts an array of files, directories, globs, or internal URLs
+- Language is inferred from `paths`; narrow each call to one language for deterministic rewrites
+- Metavariables captured in `pat` (`$A`, `$$$ARGS`) are substituted into that entry's `out` template
+- **Patterns match AST structure, not text.** `$NAME` = one node (captured); `$_` = one without binding; `$$$NAME` = zero-or-more (lazy — stops at next matchable element); `$$$` = zero-or-more without binding. Use `$$$NAME`, NOT `$$NAME` — the two-dollar form is invalid. Metavariable names are UPPERCASE and MUST be the whole AST node — partial text like `prefix$VAR` or `"hello $NAME"` does NOT work
+- When the same metavariable appears twice, both occurrences MUST match identical code (`$A == $A` matches `x == x`, not `x == y`)
+- Rewrite patterns MUST parse as a single valid AST node. For method fragments or body snippets that don't parse standalone, wrap in context (e.g. `class $_ { … }`)
+- For TS declarations/methods, tolerate unknown annotations: `async function $NAME($$$ARGS): $_ { $$$BODY }` or `class $_ { method($ARG: $_): $_ { $$$BODY } }`
+- Delete matched code with empty `out`: `{"pat":"console.log($$$)","out":""}`
+- Each rewrite is a 1:1 structural substitution — cannot split one capture across multiple nodes or merge multiple captures into one
+</instruction>
+
+<output>
+- Replacement summary, per-file replacement counts, and change diffs as `-LINE+ID|before` / `+LINE+ID|after` lines
+- Parse issues when files cannot be processed
+</output>
+
+<examples>
+# Rename a call site across TypeScript files
+`{"ops":[{"pat":"oldApi($$$ARGS)","out":"newApi($$$ARGS)"}],"paths":["src/**/*.ts"]}`
+# Delete matching calls
+`{"ops":[{"pat":"console.log($$$ARGS)","out":""}],"paths":["src/**/*.ts"]}`
+# Rewrite import source path
+`{"ops":[{"pat":"import { $$$IMPORTS } from \"old-package\"","out":"import { $$$IMPORTS } from \"new-package\""}],"paths":["src/**/*.ts"]}`
+# Modernize to optional chaining (same metavariable enforces identity)
+`{"ops":[{"pat":"$A && $A()","out":"$A?.()"}],"paths":["src/**/*.ts"]}`
+# Swap two arguments using captures
+`{"ops":[{"pat":"assertEqual($A, $B)","out":"assertEqual($B, $A)"}],"paths":["tests/**/*.ts"]}`
+# Python — convert print calls to logging
+`{"ops":[{"pat":"print($$$ARGS)","out":"logger.info($$$ARGS)"}],"paths":["src/**/*.py"]}`
+</examples>
+
+<critical>
+- Parse issues mean the rewrite is malformed or mis-scoped — fix the pattern before assuming a clean no-op
+- For one-off local text edits, prefer the Edit tool
+</critical>

package/src/prompts/tools/ast-grep.md

@@ -0,0 +1,42 @@
+Performs structural code search using AST matching via native ast-grep.
+
+<instruction>
+- Use when syntax shape matters more than raw text (calls, declarations, specific language constructs)
+- `paths` is required and accepts an array of files, directories, globs, or internal URLs
+- Language is inferred from `paths`; narrow each call to one language when mixed-language trees could cause parse noise
+- `pat` is a single AST pattern. Run separate calls for distinct unrelated patterns
+- **Patterns match AST structure, not text** — whitespace/formatting is ignored
+- `$NAME` captures one node; `$_` matches one without binding; `$$$NAME` captures zero-or-more (lazy — stops at next matchable element); `$$$` matches zero-or-more without binding. Use `$$$NAME`, NOT `$$NAME` — the two-dollar form is invalid and produces a parse error
+- Metavariable names are UPPERCASE and must be the whole AST node — partial-text like `prefix$VAR`, `"hello $NAME"`, or `a $OP b` does NOT work; match the whole node instead
+- When the same metavariable appears twice, both occurrences MUST match identical code (`$A == $A` matches `x == x`, not `x == y`)
+- Patterns MUST parse as a single valid AST node for the inferred target language. For method fragments or body snippets that don't parse standalone, wrap in valid context (e.g. `class $_ { … }`)
+- C++ qualified calls used as expression statements need the statement semicolon in the pattern: use `ns::doThing($ARG);`, `$CALLEE($ARG);`, or wrap a statement snippet. Without `;`, tree-sitter-cpp may parse `ns::doThing($ARG)` as declaration-like syntax and return no matches
+- For TS declarations/methods, tolerate unknown annotations: `async function $NAME($$$ARGS): $_ { $$$BODY }` or `class $_ { method($ARG: $_): $_ { $$$BODY } }`
+- Declaration forms are structurally distinct — top-level `function foo`, class method `foo()`, and `const foo = () => {}` are different AST shapes; search the right form before concluding absence
+- Loosest existence check: `pat: "executeBash"` with narrow `paths`
+</instruction>
+
+<output>
+- Grouped matches with file path, byte range, line/column ranges, metavariable captures
+- Match lines are anchor-prefixed: `*LINE+ID|content` for the matched line and ` LINE+ID|content` (leading space) for surrounding context
+- Summary counts (`totalMatches`, `filesWithMatches`, `filesSearched`) and parse issues when present
+</output>
+
+<examples>
+# Search TypeScript files under src
+`{"pat":"console.log($$$)","paths":["src/**/*.ts"]}`
+# Named imports from a specific package
+`{"pat":"import { $$$IMPORTS } from \"react\"","paths":["src/**/*.ts"]}`
+# Arrow functions assigned to a const
+`{"pat":"const $NAME = ($$$ARGS) => $BODY","paths":["src/utils/**/*.ts"]}`
+# Method call on any object, ignoring method name with `$_`
+`{"pat":"logger.$_($$$ARGS)","paths":["src/**/*.ts"]}`
+# Loosest existence check for a symbol in one file
+`{"pat":"processItems","paths":["src/worker.ts"]}`
+</examples>
+
+<critical>
+- Avoid repo-root scans — narrow `paths` first
+- Parse issues are query failure, not evidence of absence: repair the pattern or tighten `paths` before concluding "no matches"
+- For broad/open-ended exploration across subsystems, use Task tool with explore subagent first
+</critical>

package/src/prompts/tools/async-result.md

@@ -0,0 +1,8 @@
+<system-notice>
+{{#if multiple}}{{jobs.length}} background jobs have completed. Resume your work using the results below.
+
+{{else}}Background job {{jobs.[0].jobId}} has completed. Resume your work using the result below.
+{{/if}}{{#each jobs}}{{#if @root.multiple}}── Job {{this.jobId}}{{#if this.label}} ({{this.label}}){{/if}} ──
+{{/if}}{{this.result}}{{#unless @last}}
+{{/unless}}{{/each}}
+</system-notice>

package/src/prompts/tools/background.md

@@ -0,0 +1,19 @@
+Manage background work rows created by existing launch tools.
+
+Launch stays with the existing tool:
+- Use `task` for detached subagents.
+- Use `bash` async/background behavior for long-running shell work.
+- Use `monitor` for streaming monitor jobs.
+
+Use this tool to inspect and manage those rows:
+- `op: "list"` — enumerate current background rows before claiming background state.
+- `op: "detail"` — inspect kind, status, attention, timing, previews, and verified output refs when available.
+- `op: "follow"` — read retained output and preserve `nextOffset` when repeatedly following a row.
+- `op: "cancel"` — cancel only when the user asks or when work is clearly obsolete or unsafe.
+- `op: "settings"` — read background-related settings/keybindings only; this tool never mutates settings.
+
+Long-running work should be background-launched when it can proceed independently while the user or agent continues other work. Keep work foreground when it needs interactive input, immediate output, or a user decision.
+
+The TUI footer/panel rows (`bg … · ctrl+j`) and this tool's rows are two views over the same canonical background work. Do not claim a footer/background state from memory; call `list`, `detail`, or `follow` when accuracy matters.
+
+Keep progress commentary concise and factual: report observed state, current focus, concrete output, or real blockers. Avoid empty roadmap text.

package/src/prompts/tools/bash.md

@@ -0,0 +1,50 @@
+Executes bash command in shell session for terminal operations like git, bun, cargo, python.
+
+<instruction>
+- Use `cwd` to set working directory, not `cd dir && …`
+- Prefer `env: { NAME: "…" }` for multiline, quote-heavy, or untrusted values; reference as `$NAME`
+- Quote variable expansions like `"$NAME"` to preserve exact content
+- PTY mode is opt-in: set `pty: true` only when the command needs a real terminal (e.g. `sudo`, `ssh` requiring user input); default is `false`
+- Use `;` only when later commands should run regardless of earlier failures
+- Internal URIs (`agent://`, `artifact://`, `rule://`, `local://`) are auto-resolved to filesystem paths
+{{#if asyncEnabled}}
+- Use `async: true` for long-running commands when you don't need immediate output; the call returns a background job ID and the result is delivered automatically as a follow-up.
+- Manage resulting background rows with the `background` tool for list/detail/follow/cancel. The TUI footer rows (`bg … · ctrl+j`) and `background` tool rows describe the same background work.
+- Keep commands in the foreground when they are interactive, require immediate output, or need a user decision.
+{{/if}}
+</instruction>
+{{#if restrictedAllowedPrefixes}}
+<restricted-role-agent-mode>
+This session's bash tool is restricted. It only accepts commands beginning with:
+{{#each restrictedAllowedPrefixes}}
+- `{{this}}`
+{{/each}}
+Use it only for sanctioned jwc workflow CLI persistence or state read/write/contract operations; per-command env overrides and all other shell command shapes are blocked before execution.
+</restricted-role-agent-mode>
+{{/if}}
+
+<critical>
+- NEVER use Linux coreutils (`cat`, `head`, `tail`, `less`, `more`, `ls`, `grep`, `rg`, `awk`, `sed`, `find`, `fd`, etc.) when a dedicated tool suffices — ALWAYS prefer `read`, `search`, `find`, `edit`, `write`.
+- NEVER pipe through `| head -n N` or `| tail -n N` — output is already truncated with the full result available via `artifact://<id>`.
+- NEVER redirect with `2>&1` or `2>/dev/null` — stdout and stderr are already merged.
+</critical>
+
+<output>
+- Returns output and exit code.
+- Truncated output is retrievable from `artifact://<id>` (linked in metadata)
+- Exit codes shown on non-zero exit
+</output>
+
+{{#if asyncEnabled}}
+# Timeout and async
+
+- `timeout` (seconds) caps the **wall-clock duration** of the command. When it elapses the process is killed and the call returns with a timeout annotation. Range: `1`–`3600`s; default `300`s (see `clampTimeout("bash", …)` in `tool-timeouts.ts`).
+- `async: true` only defers **reporting** of the result — it does NOT disable, extend, or detach the timeout. A daemon started with `async: true` is still killed when `timeout` elapses, regardless of how long the agent waits before reading the result.
+- For long-running daemons (dev servers, watchers): either pass an explicit large `timeout` (up to `3600`), or fully detach the process from this shell using `nohup …  &` / `setsid … &` / `disown` so it survives independent of the bash call's lifecycle.
+{{/if}}
+
+# Output minimizer
+
+- Bash stdout/stderr may be rewritten before you see it: long output is head/tail truncated, and test/lint runners (e.g. `bun test`, `cargo test`, ESLint) are passed through heuristic filters that drop noise and keep failures.
+- When the minimizer changes the visible text, the tool appends a `[raw output: artifact://<id>]` footer pointing at the **full untouched capture**. If a run looks suspicious (e.g. only a version banner) or you need the exact bytes, read that artifact.
+- If no footer is present, what you see is what the command actually emitted.

package/src/prompts/tools/browser.md

@@ -0,0 +1,14 @@
+Control a real Chromium tab — JS execution, interactive actions, authentication flows.
+
+<instruction>
+- For static web content (articles, docs, issues, JSON, PDFs), prefer `read` with a URL. Use `browser` when you need JS, authentication, or interaction.
+- Four actions: `open` (acquire a named tab, optionally navigate), `close` (release tab(s)), `run` (execute JS with `page`/`tab` helpers), `act` (structured `[{verb, …}]` steps — preferred for routine interaction).
+- Default to `observe` over `screenshot` for understanding page state. Screenshot only when visual appearance matters.
+- For attached desktop apps, use `app.path` or `app.cdp_url` on `open`.
+- For detailed usage — tab helpers, action verbs, selectors, examples — reference the `browse` skill.
+</instruction>
+
+<critical>
+- You MUST call `open` before `run` or `act`. Neither implicitly creates a tab.
+- After navigation, prior element ids from `observe` are invalidated. Re-observe before referencing them.
+</critical>

package/src/prompts/tools/calculator.md

@@ -0,0 +1,10 @@
+Performs basic calculations.
+
+<instruction>
+- Supports +, -, *, /, %, ** and parentheses
+- Supports decimal, hex (0x), binary (0b), and octal (0o) literals
+</instruction>
+
+<output>
+Returns each calculation result with its prefix and suffix applied.
+</output>

package/src/prompts/tools/checkpoint.md

@@ -0,0 +1,16 @@
+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/search/find/lsp/etc.) and want to minimize context cost afterward.
+
+Rules:
+- You MUST call `rewind` before yielding after starting a checkpoint.
+- You MUST provide a clear `goal` explaining what you are investigating.
+- 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/computer-use.md

@@ -0,0 +1,15 @@
+Control desktop applications through the lazy cua-driver backend. The backend process starts only when this tool is called.
+
+<instruction>
+- Use `list_apps` to discover running apps before targeting a process.
+- Use `observe` or `window_state` with `pid` and `window_id` before element-based actions.
+- Prefer `element_index` clicks from observed window state; coordinates are fallback only.
+- Pass a stable `session` to `start_session` and subsequent calls when visual agent cursor/session identity matters.
+</instruction>
+
+<critical>
+- This tool does not provide screenshots in the MVP. Use supported window/app observation actions instead.
+- `click` requires `pid` plus either `element_index` or both `x` and `y`.
+- `scroll` requires `pid` plus at least one of `dx` or `dy`.
+- `type_text` requires `pid` and non-empty `text`; `press_key` requires `pid` and non-empty `key`.
+</critical>

package/src/prompts/tools/cron.md

@@ -0,0 +1,25 @@
+Schedule a prompt to fire on a recurring cron schedule, or one-shot at the next match. Cron tasks let you re-run a prompt automatically on an interval — poll a deployment, babysit a PR, check back on a long-running build, or remind yourself to do something later in the session.
+
+`CronCreate` accepts a standard 5-field cron expression in your local timezone, the prompt to run, and whether the job recurs or fires once. It returns an 8-character job id you can pass to `CronDelete`. Each session can hold up to 50 scheduled tasks. Recurring tasks auto-expire 7 days after creation; one-shot tasks self-delete after firing.
+
+`CronList` enumerates every scheduled task in the session. `CronDelete` cancels a task by id.
+
+## Cron expressions
+
+`CronCreate` accepts 5-field cron: `minute hour day-of-month month day-of-week`. All fields support `*`, single values (`5`), steps (`*/15`), ranges (`1-5`), and comma lists (`1,15,30`). Day-of-week uses `0`/`7` for Sunday through `6` for Saturday. Extended syntax like `L`, `W`, `?`, or month/weekday names is not supported.
+
+|Example|Meaning|
+|:---|:---|
+|`*/5 * * * *`|Every 5 minutes|
+|`0 * * * *`|Every hour on the hour|
+|`0 9 * * *`|Every day at 9am local|
+|`0 9 * * 1-5`|Weekdays at 9am local|
+
+## Lifecycle
+
+- Tasks fire between turns, never mid-response.
+- All times are interpreted in the local timezone.
+- Recurring tasks fire with up to 30 minutes of deterministic jitter (or up to half their interval for sub-hourly tasks). One-shot tasks scheduled for `:00` or `:30` may fire up to 90 s early. Pick an off-minute if exact timing matters.
+- Closing or replacing the session clears every scheduled task.
+
+Disable the scheduler entirely via `CLAUDE_CODE_DISABLE_CRON=1`.

package/src/prompts/tools/debug.md

@@ -0,0 +1,33 @@
+Provides debugger access through the Debug Adapter Protocol (DAP).
+Use for launching or attaching debuggers, setting breakpoints, stepping through execution, inspecting threads/stack/variables, evaluating expressions, capturing output, and interrupting hung programs.
+
+<instruction>
+- Prefer over bash for program state, breakpoints, stepping, thread inspection, or interrupting a running process.
+- `action: "launch"` starts a session; `program` is required, `adapter` optional (auto-selected from target path and workspace).
+  For Python, set `adapter: "debugpy"` and `program` to the target `.py` file; put interpreter/script flags in `args`.
+- `action: "attach"` connects to an existing process: `pid` for local attach, `port` for remote attach (where the adapter supports it), `adapter` to force a specific debugger.
+- **Breakpoints**: `set_breakpoint`/`remove_breakpoint` with source (`file`+`line`) or function (`function`); optional `condition` for conditional breakpoints.
+- **Flow control**: `continue` (resumes; briefly waits to observe whether the program stops or keeps running), `step_over`/`step_in`/`step_out` (single-step), `pause` (interrupt a running program so you can inspect state).
+- **Inspect**: `threads` (list), `stack_trace` (frames for current stopped thread), `scopes` (needs `frame_id` or a current stopped frame), `variables` (needs `variable_ref` or `scope_id`), `evaluate` (needs `expression`; `context: "repl"` for raw debugger commands when the adapter supports them), `output` (captured stdout/stderr/console), `sessions` (tracked debug sessions), `terminate`.
+- Timeouts apply per-request, not to the full session lifetime.
+</instruction>
+
+<caution>
+- Only one active debug session is supported at a time.
+- Some adapters require a launched session to receive `configurationDone` before the target actually runs; if the tool says configuration is pending, set breakpoints and then call `continue`.
+- Adapter availability depends on local binaries. Common built-ins: `gdb`, `lldb-dap`, `python -m debugpy.adapter`, `dlv dap`.
+- `program` must be an executable file or debug target, not a directory or interpreter name that resolves to a workspace directory.
+</caution>
+
+<examples>
+# Launch and inspect hang
+1. `debug(action: "launch", program: "./my_app")`
+2. `debug(action: "set_breakpoint", file: "src/main.c", line: 42)`
+3. `debug(action: "continue")`
+4. If the program appears hung: `debug(action: "pause")`
+5. Inspect state with `threads`, `stack_trace`, `scopes`, and `variables`
+# Launch a Python script with debugpy
+`debug(action: "launch", adapter: "debugpy", program: "scripts/job.py", args: ["--flag"])`
+# Raw debugger command through repl
+`debug(action: "evaluate", expression: "info registers", context: "repl")`
+</examples>

package/src/prompts/tools/eval.md

@@ -0,0 +1,75 @@
+Run code in a persistent kernel using a list of cells.
+
+<instruction>
+Each call submits one or more cells. Cells run in array order. State persists within each language across cells **and across tool calls**.
+
+Cell fields:
+
+- `language` — {{#if py}}`"py"` for the IPython kernel{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}`"js"` for the persistent JavaScript VM{{/if}}.
+- `code` — cell body, verbatim. Newlines, quotes, and indentation are JSON-encoded; no fences, no headers.
+- `title` (optional) — short label shown in the transcript (e.g. `"imports"`, `"load config"`).
+- `timeout` (optional) — per-cell timeout in seconds (1-600). Default 30.
+- `reset` (optional) — wipe this cell's language kernel before running.{{#ifAll py js}} Reset is per-language: a `py` cell's reset does not touch the JavaScript VM and vice versa.{{/ifAll}}
+
+**Work incrementally:**
+
+- One logical step per cell (imports, define, test, use).
+- Pass multiple small cells in one call.
+- Define small reusable functions for individual debugging.
+- Put workflow explanations in the assistant message or `title` — never inside cell code.
+{{#if py}}- Python cells run inside an IPython kernel with a live event loop. Use top-level `await` directly (e.g. `await main()`); `asyncio.run(…)` raises "cannot be called from a running event loop".{{/if}}
+**On failure:** errors identify the failing cell (e.g., "Cell 3 failed"). Resubmit only the fixed cell (or fixed cell + remaining cells).
+</instruction>
+
+<prelude>
+{{#ifAll py js}}Same helpers in both runtimes with the same positional argument order. Python: trailing options as keyword args. JavaScript: trailing options as a trailing object literal. JavaScript helpers are async and `await`able; Python helpers run synchronously.{{else}}{{#if py}}Helpers run synchronously. Trailing options are keyword arguments.{{/if}}{{#if js}}Helpers are async and `await`able. Trailing options are a final object literal.{{/if}}{{/ifAll}}
+```
+display(value) → None
+    Render a value in the current cell output.
+print(value, ...) → None
+    Print to the cell's text output.
+read(path, offset?=1, limit?=None) → str
+    Read file contents as text. offset/limit are 1-indexed line bounds.
+write(path, content) → str
+    Write content to a file (creates parent directories). Returns the resolved path.
+append(path, content) → str
+    Append content to a file. Returns the resolved path.
+tree(path?=".", max_depth?=3, show_hidden?=False) → str
+    Render a directory tree.
+diff(a, b) → str
+    Unified diff between two files.
+env(key?=None, value?=None) → str | None | dict
+    No args → full environment as dict. One arg → value of `key`. Two args → set `key=value` and return value.
+output(*ids, format?="raw", query?=None, offset?=None, limit?=None) → str | dict | list[dict]
+    Read task/agent output by ID. Single id returns text/dict; multiple ids return a list.
+tool.<name>(args) → unknown
+    Invoke any session tool by name. `args` is the tool's parameter object.
+```
+</prelude>
+
+<output>
+Cells render like a Jupyter notebook. `display(value)` renders non-presentable data as an interactive JSON tree. Presentable values (figures, images, dataframes, etc.) use their native representation.
+</output>
+
+<caution>
+{{#if js}}- **js**: the VM exposes a selective `process` subset, Web APIs, `Buffer`, `fs/promises`, and the `Bun` global.
+{{/if}}</caution>
+
+<example>
+{{#if py}}```json
+{
+  "cells": [
+    { "language": "py", "title": "imports", "timeout": 10, "code": "import json\nfrom pathlib import Path" },
+    { "language": "py", "title": "load config", "code": "data = json.loads(read('package.json'))\ndisplay(data)" }
+  ]
+}
+```{{/if}}{{#ifAll py js}}
+
+{{/ifAll}}{{#if js}}```json
+{
+  "cells": [
+    { "language": "js", "title": "summary", "reset": true, "code": "const data = JSON.parse(await read('package.json'));\ndisplay(data);\nreturn data.name;" }
+  ]
+}
+```{{/if}}
+</example>

package/src/prompts/tools/find.md

@@ -0,0 +1,34 @@
+Finds files using fast pattern matching that works with any codebase size.
+
+<instruction>
+- `paths` is required and accepts an array of globs, files, or directories
+- Pass multiple targets as **separate array elements** (`paths: ["a", "b"]`), NEVER as a single comma-joined string (`paths: ["a,b"]` is rejected)
+- `gitignore` defaults to `true` and hides files matched by `.gitignore`. Set `gitignore: false` to find `.env*`, `*.log`, freshly-created build outputs, or anything else your repo ignores
+- `hidden` defaults to `true`; combine with `gitignore: false` to surface dotfiles that are also gitignored
+- `timeout` is in seconds (default 5, clamped to 0.5–60). On timeout, find returns whatever partial matches it has collected with `truncated: true` and a notice — increase `timeout` or narrow the pattern instead of retrying blindly
+- You SHOULD perform multiple searches in parallel when potentially useful
+</instruction>
+
+<output>
+Matching file paths sorted by modification time (most recent first). Truncated at 1000 entries or 50KB (configurable via `limit`).
+</output>
+
+<examples>
+# Find files
+`{"paths": ["src/**/*.ts"], "limit": 1000}`
+# Multiple targets — separate array elements
+`{"paths": ["src/**/*.ts", "test/**/*.ts"]}`
+# Find gitignored files like .env
+`{"paths": [".env*"], "gitignore": false}`
+# Long-running search on a slow volume
+`{"paths": ["/Volumes/Storage/**/*.py"], "timeout": 30}`
+</examples>
+
+<avoid>
+For open-ended searches requiring multiple rounds of globbing and searching, you MUST use Task tool instead.
+</avoid>
+
+<critical>
+- You MUST use the built-in Find tool for every file-name lookup. NEVER shell out to `find`, `fd`, `locate`, `ls`, or `git ls-files` via Bash — they ignore `.gitignore`, blow past result limits, and waste tokens.
+- If you catch yourself typing `find -name`, `fd`, or `ls **/*.ext` in a Bash command, stop and re-issue the lookup through the Find tool with a glob pattern instead.
+</critical>

package/src/prompts/tools/github.md

@@ -0,0 +1,20 @@
+GitHub CLI tool with a single op-based dispatch. Wraps `gh` for repositories, pull requests, search, checkout, push, and Actions watch workflows. For reading a single issue or PR view, use the `issue://<N>` or `pr://<N>` URL schemes (cached automatically) — they replace what used to be `op: issue_view` and `op: pr_view`. For reading PR diffs, use `pr://<N>/diff` (changed-file listing), `pr://<N>/diff/<i>` (single file slice, 1-indexed), or `pr://<N>/diff/all` (full unified diff) — they replace what used to be `op: pr_diff`.
+
+<instruction>
+Pick the operation via `op`. Each op uses a subset of the parameters:
+- `repo_view` — Read repository metadata. Optional `repo` (owner/repo) and `branch`. Falls back to the current checkout or default `gh` repo.
+- `pr_create` — Create a pull request. Either provide `title` (and optional `body`) or set `fill: true` to auto-fill from commits. Optional `base` (target, defaults to repo default), `head` (source, defaults to current branch), `draft`, `repo`, `reviewer[]`, `assignee[]`, `label[]`. Returns the new PR URL plus a summary.
+- `pr_checkout` — Check one or more pull requests out into dedicated git worktrees. Optional `pr` (number, URL, branch, or array of any of those — pass an array to batch-check-out multiple PRs in one call), `repo`, `force` (reset existing local branch).
+- `pr_push` — Push a checked-out PR branch back to its source branch. Requires the branch to have been checked out via `op: pr_checkout` (carries push metadata). Optional `branch`; defaults to the current checked-out git branch. Optional `forceWithLease`.
+- `search_issues` — Search issues using normal GitHub issue search syntax. Optional `query` (required unless `since`/`until` is set), `repo`, `limit`, `since`, `until`, `dateField`. Defaults `repo` to the current checkout's `owner/repo` when omitted; pass an explicit `repo:`/`org:`/`user:` qualifier in `query` to search outside it.
+- `search_prs` — Search pull requests using normal GitHub PR search syntax. Optional `query` (required unless `since`/`until` is set), `repo`, `limit`, `since`, `until`, `dateField`. Defaults `repo` to the current checkout's `owner/repo` when omitted; pass an explicit `repo:`/`org:`/`user:` qualifier in `query` to search outside it.
+- `search_code` — Search code with GitHub code search syntax. Required `query`. Optional `repo`, `limit`. Returns matching paths with surrounding fragments. Defaults `repo` to the current checkout's `owner/repo` when omitted; pass an explicit `repo:`/`org:`/`user:` qualifier in `query` to search outside it. Date filtering (`since`/`until`) is **not** supported by GitHub code search.
+- `search_commits` — Search commits across GitHub. Optional `query` (required unless `since`/`until` is set), `repo`, `limit`, `since`, `until`. `dateField` is ignored — always uses `committer-date`. Defaults `repo` to the current checkout's `owner/repo` when omitted; pass an explicit `repo:`/`org:`/`user:` qualifier in `query` to search outside it.
+- `search_repos` — Search repositories across GitHub. Optional `query` (required unless `since`/`until` is set), `limit`, `since`, `until`, `dateField` (use query qualifiers like `org:`, `language:` instead of `repo`).
+- Date filter format for `since` / `until`: relative duration `<n><unit>` (`m`/`h`/`d`/`w`/`mo`/`y`, e.g. `3d`, `12h`, `2w`), an ISO date `YYYY-MM-DD`, or an ISO datetime. Translated to a single GitHub-search qualifier (`created:≥…`, `created:≤…`, or `created:since..until`). `dateField: "updated"` maps to `updated:` for issues/prs and `pushed:` for repos. When you only want a date filter and no keywords, omit `query` entirely.
+- `run_watch` — Watch a GitHub Actions workflow run. Optional `run` (id or URL). Omitting `run` watches all workflow runs for the current HEAD commit; `branch` falls back to the current branch. Optional `tail` (log lines per failed job). Streams snapshots, fast-fails on the first detected job failure (with a brief grace period to capture concurrent failures), then fetches tailed logs for the failed jobs. The full failed-job logs are saved as a session artifact for on-demand reads.
+</instruction>
+
+<output>
+Returns a concise readable summary tailored to the chosen op (repo metadata, PR metadata, diff text, search results, checkout info, push target, or workflow run snapshot). For `run_watch`, the full failed-job logs are saved as a session artifact when failures occur.
+</output>

package/src/prompts/tools/goal.md

@@ -0,0 +1,20 @@
+Manage the active goal-mode objective.
+
+Use a single `op` field:
+- `create` starts a goal. Requires `objective`. Use only when no goal exists and no goal is paused.
+- `get` returns the current goal and usage state.
+- `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.
+- `pause` suspends the active goal and stops continuation steers. Use when all deliverables are done but programmatic completion is blocked, or when the user should decide the next step.
+
+Examples:
+- `goal({"op":"create","objective":"Implement feature X"})`
+- `goal({"op":"get"})`
+- `goal({"op":"resume"})`
+- `goal({"op":"complete"})`
+- `goal({"op":"drop"})`
+- `goal({"op":"pause"})`
+
+Call `complete` only when the goal is actually done and verified.
+If `get` shows a paused goal, call `resume` before continuing work on it.