diff --git a/README.md b/README.md
index a9d03c0f5..db1309caa 100644
--- a/README.md
+++ b/README.md
@@ -219,7 +219,7 @@ Stealth's on by default, so pages see a normal user instead of a headless bot. T
 
 ## Whatever the task needs, _it's already in the box_.
 
-32 tools live in the same namespace as `read` and `bash`. Pin the active set with `--tools read,edit,bash,…` and the rest stay hidden but indexed — `search_tool_bm25` pulls them back in mid-session when `tools.discoveryMode` says so.
+32 tools live in the same namespace as `read` and `bash`. Pin the active set with `--tools read,edit,bash,…`; rarely used discoverable tools stay behind `xd://` devices. `read xd://` lists them, and `write xd://<tool>` runs one when `tools.xdev` is enabled.
 
 **Files & search**
 
@@ -245,9 +245,8 @@ Stealth's on by default, so pages see a normal user instead of a headless bot. T
 **Coordination**
 
 - `task` — fan out subagents in parallel, optionally workspace-isolated.
-- `irc` — short prose between live agents in this process.
+- `hub` — message live agents, wait on or cancel background jobs, and supervise long-running processes.
 - `todo` — ordered mutations over the session todo list with phase tracking.
-- `job` — wait on or cancel background jobs.
 - `ask` — structured follow-up questions for interactive runs.
 
 **Outside the box**
@@ -270,9 +269,8 @@ Stealth's on by default, so pages see a normal user instead of a headless bot. T
 **Misc**
 
 - `resolve` — apply or discard a queued preview action.
-- `search_tool_bm25` — BM25 over the hidden tool index; activates top matches mid-session.
 
-Setting-gated, off by default: `github`, `inspect_image`, `tts`, `checkpoint`, `rewind`, `search_tool_bm25`, `retain`, `recall`, `reflect`. Flip them on once, scoped per project.
+Setting-gated, off by default: `github`, `inspect_image`, `tts`, `checkpoint`, `rewind`, `retain`, `recall`, `reflect`. Flip them on once, scoped per project.
 
 [Full reference →](https://omp.sh/docs/tools)
 
diff --git a/docs/advisor-watchdog.md b/docs/advisor-watchdog.md
index a4881fa5c..65870bf11 100644
--- a/docs/advisor-watchdog.md
+++ b/docs/advisor-watchdog.md
@@ -80,7 +80,7 @@ Every advisor has the `advise` tool for surfacing notes into the primary transcr
 - `grep`
 - `glob`
 
-A `WATCHDOG.yml` roster entry may broaden this with `tools: [...]`, selecting any subset of the built-in pool the session actually built (a factory that returned `null`, e.g. `lsp` with no matching servers, is absent). Grantable tools include mutating ones: `edit`, `write`, `bash`, `eval`, `browser`, `debug`, `ast_edit`, `task`, `job`, and the memory tools. Tool names outside [`BUILTIN_TOOL_NAMES`](../packages/coding-agent/src/tools/builtin-names.ts) are dropped with a warning.
+A `WATCHDOG.yml` roster entry may broaden this with `tools: [...]`, selecting any subset of the built-in pool the session actually built (a factory that returned `null`, e.g. `lsp` with no matching servers, is absent). Grantable tools include mutating ones: `edit`, `write`, `bash`, `eval`, `browser`, `debug`, `ast_edit`, `task`, `hub`, and the memory tools. Tool names outside [`BUILTIN_TOOL_NAMES`](../packages/coding-agent/src/tools/builtin-names.ts) are dropped with a warning.
 
 Advisor grants are not routed through the primary agent's approval wrapper. The advisor pool is built from the built-in tool factories against its own `-advisor` `ToolSession` and then filtered by `WATCHDOG.yml`; it is not the primary `toolRegistry` wrapped with `ExtensionToolWrapper`. Granting write- or exec-tier tools therefore lets the advisor invoke those tools directly, subject to the tool's own runtime guards but not to `tools.approvalMode` / `tools.approval.<tool>` prompts. Keep mutating grants narrow and trusted.
 
@@ -233,7 +233,7 @@ Fields:
 - `instructions` (top level): shared prompt prepended to every advisor's system prompt alongside `WATCHDOG.md`. Concatenated across all discovered `WATCHDOG.yml` files.
 - `advisors[].name`: human label; slugified for the session id and the `<session>/__advisor.jsonl` filename. Duplicate slugs across files are resolved by the same specificity rule as `WATCHDOG.md` discovery (project leaf > project ancestor > user).
 - `advisors[].model`: optional model selector with optional `:level` thinking suffix (e.g. `x-ai/grok-code-fast:high`). Omitted → the advisor uses `modelRoles.advisor`.
-- `advisors[].tools`: optional list of built-in tool names to grant. Omitted or empty → the default `read`/`grep`/`glob` subset. Any name in [`BUILTIN_TOOL_NAMES`](../packages/coding-agent/src/tools/builtin-names.ts) is accepted, including mutating tools (`edit`, `write`, `bash`, `eval`, `browser`, `debug`, `ast_edit`, `task`, `job`, and the memory tools). Legacy aliases (`search`→`grep`, `find`→`glob`) are normalized. Unknown names are dropped with a warning. See [Tools and isolation](#tools-and-isolation) for the safety implications of granting mutating tools.
+- `advisors[].tools`: optional list of built-in tool names to grant. Omitted or empty → the default `read`/`grep`/`glob` subset. Any name in [`BUILTIN_TOOL_NAMES`](../packages/coding-agent/src/tools/builtin-names.ts) is accepted, including mutating tools (`edit`, `write`, `bash`, `eval`, `browser`, `debug`, `ast_edit`, `task`, `hub`, and the memory tools). Legacy aliases (`search`→`grep`, `find`→`glob`) are normalized. Unknown names are dropped with a warning. See [Tools and isolation](#tools-and-isolation) for the safety implications of granting mutating tools.
 - `advisors[].instructions`: this advisor's specialization, appended after the shared baseline. Both instruction fields expand `@path` imports like `WATCHDOG.md`.
 
 ### Discovery locations
@@ -277,4 +277,4 @@ Why a file:
 
 The file follows session switches: on `/new`, resume/switch, and branch the recorder reopens at the new session's path on the next advisor turn; before a `/drop` deletes the old artifacts dir the recorder feed is detached and drained so a queued write cannot recreate the deleted file. The on-disk log is append-only and independent of the in-memory context — re-primes and compaction never truncate it.
 
-The advisor is never a peer. The `advisor`-kind registry ref is excluded from every agent-facing surface — the `irc` peer roster and broadcast targets, the subagent peer prompt, and the `history://` index/lookup/completions — and cannot be messaged (`irc send` and collab chat refuse it) or revived/killed from the Agent Hub or collab. It is not addressable as a peer, regardless of what tools it has been granted.
+The advisor is never a peer. The `advisor`-kind registry ref is excluded from every agent-facing surface — the `hub` peer roster and broadcast targets, the subagent peer prompt, and the `history://` index/lookup/completions — and cannot be messaged (`hub` send and collab chat refuse it) or revived/killed from the Agent Hub or collab. It is not addressable as a peer, regardless of what tools it has been granted.
diff --git a/docs/compaction.md b/docs/compaction.md
index 186d53054..3d9790691 100644
--- a/docs/compaction.md
+++ b/docs/compaction.md
@@ -164,7 +164,7 @@ If pruning changes entries, session storage is rewritten and agent message state
 
 ### Useless-result elision
 
-Tools can flag a finished result as contextually useless — a search with zero matches, a `job` poll that timed out with everything still running, an empty `irc` inbox drain. The flag originates on the tool result (`AgentToolResult.useless`, set via `ToolResultBuilder.useless()` or directly on the returned object), is copied by the agent loop onto the persisted `ToolResultMessage` (never together with `isError` — errors always win), and is consumed in three places:
+Tools can flag a finished result as contextually useless — a search with zero matches, a `hub` wait that timed out with everything still running, an empty `hub` inbox drain. The flag originates on the tool result (`AgentToolResult.useless`, set via `ToolResultBuilder.useless()` or directly on the returned object), is copied by the agent loop onto the persisted `ToolResultMessage` (never together with `isError` — errors always win), and is consumed in three places:
 
 - **Per-turn stale-result pass** (`pruneSupersededToolResults`, gated by `compaction.dropUseless`, default on): flagged results are blanked to the exact placeholder `[Uneventful result elided]` (`USELESS_NOTICE`) with the same cache-aware timing as superseded reads — only when the suffix after the candidate is small (≤ ~8k tokens) or the session has idled past the provider prompt-cache lifetime. Results smaller than the notice itself are never blanked (no savings), and protected tools are exempt.
 - **Threshold prune** (`pruneToolOutputs`): flagged results bypass the protect-recent window, same as superseded reads, and receive `USELESS_NOTICE` instead of the token-count placeholder.
diff --git a/docs/custom-tools.md b/docs/custom-tools.md
index 9f74137fd..9c6d63e0c 100644
--- a/docs/custom-tools.md
+++ b/docs/custom-tools.md
@@ -129,7 +129,7 @@ From `types.ts` and `loader.ts`:
 - `typebox`: zod-backed compatibility shim for legacy TypeBox-style schemas
 - `zod`: injected `zod/v4` module (canonical for new schemas)
 - `pi`: injected `@oh-my-pi/pi-coding-agent` exports
-- `pushPendingAction(action)`: register a preview action for hidden `resolve` tool (`docs/resolve-tool-runtime.md`)
+- `pushPendingAction(action)`: register a preview action finalized via plain-text writes to `/xdev/resolve` or `/xdev/reject` (`docs/resolve-tool-runtime.md`)
   Loader starts with a no-op UI context and requires host code to call `setUIContext(...)` when real UI is ready.
 
 ## Execution contract and typing
diff --git a/docs/resolve-tool-runtime.md b/docs/resolve-tool-runtime.md
index 6aadf6168..97001b01e 100644
--- a/docs/resolve-tool-runtime.md
+++ b/docs/resolve-tool-runtime.md
@@ -1,145 +1,53 @@
-# Resolve tool runtime internals
+# Resolution devices runtime
 
-This document explains how preview/apply workflows are modeled in coding-agent and how built-in or custom tools can participate via the pending-invoker registry and `pushPendingAction`. (Pending previews live in a separate non-forcing registry inside `ToolChoiceQueue`; only genuine hard forces use the consuming directive queue.)
+Pending previews and plan approval no longer use a `resolve` tool. They finalize through three plain-text writes handled by `packages/coding-agent/src/tools/resolve.ts`:
 
-## Scope and key files
+- `/xdev/resolve` — apply the pending staged preview; body = reason text
+- `/xdev/reject` — discard the pending staged preview; body = reason text
+- `/xdev/propose` — submit the plan for approval while plan mode is active; body = the plan slug/title (`<slug>` for `local://<slug>-plan.md`)
 
-- [`src/tools/resolve.ts`](../packages/coding-agent/src/tools/resolve.ts)
-- [`src/tools/ast-edit.ts`](../packages/coding-agent/src/tools/ast-edit.ts)
-- [`src/extensibility/custom-tools/types.ts`](../packages/coding-agent/src/extensibility/custom-tools/types.ts)
-- [`src/extensibility/custom-tools/loader.ts`](../packages/coding-agent/src/extensibility/custom-tools/loader.ts)
-- [`src/sdk.ts`](../packages/coding-agent/src/sdk.ts)
+## Preview flows
 
-## What `resolve` does
+Preview producers call `queueResolveHandler(...)` with `apply(reason)` and optional `reject(reason)` callbacks. That registers a non-forcing pending invoker in `ToolChoiceQueue`.
 
-`resolve` is a hidden tool that finalizes a pending preview action.
+While a preview is pending, `AgentSession.nextToolChoiceDirective()` returns a soft requirement:
 
-- `action: "apply"` executes the queued action's `apply(reason, extra)` callback and returns that result with resolve metadata.
-- `action: "discard"` invokes `reject(reason, extra)` if provided; otherwise returns `Discarded: <label>. Reason: <reason>`.
-- `extra` is optional free-form metadata. Queue handlers receive it; producers decide whether it has meaning.
+- `toolName: "write"`
+- `satisfies: isPreviewResolutionToolCall`
+- reminder from `resolve-device-reminder.md`
 
-If no pending action exists, `resolve(action="apply")` fails with:
+So the model can comply by writing to `/xdev/resolve` or `/xdev/reject`; a write to any other path is still a detour and gets skipped/escalated.
 
-- `No pending action to resolve. Nothing to apply or discard.`
+Dispatch path:
 
-`resolve(action="discard")` with no pending action succeeds instead, returning `Nothing to discard; no pending action remains.` — the desired end-state (no staged change) already holds.
+- `dispatchResolutionDevice(session, "resolve" | "reject", text)`
+- `peekQueueInvoker() ?? peekPendingInvoker()`
+- `runResolveInvocation(...)`
 
-## Pending previews use a non-forcing soft tool requirement
+`reject` with no pending action succeeds (`Nothing to reject; no pending action remains.`). `resolve` with no pending action throws.
 
-Preview producers call `queueResolveHandler(...)`, which registers a non-forcing
-pending invoker on the session (a stack keyed by a unique
-`pending-action:<tool>:<seq>` id — never clobbered by label). It does NOT force
-`tool_choice` and does NOT inject a steering reminder.
+## Plan approval
 
-While a preview is pending, the session's `getToolChoice` callback
-(`nextToolChoiceDirective`) returns a `SoftToolRequirement` (`toolName: "resolve"`)
-carrying the resolve reminder, as a non-consuming peek. The agent runtime owns the
-lifecycle: it injects the reminder once, runs with `tool_choice` unchanged, and
-escalates to a one-turn forced `resolve` choice ONLY if the model fails to call
-`resolve` that turn (skipping any detour tool batch first). A model that resolves
-on the reminder pays no message-cache invalidation — the previous design forced
-`tool_choice` on every preview, busting the provider message cache twice per cycle.
+Plan mode installs a separate proposal handler through `setPlanProposalHandler(...)`.
 
-Runtime behavior:
+- `InteractiveMode` uses it to hand `PlanApprovalDetails` to the plan-review UI.
+- ACP mode uses it to run elicitation/approval and emit mode updates.
+- PlanYolo uses it to auto-approve and switch to the execution target.
 
-- the pending invoker owns the `apply`/`reject` callbacks,
-- `resolve` dispatches via `peekQueueInvoker() ?? peekPendingInvoker() ?? peekStandingResolveHandler()`,
-- a genuine hard forced tool choice (dequeued first by `nextToolChoiceDirective`) preempts the soft requirement,
-- if an apply callback throws, the helper re-registers the same pending invoker (same id) so the preview can still be discarded or retried.
+Dispatch path:
 
-`resolve` also checks a standing resolve handler after the invokers; this is used by long-lived approval flows that are not ordinary preview tool calls.
+- `dispatchResolutionDevice(session, "propose", title)`
+- `peekPlanProposalHandler()`
 
-Multiple pending previews stack as unique-keyed invokers and resolve independently (head-first), not through forced tool-choice ordering.
+`/xdev/propose` is only valid while plan mode is active.
 
-## Built-in producer example (`ast_edit`)
+## Why `write` is guaranteed
 
-`ast_edit` previews structural replacements first. When the preview has replacements and is not applied yet, it queues a resolve handler that contains:
+Because previews and plan approval now ride `write`, the harness keeps `write` available whenever it is needed:
 
-- label (human-readable summary)
-- `sourceToolName` (`ast_edit`)
-- `apply(reason: string, extra?: Record<string, unknown>)` callback that reruns AST edit with `dryRun: false`
+- `createTools(...)` auto-appends `write` when a `deferrable` tool is active (e.g. `ast_edit`)
+- `createAgentSession(...)` keeps `write` registered when a deferrable tool exists or plan mode is enabled
 
-`resolve(action="apply", reason="...")` passes both `reason` and `extra` into this callback, but `ast_edit`'s apply ignores both — its parameter is `_reason`, and the rerun is independent of `reason`/`extra`.
+## Custom tools
 
-## Custom tools: `pushPendingAction`
-
-Custom tools can register resolve-compatible pending actions through `CustomToolAPI.pushPendingAction(...)`. The custom tool loader forwards these actions to `queueResolveHandler(...)` when that hook is available.
-
-`CustomToolPendingAction`:
-
-- `label: string` (required)
-- `apply(reason: string): Promise<AgentToolResult<unknown>>` (required) — invoked on apply; `reason` is the string passed to `resolve`
-- `reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>` (optional) — invoked on discard; return value replaces the default "Discarded" message if provided
-- `details?: unknown` exists on the public custom-tool type but is not currently forwarded by the loader into resolve metadata
-- `sourceToolName?: string` (optional, defaults to `"custom_tool"`)
-
-### Minimal usage example
-
-```ts
-import type { CustomToolFactory } from "@oh-my-pi/pi-coding-agent";
-
-const factory: CustomToolFactory = (pi) => ({
-  name: "batch_rename_preview",
-  label: "Batch Rename Preview",
-  description: "Previews renames and defers commit to resolve",
-  parameters: pi.zod.object({
-    files: pi.zod.array(pi.zod.string()),
-  }),
-
-  async execute(_toolCallId, params) {
-    const previewSummary = `Prepared rename plan for ${params.files.length} files`;
-
-    pi.pushPendingAction({
-      label: `Batch rename: ${params.files.length} files`,
-      sourceToolName: "batch_rename_preview",
-      apply: async (reason) => {
-        // apply writes here
-        return {
-          content: [
-            { type: "text", text: `Applied batch rename. Reason: ${reason}` },
-          ],
-        };
-      },
-      reject: async (reason) => {
-        // optional: cleanup or notify on discard
-        return {
-          content: [
-            { type: "text", text: `Discarded batch rename. Reason: ${reason}` },
-          ],
-        };
-      },
-    });
-
-    return {
-      content: [
-        {
-          type: "text",
-          text: `${previewSummary}. Call resolve to apply or discard.`,
-        },
-      ],
-    };
-  },
-});
-
-export default factory;
-```
-
-## Runtime availability and failures
-
-`pushPendingAction` is wired by the custom tool loader through the active session's resolve queue hook.
-
-If the runtime did not provide the resolve queue hook, `pushPendingAction` throws:
-
-- `Pending action store unavailable for custom tools in this runtime.`
-
-## Tool-choice behavior
-
-When `queueResolveHandler(...)` registers a preview, the agent runtime forces a one-shot `resolve` tool choice so pending previews are explicitly finalized before normal tool flow continues.
-
-## Developer guidance
-
-- Use pending actions only for destructive or high-impact operations that should support explicit apply/discard.
-- Keep `label` concise and specific; it is shown in resolve renderer output.
-- Ensure `apply(reason)` is deterministic and idempotent enough for one-shot execution; `reason` is informational and should not change behavior.
-- Implement `reject(reason)` when the discard needs cleanup (temp state, locks, notifications); omit it for stateless previews where the default message suffices.
-- If your tool can stage multiple previews, remember they stack as unique-keyed pending invokers (resolved head-first), not a forced tool-choice sequence and not a separate `pushPendingAction` stack.
+Custom tools still stage previews through `pushPendingAction(...)`; the loader forwards them into `queueResolveHandler(...)`. Nothing about the custom-tool API changes except the model-facing finalization step: the follow-up is now a plain-text write to `/xdev/resolve` or `/xdev/reject`, not a `resolve` tool call.
diff --git a/docs/session.md b/docs/session.md
index 84182abe3..e857ba416 100644
--- a/docs/session.md
+++ b/docs/session.md
@@ -119,7 +119,6 @@ All non-header entries include:
 - `ttsr_injection`
 - `session_init`
 - `mode_change`
-- `mcp_tool_selection`
 
 ### `message`
 
@@ -290,18 +289,6 @@ Extension-provided message that does participate in LLM context. `content` can b
 }
 ```
 
-### `mcp_tool_selection`
-
-```json
-{
-  "type": "mcp_tool_selection",
-  "id": "d2e3f4a5",
-  "parentId": "c2d3e4f5",
-  "timestamp": "2026-02-16T10:28:30.000Z",
-  "selectedToolNames": ["server.tool"]
-}
-```
-
 ### `session_init`
 
 ```json
@@ -400,7 +387,6 @@ Algorithm:
    - model map from `model_change` entries (`role ?? "default"`)
    - fallback `models.default` from assistant message provider/model if no explicit model change
    - deduplicated `injectedTtsrRules` from all `ttsr_injection` entries
-   - selected MCP discovery tools from latest `mcp_tool_selection`
    - mode/modeData from latest `mode_change` (default mode `"none"`)
 4. Build message list:
    - `message` entries pass through
@@ -411,7 +397,7 @@ Algorithm:
      - emit path entries starting at `firstKeptEntryId` up to the compaction boundary
      - emit entries after the compaction boundary
 
-`custom`, `session_init`, `service_tier_change`, `mcp_tool_selection`, and `ttsr_injection` entries do not inject model context directly.
+`custom`, `session_init`, `service_tier_change`, and `ttsr_injection` entries do not inject model context directly.
 
 ## Persistence Guarantees and Failure Model
 
diff --git a/docs/settings.md b/docs/settings.md
index 76be155f6..682279460 100644
--- a/docs/settings.md
+++ b/docs/settings.md
@@ -432,7 +432,6 @@ tools:
   approval:
     bash: prompt
     edit: allow
-  discoveryMode: auto
   maxTimeout: 0
   intentTracing: true
 ```
@@ -441,8 +440,6 @@ tools:
 |---|---|---|---|
 | `tools.approvalMode` | enum | `yolo` | `always-ask` (auto-approve read-only), `write` (auto-approve read + workspace-write), `yolo` (auto-approve all tiers). `--approval-mode` and `--auto-approve`/`--yolo` override per run. |
 | `tools.approval` | record | `{}` | Per-tool policy keyed by tool name; each value is `allow`, `deny`, or `prompt`. e.g. `omp config set tools.approval '{"bash":"prompt"}'`. |
-| `tools.discoveryMode` | enum | `auto` | `auto`, `off`, `mcp-only`, `all`. Controls dynamic tool discovery. |
-| `tools.essentialOverride` | array | `[]` | Tool names kept available even when tools are narrowed. |
 | `tools.maxTimeout` | number | `0` | Max tool runtime in seconds; `0` = no cap. |
 | `tools.intentTracing` | boolean | `true` | Record per-call intent strings. |
 | `tools.outputMaxColumns` | number | `768` | Per-line byte cap for streaming output; `0` disables. |
diff --git a/docs/task-agent-discovery.md b/docs/task-agent-discovery.md
index be8a4beeb..cb1dcde6e 100644
--- a/docs/task-agent-discovery.md
+++ b/docs/task-agent-discovery.md
@@ -183,7 +183,7 @@ So deeper levels cannot spawn further tasks even if the agent definition include
 When parent plan mode is enabled, `TaskTool.#runSpawn` builds an `effectiveAgent` before launching subprocesses:
 
 - prepends the plan-mode subagent system prompt
-- restricts tools to `read`, `search`, `find`, `lsp`, and `web_search`, plus `ast_grep`/`report_finding` when the agent's own tool list declares them (`PLAN_MODE_AGENT_TOOL_ALLOWLIST`)
+- restricts tools to `read`, `search`, `find`, `lsp`, and `web_search`, plus `ast_grep` when the agent's own tool list declares it (`PLAN_MODE_AGENT_TOOL_ALLOWLIST`)
 - clears child spawns
 - clears `prewalk` (read-only exploration must not receive the prewalk plan/implement nudges)
 
diff --git a/docs/tools/ast-edit.md b/docs/tools/ast-edit.md
index c027aeaeb..4d600a4b4 100644
--- a/docs/tools/ast-edit.md
+++ b/docs/tools/ast-edit.md
@@ -40,8 +40,8 @@ Shared AST pattern grammar and language catalog: see [`ast_grep`](./ast-grep.md#
 - `details` includes aggregate preview metadata:
   - `totalReplacements`, `filesTouched`, `filesSearched`, `applied`, `limitReached`
   - optional `parseErrors`, `parseErrorsTotal`, `scopePath`, `files`, `fileReplacements`, `displayContent`, `searchPath`, `cwd`, `meta`
-- The tool always previews first (`applied: false` in the direct result). Actual file writes happen only later through `resolve(action: "apply", ...)`.
-- When preview produced replacements, `ast_edit` also queues a pending `resolve` action. Successful apply returns a separate `resolve` result, not another `ast_edit` result.
+- The tool always previews first (`applied: false` in the direct result). Actual file writes happen only later through a `write /xdev/resolve` dispatch whose plain-text body is the reason.
+- When preview produced replacements, `ast_edit` also queues a pending resolve action. Successful apply returns a separate resolve dispatch result (on the `write` call), not another `ast_edit` result.
 
 ## Flow
 1. `AstEditTool.execute()` validates each op in `packages/coding-agent/src/tools/ast-edit.ts`:
@@ -61,9 +61,9 @@ Shared AST pattern grammar and language catalog: see [`ast_grep`](./ast-grep.md#
    - compiles every rewrite pattern for that language,
    - parses each file, skips files with syntax-error trees, collects `replace_by(...)` edits for every match, enforces replacement and file caps, and returns textual before/after slices plus source ranges.
 7. The TS wrapper deduplicates and caps parse errors, groups changes by file, and renders preview diff lines.
-8. If preview found replacements and `applied` is false, `queueResolveHandler(...)` registers a non-forcing pending `resolve` invoker. While it is pending the session surfaces a `SoftToolRequirement` carrying the resolve reminder; the agent runtime injects the reminder and forces `resolve` only if the model declines that turn (no per-preview `tool_choice` cache bust).
-9. On `resolve(action: "apply")`, the queued callback reruns the same rewrite set with `dryRun: false`, recomputes counts, and returns an error result if the live result no longer matches the preview (`stalePreview`). The current implementation compares replacement totals and per-file counts after the rerun; if the new run has already written different counts, the result is marked error.
-10. On a non-stale apply, the callback returns `Applied N replacements in M files.` (in hashline mode followed by fresh `[path#tag]` snapshot headers re-recorded from the post-apply content); on discard, `resolve` returns a discard message without mutating files.
+8. If preview found replacements and `applied` is false, `queueResolveHandler(...)` registers a non-forcing pending resolve invoker. While it is pending the session surfaces a `SoftToolRequirement` (`toolName: "write"` with a `/xdev/resolve` or `/xdev/reject` `satisfies` predicate) carrying the resolve reminder; the agent runtime injects the reminder and forces `write` only if the model declines that turn (no per-preview `tool_choice` cache bust).
+9. On a `write /xdev/resolve` dispatch, the queued callback reruns the same rewrite set with `dryRun: false`, recomputes counts, and returns an error result if the live result no longer matches the preview (`stalePreview`). The current implementation compares replacement totals and per-file counts after the rerun; if the new run has already written different counts, the result is marked error.
+10. On a non-stale apply, the callback returns `Applied N replacements in M files.` (in hashline mode followed by fresh `[path#tag]` snapshot headers re-recorded from the post-apply content); on discard (`write /xdev/reject`), the dispatch returns a discard message without mutating files.
 
 ## Modes / Variants
 - Single file: preview or apply against one file.
@@ -71,7 +71,7 @@ Shared AST pattern grammar and language catalog: see [`ast_grep`](./ast-grep.md#
 - Multiple explicit paths/globs: wrapper unions them into one synthetic scope or runs per-target native calls when paths only meet at root.
 - Internal URL inputs: only supported when the router resolves them to a backing file path.
 - Preview mode: always the direct `ast_edit` tool result.
-- Apply mode: only reachable through the queued `resolve` callback after a preview.
+- Apply mode: only reachable through the queued resolve callback (a `write /xdev/resolve` or `/xdev/reject` dispatch) after a preview.
 - Hashline output mode vs plain line/column mode: controlled by `resolveFileDisplayMode()`.
 
 ## Side Effects
@@ -79,11 +79,11 @@ Shared AST pattern grammar and language catalog: see [`ast_grep`](./ast-grep.md#
   - Preview reads files and scans directories.
   - Apply rewrites files in place with `std::fs::write(...)`, but only when the computed output differs from the original source.
 - Session state (transcript, memory, jobs, checkpoints, registries)
-  - Registers a non-forcing pending `resolve` invoker through `queueResolveHandler(...)`.
-  - Surfaces a `SoftToolRequirement` (with the resolve reminder) while pending; the agent runtime forces `resolve` only on non-compliance — no steering message and no per-preview forced tool choice.
+  - Registers a non-forcing pending resolve invoker through `queueResolveHandler(...)`.
+  - Surfaces a `SoftToolRequirement` (with the resolve reminder) while pending; the agent runtime forces `write` only on non-compliance — no steering message and no per-preview forced tool choice.
 - User-visible prompts / interactive UI
   - Direct `ast_edit` results are previews.
-  - Follow-up apply/discard is exposed through the hidden `resolve` tool.
+  - Follow-up apply/discard is exposed through the `/xdev/resolve` and `/xdev/reject` device writes.
 - Background work / cancellation
   - Native preview/apply work runs on a blocking worker via `task::blocking(...)`.
   - Cancellation and optional native timeout are cooperative through `CancelToken::heartbeat()`.
diff --git a/docs/tools/bash.md b/docs/tools/bash.md
index 6adf40838..e3e868cdd 100644
--- a/docs/tools/bash.md
+++ b/docs/tools/bash.md
@@ -114,7 +114,7 @@ Stdout and stderr are merged before the model sees them. Definite non-zero exit
   - Invalidates `github-cache` rows before execution when the command contains a mutating `gh issue`/`gh pr` subcommand, so later `issue://`/`pr://` reads see post-mutation state (`invalidateGithubCacheForBashCommand`).
 - User-visible prompts / interactive UI
   - PTY mode opens a TUI overlay titled `Console` and forwards input to the PTY.
-  - Background start messages note that the result is delivered automatically when complete and that the `job` tool can poll until then.
+  - Background start messages note that the result is delivered automatically when complete and that the `hub` tool can wait on it until then.
 - Background work / cancellation
   - Async and auto-background jobs continue after the initial tool return.
   - Cancellation aborts the native run; PTY overlay dismissal also kills the PTY.
diff --git a/docs/tools/edit.md b/docs/tools/edit.md
index e10700c0b..061e45e26 100644
--- a/docs/tools/edit.md
+++ b/docs/tools/edit.md
@@ -67,7 +67,7 @@ The canonical grammar is strict, but the hand parser accepts a few non-dangerous
 - `SWAP.BLK N:` / `DEL.BLK N` / `INS.BLK.POST N:` require a wired tree-sitter resolver; `SWAP.BLK` and `INS.BLK.POST` additionally need at least one `+TEXT` body row, while `DEL.BLK` takes none. An unresolvable block (unsupported language, blank/closing-delimiter line, no node beginning on N, or a syntax error in the resolved block) rejects a `SWAP.BLK` / `DEL.BLK` on the apply/final-preview path (the streaming preview silently drops it instead). `INS.BLK.POST N:` is never rejected this way — it is lowered to plain `INS.POST N:` with a warning: a closing-delimiter-anchor warning when line N is a pure closer (inserting after that end is exactly what the plain form does), a generic unresolved-anchor warning otherwise.
 
 ## Outputs
-- Single-shot tool result; hashline mode does not use a `resolve` preview/apply handshake.
+- Single-shot tool result; hashline mode does not use the staged preview/apply devices (`/xdev/resolve`, `/xdev/reject`).
 - `content` contains one text block per call. For a successful single-file edit it is the post-edit `[path#TAG]` section header (a fresh snapshot tag for the written content), followed by a compact diff preview from `packages/hashline/src/diff-preview.ts` when one is emitted.
 - When the patch used `SWAP.BLK`/`DEL.BLK`/`INS.BLK.POST` ops (and the apply matched the tagged content), one `SWAP.BLK N → resolved lines A-B (K lines)` line per block op (single-line spans render `resolved line A (1 line)`; INS.BLK.POST appends `; body lands after line B`) is inserted between the `[PATH#TAG]` header and the diff preview, so the caller can confirm tree-sitter resolved the construct it intended.
 - Parse, apply, or recovery warnings are appended as:
diff --git a/docs/tools/hub.md b/docs/tools/hub.md
new file mode 100644
index 000000000..3027263e3
--- /dev/null
+++ b/docs/tools/hub.md
@@ -0,0 +1,126 @@
+# hub
+
+> The single agent-coordination surface: peer messaging over the process-global mailbox bus, background-job control, and supervision of shared long-running processes.
+
+Merged from the former `irc`, `job`, and `launch` tools; each op family keeps its old behavior and rendering.
+
+## Source
+- Entry: `packages/coding-agent/src/tools/hub/index.ts` (schema, `HubTool`, unified `wait`, renderer dispatch)
+- Messaging half: `packages/coding-agent/src/tools/hub/messaging.ts`
+- Jobs half: `packages/coding-agent/src/tools/hub/jobs.ts`
+- Launch half: `packages/coding-agent/src/tools/hub/launch.ts`
+- Shared types: `packages/coding-agent/src/tools/hub/types.ts`
+- Model-facing prompt: `packages/coding-agent/src/prompts/tools/hub.md`
+- Key collaborators:
+  - `packages/coding-agent/src/irc/bus.ts` — process-global `IrcBus`: per-agent mailboxes, delivery, waiter matching.
+  - `packages/coding-agent/src/registry/agent-registry.ts` — process-global agent directory and status.
+  - `packages/coding-agent/src/registry/agent-lifecycle.ts` — revival of parked recipients on direct send.
+  - `packages/coding-agent/src/session/agent-session.ts` — `deliverIrcMessage(...)`: recipient-side injection and wake turns.
+  - `packages/coding-agent/src/async/job-manager.ts` — job registry, cancellation, delivery suppression, smart poll ladder.
+  - `packages/coding-agent/src/launch/client.ts` / `broker.ts` / `presence.ts` / `protocol.ts` — process-supervision broker.
+  - `packages/coding-agent/src/config/settings-schema.ts` — `irc.timeoutMs`, `async.pollWaitDuration`, `launch.enabled`.
+
+## Inputs
+
+| Field | Type | Required | Description |
+| --- | --- | --- | --- |
+| `op` | `"send" \| "wait" \| "inbox" \| "list" \| "jobs" \| "cancel" \| "start" \| "ps" \| "logs" \| "stop" \| "restart" \| "describe"` | Yes | Operation. |
+| `to` | `string` | `send` (peer) | Recipient agent id, or `"all"` for broadcast. Mutually exclusive with `name`. |
+| `message` | `string` | `send` (peer) | Message body. Empty-after-trim is rejected. |
+| `replyTo` | `string` | No | `send`: message id being answered. |
+| `await` | `boolean` | No | `send`: after delivery, block until the next message from that peer arrives. Invalid with `to: "all"`. |
+| `from` | `string` | No | `wait`: only accept a message from this agent id (pure message wait). |
+| `ids` | `string[]` | No | `wait`: job ids to watch (omit = all running jobs); `cancel`: job ids to kill (required). |
+| `timeoutMs` | `number` | No | `wait` (messages/jobs): milliseconds; `0` waits indefinitely. Defaults to the poll window when jobs are watched, `irc.timeoutMs` otherwise. |
+| `peek` | `boolean` | No | `inbox`: list messages without consuming them. |
+| `name` | `string` | process ops | Stable project-scoped launch name (1-48 chars). On `send`/`wait` it routes the op to the process broker. |
+| `application`, `args`, `env`, `cwd`, `pty`, `ready`, `restart`, `persist`, `detached` | — | `start` | Launch spec, unchanged from the former `launch` tool. |
+| `lines`, `head`, `grep`, `follow`, `cursor` | — | `logs` | Log window controls, unchanged. |
+| `for`, `pattern` | — | `wait` (name) | Process lifecycle condition / output regex. |
+| `text`, `enter`, `keys`, `signal` | — | `send` (name) | Process stdin / terminal keys / signal. |
+| `timeout` | `number` | No | `logs`/`stop`/`wait`-with-`name`: seconds; default 30 (stop: 5). |
+
+## Op families and dispatch
+- **Messaging** — `send` (with `to`), `inbox`, `list`, and `wait` with `from`. Exact behavior of the former `irc` tool: fire-and-forget sends with delivery receipts (`injected`/`woken`/`revived`/`failed`), broadcast to live peers, parked-agent revival on direct send, `await: true` round-trip sugar, busy-recipient auto-reply when async execution is disabled.
+- **Jobs** — `wait` (bare or with `ids`), `cancel`, `jobs`. Exact behavior of the former `job` tool: owner-scoped visibility, watch/unwatch delivery suppression, `acknowledgeDeliveries` on returned completions, 500 ms `onUpdate` snapshots while waiting, and the `async.pollWaitDuration` fixed/smart wait window. `jobs` is the former `list: true` snapshot (plus the roster of running subagents with no job entry).
+- **Processes** — `start`, `ps`, `logs`, `stop`, `restart`, `describe`, plus `send`/`wait` when they carry `name`. Exact behavior of the former `launch` tool; `ps` is the broker's `list`. See the launch sections below.
+
+`send` with both `to` and `name` is rejected as ambiguous. `wait` routes by target: `name` → process wait; otherwise the unified coordination wait.
+
+## The unified `wait`
+One blocking primitive. It resolves job legs (explicit `ids`, owner-scoped and silently filtered, or every running job the caller owns) and — when the session can message peers — parks a bus waiter, then races:
+- every watched running job's `job.promise`,
+- the first matching incoming message (`from`-filtered when given),
+- the wait window — explicit `timeoutMs` if passed (`0` = no window), else `manager.nextPollWaitMs(...)` under `smart` or the fixed `async.pollWaitDuration`,
+- the tool-call abort signal.
+
+Outcomes:
+- A message wins (even a photo-finish: a message consumed by the bus waiter is never dropped) → the message is returned exactly like the former `irc wait` (`details.waited`), and the jobs keep running; their results still self-deliver.
+- A job settles or the window elapses → a job snapshot exactly like the former `job` poll (`details.jobs`, `## Completed` / `## Still Running` sections). An all-running snapshot is flagged `useless` and rendered as a displaceable waiting frame that the next `hub` call supersedes.
+- No job legs: pure message wait with peer liveness (bounded by `irc.timeoutMs`); with no running peers either, it returns `No running background jobs to wait for.` immediately (plus the jobless running-agent roster when one exists).
+- Explicit `ids` that match nothing visible → `No matching jobs found for IDs: ...` with per-id agent hints (`history://<id>`), never a hang.
+- A message already buffered on the session satisfies the wait before anything is watched.
+
+Smart-ladder bookkeeping (`recordPollWaitEnd`) runs only when the smart window was actually used (no explicit `timeoutMs`).
+
+## Outputs
+- Messaging and job results: single text block plus `details: CoordinationDetails` — `{ op, from?, to?, receipts?, waited?, inbox?, peers?, jobs?, cancelled?, agents? }`. Shapes are unchanged from the former tools except that job-op details now carry `op` (`"wait" | "cancel" | "jobs"`).
+- Process results: `details: LaunchToolDetails` — `{ op, daemon?, daemons?, cursor?, timedOut?, state?, terminalRows?, matched?, spec? }`, unchanged from the former `launch` tool (internally `ps` stores the broker op `list`).
+- Streaming: job-watching waits emit `onUpdate` every 500 ms with fresh snapshots; everything else is single-shot.
+
+## Availability
+- The tool is always registered (`loadMode: "essential"`).
+- Messaging ops require an `AgentRegistry` and a caller agent id; otherwise they return `Peer messaging is unavailable in this session.` (`isIrcEnabled` still gates the peer-roster prompt sections: true for every subagent and for any session that can still spawn subagents).
+- Job ops require `session.asyncJobManager`; otherwise `Async execution is disabled; no background jobs are available.`
+- Process ops require `launch.enabled`; otherwise `Process supervision is disabled (launch.enabled=false).`
+
+## Approval
+`hubApproval` (per-call): `start`, `stop`, `restart`, and `send`-to-process are `exec`; everything else — messaging, job control, `ps`/`logs`/`describe`/`wait` — is `read`.
+
+## Starting and readiness (processes)
+`application` and `args` are separate fields, so callers do not need shell quoting:
+
+```json
+{
+  "op": "start",
+  "name": "web",
+  "application": "bun",
+  "args": ["run", "dev"],
+  "ready": { "log": "Local:.*http", "port": 5173, "timeout": 30 }
+}
+```
+
+Defaults: `cwd` = session directory, `args: []`, `env: {}`, `pty: true`, `restart: "no"`, `persist: false`, `detached: false`, readiness timeout 30 s. `detached: true` implies `persist`, forces `pty: false`, and disables stdin. `ready.log` is a regex over captured output; `ready.port` probes TCP at `ready.host` (default `127.0.0.1`); when both are present, both must pass. A readiness timeout leaves the process running and reports its state.
+
+Names are stable and unique within one project directory. A live name must be stopped or restarted; starting a completed name creates a new launch and rotates its prior output log.
+
+## Logs, input, signals (processes)
+```json
+{"op":"logs","name":"web","grep":"error|warn","lines":50}
+{"op":"logs","name":"web","follow":true,"cursor":1842,"timeout":30}
+{"op":"send","name":"debugger","text":"breakpoint set --name main"}
+{"op":"send","name":"debugger","keys":["CTRL_C"]}
+```
+Each logs result returns a byte cursor; `follow: true` waits until output advances beyond it, the process exits, or the timeout elapses. The broker keeps a 25 MiB current log plus one rotated log. Keys: `ENTER`, `TAB`, `ESCAPE`, `CTRL_C`, `CTRL_D`, arrows. Signals: `SIGINT`, `SIGTERM`, `SIGHUP`, `SIGQUIT`, `SIGKILL`. Input is one shared stream across all project clients.
+
+## Cross-instance lifecycle (processes)
+Unchanged from the former `launch` tool: the first process op starts a detached broker over a private socket under `~/.omp/run/daemons/<project-hash>/`; every omp instance in the project shares names, logs, and state. After the last omp process exits, the broker stops non-persistent processes and exits. `persist: true` opts out of last-client teardown; restart policies (`no`/`on-failure`/`always`) use bounded exponential backoff up to 30 s.
+
+## Limits & Caps
+- Mailboxes: 100 messages per agent (`MAILBOX_CAP`); oldest dropped beyond the cap.
+- `irc.timeoutMs` default `120_000`; `0` disables; negative/non-finite fall back to the default.
+- Poll window: `async.pollWaitDuration` — `5s`/`10s`/`30s`/`1m`/`5m`/`smart` (default); smart ladder `[5s..5m]` climbing per back-to-back wait, resetting after 60 s without waiting.
+- Job retention 5 min; manager max-running fallback 15; `async.maxJobs` clamped 1..100.
+- Launch names 1-48 chars; `ready.port` 1..65535; `logs`/`wait`/`stop` timeouts capped at one hour.
+
+## Errors
+- Text error results (`isError: true`), not throws: messaging unavailable, missing `to`/`message`, self-send (`Cannot send a message to yourself.`), `await` with `to:"all"`, `to`+`name` on one send, missing `ids` on `cancel`, async disabled, launch disabled.
+- Launch validation (missing `name`/`application`, bad `ready.port`, unsupported key) throws `ToolError`, exactly as before.
+- A `wait` timeout is a normal result (`waited: null` or an all-running snapshot flagged `useless`), never an error.
+- Per-recipient delivery failures surface as `failed` receipts; `send` is `isError` only when nothing was delivered.
+
+## Notes
+- The IRC bus, agent registry, job manager, and launch broker are unchanged subsystems; only the tool surface merged.
+- A running recipient still gets messages injected as non-interrupting asides (`irc:incoming` custom messages, `prompts/system/irc-incoming.md`); replies are real turns.
+- Messaging a parked agent revives it — the only resume primitive; the task tool has no `resume` parameter.
+- TUI rendering is preserved per family: messaging cards (`IRC ➤ / ⟵` headers), job waiting frames (displaceable, shimmering rows), and launch frames render byte-identically to the pre-merge tools; the `hub` renderer only dispatches.
diff --git a/docs/tools/irc.md b/docs/tools/irc.md
deleted file mode 100644
index 515461099..000000000
--- a/docs/tools/irc.md
+++ /dev/null
@@ -1,100 +0,0 @@
-# irc
-
-> Send and receive messages between agents over a process-global mailbox bus.
-
-## Source
-- Entry: `packages/coding-agent/src/tools/irc.ts`
-- Model-facing prompt: `packages/coding-agent/src/prompts/tools/irc.md`
-- Key collaborators:
-  - `packages/coding-agent/src/irc/bus.ts` — process-global `IrcBus`: per-agent mailboxes, delivery, waiter matching.
-  - `packages/coding-agent/src/registry/agent-registry.ts` — process-global agent directory and status.
-  - `packages/coding-agent/src/registry/agent-lifecycle.ts` — revival of parked recipients on direct send.
-  - `packages/coding-agent/src/session/agent-session.ts` — `deliverIrcMessage(...)`: recipient-side injection and wake turns.
-  - `packages/coding-agent/src/prompts/system/irc-incoming.md` — incoming-message rendering for the recipient.
-  - `packages/coding-agent/src/prompts/system/irc-autoreply.md` — prompt for the ephemeral auto-reply side turn (busy recipient, async disabled).
-  - `packages/coding-agent/src/config/settings-schema.ts` — `irc.timeoutMs`.
-  - `packages/coding-agent/src/modes/controllers/event-controller.ts` — renders IRC events into chat UI.
-
-## Inputs
-
-| Field | Type | Required | Description |
-| --- | --- | --- | --- |
-| `op` | `"send" \| "wait" \| "inbox" \| "list"` | Yes | Operation. |
-| `to` | `string` | `send` | Recipient agent id, or `"all"` for broadcast. Whitespace trimmed; self-send rejected. |
-| `message` | `string` | `send` | Message body. Empty-after-trim is rejected. |
-| `replyTo` | `string` | No | `send`: message id being answered. |
-| `await` | `boolean` | No | `send`: after delivery, block until the next message from that peer arrives (round-trip sugar). Invalid with `to: "all"`. |
-| `from` | `string` | No | `wait`: only accept a message from this agent id. |
-| `timeoutMs` | `number` | No | `wait` / `send await:true`: timeout in milliseconds; `0` waits indefinitely. Defaults to `irc.timeoutMs`. |
-| `peek` | `boolean` | No | `inbox`: list messages without consuming them. |
-
-## Outputs
-- Single-shot `AgentToolResult`; no streaming updates.
-- `content` is one text block:
-  - `list`: `No other agents.` or `<n> peer(s):` bullets — `id [displayName · kind · status]` plus unread count, parent, and last-activity age; a footer notes that parked agents are revived automatically when messaged.
-  - `send`: per-recipient delivery receipts (`injected` / `woken` / `revived` / `failed — <error>`); with `await: true`, the reply body or a clean no-reply timeout note.
-  - `wait`: the consumed message as `[<msgId>] <from>: <body>` (with a reply-to tag), or `No message within <duration>.`
-  - `inbox`: `Inbox empty.` or `<n> message(s):` bullets.
-- `details: IrcDetails`: `{ op, from?, to?, receipts?, waited?, inbox?, peers? }`. `waited` is `null` when a wait timed out; `receipts` carry `{ to, outcome, error? }`.
-
-## Flow
-1. `IrcTool.createIf` constructs the tool only when `isIrcEnabled` passes and the session has both an `AgentRegistry` and `getAgentId`. There is no `irc.enabled` setting: availability is derived — true for every subagent (`taskDepth > 0`; a parent always exists) and for any session that can still spawn subagents through the task tool. Only a top-level session with task spawning unavailable has no peers, hence no irc.
-2. `execute` resolves the registry and sender id; missing either returns a text error result instead of throwing.
-3. `op: "list"`: `registry.list()` minus self and minus `aborted` agents — `parked` peers ARE listed. Each row includes the unread count from `IrcBus.unreadCount(...)` and last activity.
-4. `op: "send"` validates `to`/`message`, rejects self-sends, and rejects `await` with `to: "all"`.
-5. Target resolution: broadcasts fan out to `registry.listVisibleTo(senderId)` (live peers only — `running`/`idle`; reviving every parked agent on a broadcast would be a stampede). Direct sends go through the bus unfiltered, so a parked recipient is revived.
-6. `IrcBus.send(...)` is fire-and-forget — it never blocks on the recipient generating anything. Delivery by recipient status:
-   - `running` → message enqueued and injected as a non-interrupting aside at the recipient's next step boundary (`AgentSession.deliverIrcMessage`, rendered from `irc-incoming.md`, persisted as an `irc:incoming` custom message) — receipt `injected`. If the sender awaits a reply (`expectsReply` from `await: true`) and the recipient has `async.enabled` off, the recipient also generates an ephemeral no-tools auto-reply (`runEphemeralTurn`, the `/btw` pipeline) and sends it back over the bus with `replyTo` set, recording an `irc:autoreply` aside in its own history — a recipient blocked in a synchronous task spawn can never reach a step boundary before the sender's timeout otherwise;
-   - `idle` (live session) → enqueued and a real turn is started — the message wakes the agent — receipt `woken`;
-   - `parked` → `AgentLifecycleManager.global().ensureLive(to)` revives the session first, then the wake path — receipt `revived`;
-   - resolution/revival failure → receipt `failed` with the error; other recipients still complete.
-7. `send` with `await: true` then calls `IrcBus.wait(senderId, { from: to }, timeoutMs, signal)` and appends the reply (or a no-reply note suggesting `inbox`/`wait`) to the result. Awaited sends pass `{ expectsReply: true }` to `IrcBus.send` so a busy recipient can auto-reply (see step 6).
-8. `op: "wait"` blocks until a message for the caller (optionally filtered by `from`) arrives, consumes it, and returns it. Timeout returns a clean "no message" result, not an error.
-9. `op: "inbox"` drains pending messages (or peeks with `peek: true`) without blocking.
-10. Timeouts resolve as `params.timeoutMs ?? irc.timeoutMs`, normalized: `0` disables the timeout, negative/non-finite values fall back to the default `120_000`, positive values are truncated and clamped to ≥ 1 ms.
-
-## Modes / Variants
-- `list`: enumerate peers with status (`running`/`idle`/`parked`), unread counts, and last activity.
-- `send` direct: one exact peer id; wakes idle peers, revives parked ones.
-- `send` broadcast: `to: "all"` to every live peer; parked peers are skipped.
-- `send` + `await: true`: round-trip convenience — send, then wait for the next message from that peer. Marks the send `expectsReply`, enabling the busy-recipient auto-reply path when async execution is disabled.
-- `wait`: block for an incoming message, optionally filtered by sender.
-- `inbox`: non-blocking drain or peek.
-
-## Side Effects
-- Session state
-  - Reads the process-global `AgentRegistry`; direct sends to parked agents revive their sessions through the lifecycle manager.
-  - Persists `irc:incoming` custom messages into recipient history; replies are ordinary turns in the recipient's own session.
-  - Waking an idle/parked recipient starts a real agent turn (model requests, tool use) in that recipient.
-- User-visible prompts / interactive UI
-  - IRC events render as transcript cards in the TUI; the Agent Hub shows per-agent unread counts.
-- Background work / cancellation
-  - `send` itself never blocks on reply generation; only `wait` (and `await: true`) blocks, bounded by the resolved timeout and the caller's `AbortSignal`.
-- Network
-  - No IRC server connection. Woken recipients make their own model-provider calls as part of their turn.
-- Filesystem
-  - No direct filesystem writes in the tool itself; recipient turns persist to their session JSONL as usual.
-
-## Limits & Caps
-- Availability gates: `isIrcEnabled` (running as a subagent, or task spawning available — there is no `irc.enabled` setting), an `AgentRegistry`, and a caller agent id.
-- Mailboxes are bounded at 100 messages per agent (`MAILBOX_CAP` in `packages/coding-agent/src/irc/bus.ts`); oldest messages are dropped beyond the cap.
-- `irc.timeoutMs` defaults to `120_000` and is the default `wait` / `send await:true` timeout; `0` disables the timeout, non-finite or negative values fall back to the default, positive values are truncated and clamped to at least `1` ms.
-- Broadcast scope: live peers only (`running`/`idle`) via `listVisibleTo`; direct sends address any non-aborted agent, including parked ones.
-
-## Errors
-- The tool returns text errors (with `isError: true`), not thrown exceptions, for:
-  - missing registry: `IRC is unavailable in this session.`
-  - missing sender id: `IRC is unavailable: caller has no agent id.`
-  - missing `to` / `message` on `send`
-  - self-send: `Cannot send an IRC message to yourself.`
-  - `await` with `to: "all"`
-  - unknown op
-- Per-recipient delivery failures surface as `failed` receipts with the error message; `send` is marked `isError` only when no recipient received the message.
-- `wait` timeout is a normal result (`waited: null`), not an error.
-
-## Notes
-- This is IRC-like naming only: no servers, sockets, channels, or join/part state. Addressing is by exact registry agent id.
-- Replies are real turns by the recipient, with one exception: an awaited send to a mid-turn recipient with `async.enabled` off triggers an ephemeral no-tools auto-reply (the old `respondAsBackground` path), because a recipient blocked in a synchronous task spawn whose batch includes the sender can never run a real turn before the sender's timeout. A recipient may otherwise keep working before answering; check `inbox` or `wait` again rather than re-sending.
-- Wake-on-message is the only resume primitive: messaging a parked agent revives it (same `ensureLive` path as the Agent Hub). The task tool has no `resume` parameter.
-- Message ids are Snowflakes; pass them as `replyTo` to thread an answer to a specific message.
-- Persistence is per recipient history: the sender gets receipts in the tool result; the recipient sees the injected `irc:incoming` message in its own transcript (visible via `history://<id>`).
diff --git a/docs/tools/job.md b/docs/tools/job.md
deleted file mode 100644
index 888ab2ff7..000000000
--- a/docs/tools/job.md
+++ /dev/null
@@ -1,141 +0,0 @@
-# job
-
-> Wait for or cancel background jobs managed by the session async runtime.
-
-## Source
-- Entry: `packages/coding-agent/src/tools/job.ts`
-- Model-facing prompt: `packages/coding-agent/src/prompts/tools/job.md`
-- Key collaborators:
-  - `packages/coding-agent/src/async/job-manager.ts` — job registry, cancellation, delivery suppression.
-  - `packages/coding-agent/src/tools/bash.ts` — explicit async bash and auto-backgrounded bash jobs.
-  - `packages/coding-agent/src/task/index.ts` — async task-job scheduling.
-  - `packages/coding-agent/src/sdk.ts` — automatic follow-up delivery for unsuppressed completions.
-  - `packages/coding-agent/src/config/settings-schema.ts` — `async.pollWaitDuration` options.
-
-## Inputs
-
-| Field | Type | Required | Description |
-| --- | --- | --- | --- |
-| `poll` | `string[]` | No | Job ids to watch. Cannot be combined with `list`. If omitted (and `cancel` is also omitted), the tool watches all running jobs owned by the calling agent. If provided, missing ids — and ids owned by other agents — are silently filtered out before waiting. |
-| `cancel` | `string[]` | No | Job ids to cancel before any polling. Missing ids (and other agents' jobs) are reported as `not_found`; non-running ids as `already_completed`. |
-| `list` | `boolean` | No | Return an immediate snapshot of every job spawned by the calling agent (running + completed within retention) without waiting. Read-only — cannot be combined with `poll` or `cancel`. |
-
-## Outputs
-The tool returns one text block plus `details`.
-
-- `content[0].text`: markdown-like plain text sections assembled by `#buildResult(...)`:
-  - `## Cancelled (N)` for cancel outcomes.
-  - `## Completed (N)` for non-running jobs, including stored `resultText` and `errorText`.
-  - `## Still Running (N)` for jobs still in `running`.
-- `details.jobs`: array of snapshots:
-  - `id: string`
-  - `type: "bash" | "task"`
-  - `status: "running" | "completed" | "failed" | "cancelled"`
-  - `label: string`
-  - `durationMs: number`
-  - optional `resultText`, `errorText`
-- `details.cancelled` appears only when `cancel` was passed; each item is `{ id, status }` where status is `"cancelled" | "not_found" | "already_completed"`.
-
-Streaming behavior:
-- During a polling wait, `execute(...)` emits `onUpdate(...)` every 500 ms with an empty text block and fresh `details.jobs` snapshots.
-- Final return is single-shot after a completion, timeout, abort, or immediate fast path.
-
-Read-only snapshot path:
-- Calling `job` with `list: true` returns a markdown summary of every job spawned by the calling agent (running + completed within retention) without waiting.
-
-## Flow
-1. `JobTool` is registered unconditionally in `packages/coding-agent/src/tools/index.ts`; there is no `async.enabled` gate (the manager may still carry bash or task jobs from before a setting change).
-2. `execute(...)` fetches `session.asyncJobManager`. If absent, it returns `Async execution is disabled; no background jobs are available.`
-3. `cancel` ids are processed first:
-   - `manager.getJob(id)` missing → `not_found`.
-   - existing job with `status !== "running"` → `already_completed`.
-   - running job → `manager.cancel(id)`, which sets `job.status = "cancelled"`, aborts the controller, and schedules eviction.
-4. Polling mode is chosen with `const shouldPoll = requestedPollIds !== undefined || cancelIds.length === 0`:
-   - only `cancel` present → return immediately, no wait.
-   - explicit `poll`, or no args at all → proceed to watch jobs.
-5. Watch set resolution:
-   - explicit `poll` → resolve ids via `#visibleJobs(...)`, dropping missing ids and jobs owned by other agents.
-   - no `poll` and no `cancel` → `manager.getRunningJobs(ownerFilter)` (jobs owned by the calling agent).
-6. Empty watch set returns immediately:
-   - if cancellations happened, return snapshots for the cancelled ids that still exist.
-   - else return either `No matching jobs found for IDs: ...` or `No running background jobs to wait for.`
-7. If every watched job is already non-running, `#buildResult(...)` returns immediately without waiting.
-8. Otherwise the tool waits on `Promise.race(...)` across:
-   - every watched running job's `job.promise`,
-   - a timeout promise for the poll wait window — `manager.nextPollWaitMs(ownerId)` when `async.pollWaitDuration` is `smart`, otherwise the fixed duration,
-   - the tool-call abort signal when present.
-9. Before waiting, it calls `manager.watchJobs(watchedJobIds)`. This suppresses automatic completion delivery for those ids while they are being watched.
-10. If `onUpdate` exists, a 500 ms interval sends progress snapshots from `#snapshotJobs(...)`; one snapshot is emitted immediately before entering the race.
-11. In `finally`, the tool always calls `manager.unwatchJobs(...)`, clears the timeout, and stops the progress interval.
-12. `#buildResult(...)` deduplicates jobs, snapshots current manager state, then calls `manager.acknowledgeDeliveries(...)` for every non-running job in the result. That suppresses later automatic follow-up delivery for the same completions and removes queued deliveries for those ids.
-13. The final text groups jobs by non-running vs still-running state. A timeout is not an error path; it simply returns the current snapshot.
-
-## Modes / Variants
-- Poll all running jobs: call with neither `poll` nor `cancel`.
-- Poll explicit ids: call with `poll` only.
-- Cancel only: call with `cancel` only; cancellations happen and the tool returns immediately.
-- Cancel then poll: call with both. Cancellations are applied first, then the tool watches the remaining resolved `poll` ids.
-- Read-only inspection: call with `list: true` for the same snapshot data without waiting on completion.
-
-Spawn paths that produce jobs:
-- `packages/coding-agent/src/tools/bash.ts`
-  - `async: true` always registers a `type: "bash"` job with `AsyncJobManager.register(...)` and returns a start message.
-  - auto-background mode (`bash.autoBackground.enabled`) starts the same managed job path for non-PTY commands, waits up to `min(bash.autoBackground.thresholdMs, timeoutMs - 1000)`, and if the command is still running returns a background-job start result instead of inline command output.
-- `packages/coding-agent/src/task/index.ts`
-  - every `task` call registers one `type: "task"` job, unless the session has no job manager or the agent definition declares `blocking: true` (sync fallback).
-
-Lifecycle and exact state names:
-- Conceptual scheduling path: `pending` (only task-progress bookkeeping before work starts) → `running` → `completed` / `failed`; cancellation changes a running async job to `cancelled`.
-- Exact `AsyncJob.status` values in `packages/coding-agent/src/async/job-manager.ts`: `"running" | "completed" | "failed" | "cancelled"`.
-- Exact per-task progress values in `packages/coding-agent/src/task/types.ts`: `"pending" | "running" | "completed" | "failed" | "aborted"`.
-
-## Side Effects
-- Filesystem
-  - None in `job.ts` itself.
-  - Jobs being observed may already have written artifacts/results through their own tool runtimes.
-- Session state (transcript, memory, jobs, checkpoints, registries)
-  - Reads and mutates `session.asyncJobManager` state.
-  - `watchJobs(...)` / `unwatchJobs(...)` toggle delivery suppression for the watched ids.
-  - `acknowledgeDeliveries(...)` marks completed ids as suppressed and removes queued deliveries for them.
-  - `cancel(...)` aborts running jobs through each job's `AbortController`.
-- User-visible prompts / interactive UI
-  - Polling emits periodic `onUpdate` snapshots every 500 ms.
-  - Automatic job completion follow-ups are generated by `packages/coding-agent/src/sdk.ts` only for unsuppressed deliveries.
-- Background work / cancellation
-  - Waiting uses a timeout plus optional tool-call abort signal.
-  - Cancelling a job does not synchronously await teardown; it flips state, aborts, and returns control to the manager/job promise.
-
-## Limits & Caps
-- Poll wait duration comes from `async.pollWaitDuration` ("Max Poll Time") in `packages/coding-agent/src/config/settings-schema.ts`:
-  - allowed values: `5s`, `10s`, `30s`, `1m`, `5m`, `smart`
-  - default: `smart`
-  - fixed values block for exactly that long; `smart` uses the adaptive ladder `POLL_WAIT_LADDER_MS = [5s, 10s, 30s, 1m, 5m]` in `packages/coding-agent/src/async/job-manager.ts`, climbing one rung per back-to-back poll and resetting to the 5s floor after `POLL_ESCALATION_RESET_MS = 60_000` ms without polling. Per-owner state is driven by `nextPollWaitMs(...)` / `recordPollWaitEnd(...)`.
-- Progress update cadence while polling: `PROGRESS_INTERVAL_MS = 500` in `packages/coding-agent/src/tools/job.ts`.
-- Async job retention default: `DEFAULT_RETENTION_MS = 5 * 60 * 1000` in `packages/coding-agent/src/async/job-manager.ts`.
-- Manager fallback max-running limit: `DEFAULT_MAX_RUNNING_JOBS = 15` in `packages/coding-agent/src/async/job-manager.ts`.
-- Session wiring clamps `async.maxJobs` to `1..100` before constructing the manager in `packages/coding-agent/src/sdk.ts`; settings default is `100` in `packages/coding-agent/src/config/settings-schema.ts`.
-- Async completion delivery retry backoff in `packages/coding-agent/src/async/job-manager.ts`:
-  - base `500` ms
-  - max `30_000` ms
-  - jitter `< 200` ms
-  - exponent capped at 8 doublings
-
-## Errors
-- Tool-disabled path is returned as normal text, not thrown: `Async execution is disabled; no background jobs are available.`
-- Polling a nonexistent id is not an exception:
-  - with `poll` only, missing ids are dropped; if none remain the tool returns `No matching jobs found for IDs: ...`.
-  - with `cancel`, each missing id is reported as `not_found` in `details.cancelled` and text.
-- Cancelling a non-running job is not an exception; it reports `already_completed` even if the actual status is `completed`, `failed`, or `cancelled`.
-- Tool-call abort during polling stops waiting and returns a final snapshot through `#buildResult(...)`; it does not cancel watched jobs.
-- Failures inside the underlying async work are stored on the job (`status: "failed"`, `errorText`) and reported in normal tool output, not rethrown by `job`.
-- Calling `list: true` against an empty manager returns a normal empty-list result rather than throwing; missing ids passed to `poll` are silently filtered.
-- Combining `list` with `poll` or `cancel` throws a `ToolError`: `` `list` cannot be combined with `poll` or `cancel`. ``
-
-## Notes
-- `job` waits for the first watched running job to settle, not for all watched jobs. If others remain `running`, they are reported under `## Still Running`; the caller must invoke `job` again to continue waiting.
-- Delivery suppression is the key difference between snapshot and automatic delivery:
-  - snapshots (`job` calls with `poll` or `list: true`) read current manager state;
-  - follow-up delivery comes from `AsyncJobManager.#enqueueDelivery(...)` and `sdk.ts` `onJobComplete`;
-  - watched or acknowledged ids are suppressed via `isDeliverySuppressed(...)`.
-- `manager.cancel(id)` sets `status = "cancelled"` before the underlying promise settles. The job function may later populate `resultText` or `errorText`; `job-manager.ts` preserves that text but does not transition the status away from `cancelled`.
-- Retention eviction removes the job record, suppression flags, and watch flag together. After eviction, both `job` calls and `list: true` snapshots behave as if the id never existed.
diff --git a/docs/tools/launch.md b/docs/tools/launch.md
deleted file mode 100644
index 1a40a7fca..000000000
--- a/docs/tools/launch.md
+++ /dev/null
@@ -1,122 +0,0 @@
-# launch
-
-> Launch and control long-running project processes shared by every omp instance in the same directory.
-
-## Source
-- Tool: `packages/coding-agent/src/tools/launch.ts`
-- Broker client: `packages/coding-agent/src/daemon/client.ts`
-- Broker runtime: `packages/coding-agent/src/daemon/broker.ts`
-- Omp process presence: `packages/coding-agent/src/daemon/presence.ts`
-- Protocol: `packages/coding-agent/src/daemon/protocol.ts`
-- Model-facing prompt: `packages/coding-agent/src/prompts/tools/launch.md`
-
-## When to use it
-Use `launch` for processes that stay alive after one tool call or need later interaction:
-- web development servers and file watchers
-- debuggers such as lldb and gdb
-- REPLs and interactive application consoles
-- local services whose logs or readiness must be observed
-
-Use `bash` for commands that finish. Async bash remains appropriate for finite commands that need no later stdin; it is not a process supervisor.
-
-## Operations
-
-| Operation | Purpose | Main fields |
-| --- | --- | --- |
-| `start` | Launch a named process. | `name`, `application`, `args`, `env`, `cwd`, `pty`, `ready`, `restart`, `persist`, `detached` |
-| `list` | Snapshot every managed process in the current project scope. | none |
-| `logs` | Read, filter, or follow captured combined output. | `name`, `lines`, `head`, `grep`, `follow`, `cursor`, `timeout` |
-| `wait` | Wait for readiness, exit, or an output regex. | `name`, `for`, `pattern`, `timeout` |
-| `send` | Write stdin, terminal keys, or a process signal. | `name`, `text`, `enter`, `keys`, `signal` |
-| `stop` | Gracefully terminate the managed process tree, then hard-kill if needed. | `name`, `timeout` |
-| `restart` | Stop and relaunch using the retained launch specification. | `name` |
-| `describe` | Show the retained launch specification and live state. | `name` |
-
-Names are stable and unique within one project directory. A live name must be stopped or restarted; starting a completed name creates a new launch and rotates its prior output log.
-
-## Starting and readiness
-`application` and `args` are separate fields, so callers do not need shell quoting:
-
-```json
-{
-  "op": "start",
-  "name": "web",
-  "application": "bun",
-  "args": ["run", "dev"],
-  "ready": {
-    "log": "Local:.*http",
-    "port": 5173,
-    "timeout": 30
-  }
-}
-```
-
-Defaults:
-- `cwd`: current coding-agent session directory
-- `args`: `[]`
-- `env`: `{}` over the broker's inherited environment
-- `pty`: `true`
-- `restart`: `no`
-- `persist`: `false`
-- `detached`: `false`
-- readiness timeout: 30 seconds
-
-`detached: true` implies `persist: true`, forces `pty: false`, and disables stdin. Its process survives broker shutdown and every omp exit; a later broker reconnects to its records for logs and explicit `stop`.
-
-`ready.log` is a regular expression matched against captured output. `ready.port` probes TCP at `ready.host` (default `127.0.0.1`). When both are present, both must pass. A readiness timeout leaves the process running and returns its current state so the caller can inspect logs or stop it.
-
-Without a readiness condition, a successfully created process enters `running`. With readiness configured, it moves `starting` → `ready`; launch or nonzero-exit failures move to `failed`.
-
-## Logs and following
-stdout and stderr are captured into one ordered stream when possible. PTY output is naturally combined.
-
-```json
-{"op":"logs","name":"web","lines":100}
-{"op":"logs","name":"web","grep":"error|warn","lines":50}
-{"op":"logs","name":"web","follow":true,"cursor":1842,"timeout":30}
-```
-
-Each logs result returns a byte cursor. `follow: true` waits until output advances beyond the supplied cursor, the process exits, or the timeout elapses, then returns a fresh window. `head: true` reads from the beginning; the default reads the tail.
-
-The broker keeps a 25 MiB current log and one 25 MiB rotated log while it owns a process's output stream. A detached process writes directly to its disk log so it survives broker exit; output is not rotated while no broker is running.
-
-## Input and signals
-
-```json
-{"op":"send","name":"debugger","text":"breakpoint set --name main"}
-{"op":"send","name":"debugger","text":"run"}
-{"op":"send","name":"debugger","keys":["CTRL_C"]}
-```
-
-`enter` defaults to true when `text` is present. Supported keys are `ENTER`, `TAB`, `ESCAPE`, `CTRL_C`, `CTRL_D`, `UP`, `DOWN`, `LEFT`, and `RIGHT`. Supported signals are `SIGINT`, `SIGTERM`, `SIGHUP`, `SIGQUIT`, and `SIGKILL`.
-
-All project clients may observe the same managed process. Input is one shared stream: each send operation is serialized, but two clients writing independently still address the same process stdin.
-
-## Cross-instance lifecycle
-Every omp session registers its process in the canonical project scope. The first `launch` call starts a detached broker over a private socket; later `launch` calls from any registered omp process connect to the same broker and see the same names, logs, and state.
-
-Runtime data lives under `~/.omp/run/daemons/<project-hash>/`:
-- `broker.sock` (or a Windows named pipe)
-- a mode-0600 authentication token
-- broker PID metadata
-- per-managed-process launch metadata and logs
-- live omp process-presence records
-
-After the last tool socket disconnects, the broker checks the project-presence records. Live omp PIDs keep non-persistent managed processes running even when those omp instances have not called `launch`; dead PIDs are removed. Once no omp process remains, the broker waits three seconds, stops every non-persistent managed process, and exits. This PID check still works when an omp process is killed without JavaScript cleanup.
-
-`persist: true` explicitly opts a managed process out of last-client teardown. A broker with a live persistent process remains available without clients until another omp reconnects and stops it. Broker recovery terminates stale recorded children and preserves their records as exited instead of adopting an unknown process state.
-
-## Restart policies
-- `no`: never restart automatically (default)
-- `on-failure`: restart after a nonzero exit or runtime failure
-- `always`: restart after any unexpected exit
-
-Automatic restarts use bounded exponential backoff up to 30 seconds. Explicit `stop` suppresses restart. `restart` always reuses the retained application, arguments, environment, working directory, PTY, readiness, persistence, and detached settings.
-
-## Errors and limits
-- Names must be 1-48 letters, numbers, dots, underscores, or hyphens.
-- `ready.port` must be an integer from 1 through 65535.
-- Invalid readiness, wait, or log regular expressions are rejected before use.
-- Sending to a stopped managed process or to unavailable stdin is an error.
-- `logs`, `wait`, and `stop` timeouts are capped at one hour by the tool.
-- PTY process-group signaling is POSIX-native. Windows ConPTY accepts input and Ctrl-C; other POSIX signals become hard termination because Windows has no equivalent signal model.
diff --git a/docs/tools/resolve.md b/docs/tools/resolve.md
deleted file mode 100644
index 1027fa43a..000000000
--- a/docs/tools/resolve.md
+++ /dev/null
@@ -1,90 +0,0 @@
-# resolve
-
-> Finalizes a pending action by applying or discarding it.
-
-## Source
-- Entry: `packages/coding-agent/src/tools/resolve.ts`
-- Model-facing prompt: `packages/coding-agent/src/prompts/tools/resolve.md`
-- Key collaborators:
-  - `docs/resolve-tool-runtime.md` — preview/apply runtime reference
-  - `packages/coding-agent/src/extensibility/custom-tools/loader.ts` — forwards custom pending actions into the queue
-  - `packages/coding-agent/src/tools/ast-edit.ts` — built-in preview producer example
-  - `packages/coding-agent/src/session/agent-session.ts` — tool-choice queue, standing resolve handler, and invoker access
-
-## Inputs
-
-| Field | Type | Required | Description |
-| --- | --- | --- | --- |
-| `action` | `"apply" | "discard"` | Yes | Whether to commit or reject the pending action. |
-| `reason` | `string` | Yes | Required explanation passed through to the handler. |
-| `extra` | `Record<string, unknown>` | No | Free-form metadata passed through to the handler. Plan approval uses this for data such as a title slug; preview-style actions usually ignore it. |
-
-## Outputs
-- Single-shot result.
-- `execute()` returns whatever the queued or standing invoker returns, with `details` wrapped/augmented to include:
-  - `action`
-  - `reason`
-  - `extra?`
-  - `sourceToolName?`
-  - `label?`
-  - `sourceResultDetails?` — original `result.details` from the apply/reject callback when present
-- If `discard` has no custom reject callback, or the reject callback returns `undefined`, the default success payload is `Discarded: <label>. Reason: <reason>`.
-- The TUI renderer is inline and merges call+result into one block.
-
-## Flow
-1. Preview-producing code can call `queueResolveHandler(...)` with a label, source tool name, `apply(reason, extra?)` callback, and optional `reject(reason, extra?)` callback.
-2. Modes can also register a standing resolve handler through `session.setStandingResolveHandler(...)`; `resolve.execute()` consults it only when no queued invoker is active.
-3. `queueResolveHandler(...)` registers a non-forcing pending invoker on the session's tool-choice queue under a unique `pending-action:<sourceTool>:<seq>` id. It does NOT force a tool choice and does NOT steer a reminder.
-4. While a preview is pending, the session's `getToolChoice` (`nextToolChoiceDirective`) returns a `SoftToolRequirement` (`toolName: "resolve"`) carrying the resolve reminder — a non-consuming peek. The agent runtime injects the reminder once and forces `tool_choice: resolve` for one turn only if the model declines (see `docs/resolve-tool-runtime.md`). The reminder text is:
-
-```text
-<system-reminder>
-This is a preview. Call the `resolve` tool to apply or discard these changes.
-</system-reminder>
-```
-
-5. When `resolve.execute()` runs, it wraps the call in `untilAborted(...)` and dispatches via `session.peekQueueInvoker?.() ?? session.peekPendingInvoker?.() ?? session.peekStandingResolveHandler?.()`.
-6. If no invoker exists, `apply` throws `ToolError("No pending action to resolve. Nothing to apply or discard.")`; `discard` instead returns a success payload `Nothing to discard; no pending action remains.` because the desired end-state (no staged change) already holds.
-7. Otherwise it invokes the current handler with the full params object.
-8. `runResolveInvocation(...)` builds base details from `action`, `reason`, `extra`, `sourceToolName`, and `label`.
-9. For `apply`, it calls the producer's `apply(reason, extra)` callback.
-10. If `apply` throws, `runResolveInvocation(...)` calls `onApplyError` when present. The pending-preview integration uses this to re-register the same pending invoker (same id) so the action remains pending for discard or retry. Non-`ToolError` exceptions are wrapped as `ToolError("Apply failed: <message>")`.
-11. For `discard`, it calls `reject(reason, extra)` when provided. If no reject callback exists or it returns `undefined`, `resolve` fabricates the default discard message.
-12. Before returning callback results, it merges resolve metadata into `result.details` so renderer/UI code can show the action, label, and originating tool.
-
-## Modes / Variants
-- `apply`: runs the pending action's `apply(reason, extra?)` callback and returns its content.
-- `discard` with reject callback: runs `reject(reason, extra?)` and returns that callback's content when non-`undefined`.
-- `discard` without reject callback, or with a reject callback returning `undefined`: returns the built-in `Discarded: ...` text payload.
-- `discard` with no pending action at all: returns `Nothing to discard; no pending action remains.` as a success result.
-- Pending invoker: a non-forcing preview invoker in the pending-invoker registry (separate from the consuming directive queue), used by preview producers such as `ast_edit`.
-- Standing handler: long-lived mode-owned handler, used as a fallback when no queue invoker is active.
-
-## Side Effects
-- Session state
-  - Consumes or invokes the current pending action through the pending invoker, tool-choice queue, or standing handler; `resolve` does not maintain its own stack.
-  - Does not steer a reminder or force a tool choice for previews — the reminder rides a non-forcing `SoftToolRequirement` and the agent runtime forces `resolve` only on non-compliance.
-  - On queued apply failure, requeues the same pending action before rethrowing so the model can discard or retry instead of losing the pending preview.
-- User-visible prompts / interactive UI
-  - The visible effect depends on the preview-producing tool and the resolve renderer.
-  - Renderer result blocks show `Accept`, `Discard`, or `Failed`, include the pending action label, and display the reason.
-- Background work / cancellation
-  - `untilAborted(...)` lets abort signals interrupt resolution before or while the callback awaits.
-
-## Limits & Caps
-- Hidden tool: `ResolveTool.hidden = true`, and normal requested-tool filtering removes `resolve`; `createTools(...)` adds it separately as a hidden tool.
-- Per call, `resolve` consults the in-flight hard-directive queue invoker (`session.peekQueueInvoker()`), then the non-forcing pending-preview invoker (`session.peekPendingInvoker()`), then a standing handler (`session.peekStandingResolveHandler()`).
-- There is no independent depth cap in this tool; pending previews stack as unique-keyed invokers (resolved head-first), separate from the consuming directive queue and the mode-owned standing handler lifecycle.
-
-## Errors
-- `apply` with no pending action or standing handler: throws `ToolError("No pending action to resolve. Nothing to apply or discard.")`. `discard` in the same situation succeeds with `Nothing to discard; no pending action remains.` instead of erroring.
-- `apply` callback throws `ToolError`: the original `ToolError` propagates.
-- `apply` callback throws any other value: `resolve` wraps it as `ToolError("Apply failed: <message>")` after running `onApplyError` when present.
-- `reject` callback exceptions propagate without the apply-specific wrapper.
-- Aborts during `untilAborted(...)` surface as the underlying abort error from the utility.
-
-## Notes
-- `reason` and `extra` are passed through; `resolve` itself does not interpret them.
-- `queueResolveHandler(...)` is the canonical built-in preview integration point; custom tools use `pushPendingAction(...)`, which the loader forwards into the same mechanism.
-- Standing handlers let modes accept `resolve` invocations without forcing the tool choice every turn.
-- `sourceResultDetails` is added only when the apply/reject callback returned a non-null `details` field; custom pending-action `details` are not forwarded automatically by the loader.
diff --git a/docs/tools/search_tool_bm25.md b/docs/tools/search_tool_bm25.md
deleted file mode 100644
index c6b27cb5b..000000000
--- a/docs/tools/search_tool_bm25.md
+++ /dev/null
@@ -1,118 +0,0 @@
-# search_tool_bm25
-
-> Search the hidden tool-discovery index and activate the top matches for the current session.
-
-## Source
-- Entry: `packages/coding-agent/src/tools/search-tool-bm25.ts`
-- Model-facing prompt: `packages/coding-agent/src/prompts/tools/search-tool-bm25.md`
-- Key collaborators:
-  - `packages/coding-agent/src/tool-discovery/tool-index.ts` — discoverable-tool metadata and BM25 index/search.
-  - `packages/coding-agent/src/session/agent-session.ts` — session discovery mode, corpus assembly, activation, cache invalidation.
-  - `packages/coding-agent/src/sdk.ts` — initial hiding of discoverable built-ins and prompt-time discoverable summary.
-  - `packages/coding-agent/src/tools/index.ts` — tool-session discovery hooks, essential/discoverable load modes, registry wiring.
-  - `packages/coding-agent/src/config/settings-schema.ts` — `tools.discoveryMode` and legacy `mcp.discoveryMode` settings.
-
-## Inputs
-
-| Field | Type | Required | Description |
-| --- | --- | --- | --- |
-| `query` | `string` | Yes | Natural-language or keyword query. Trimmed before search; empty-after-trim is rejected. |
-| `limit` | `integer` | No | Max matches to return and activate. Minimum `1`. Defaults to `8` (`DEFAULT_LIMIT`). |
-
-## Outputs
-- Single-shot `AgentToolResult`.
-- Model-visible `content` is one text part containing JSON with:
-
-```json
-{"query":"...","activated_tools":["..."],"match_count":2,"total_tools":17}
-```
-
-- Runtime-only `details` carries the ranked matches used by the TUI renderer:
-  - `query`, `limit`, `total_tools`
-  - `activated_tools`: tool names activated by this call
-  - `active_selected_tools`: cumulative discovered-tool selections still active
-  - `tools`: array of match objects with
-    - `name`
-    - `label`
-    - `description` (`tool.summary`; this is the only snippet-like field)
-    - optional `server_name`
-    - optional `mcp_tool_name`
-    - `schema_keys`
-    - `score` rounded to 6 decimals
-- The renderer shows a status line plus up to 5 collapsed tree items by default (`COLLAPSED_MATCH_LIMIT`), each with label, optional server name, score to 3 decimals, and truncated description. The ranked match list is not serialized into `content`.
-
-## Flow
-1. `SearchToolBm25Tool.createIf()` in `packages/coding-agent/src/tools/search-tool-bm25.ts` exposes the tool for explicit discovery modes (`"mcp-only"` / `"all"`) or legacy `mcp.discoveryMode === true`. The default `"auto"` mode is resolved later by `createAgentSession()` after MCP/extension tools are registered.
-2. `description` is rendered from `packages/coding-agent/src/prompts/tools/search-tool-bm25.md` via `renderSearchToolBm25Description()`, using the current discoverable-tool list plus per-server summary/count.
-3. `execute()` re-checks capability and settings:
-   - missing discovery hooks -> `ToolError("Tool discovery is unavailable in this session.")`
-   - discovery disabled -> `ToolError("Tool discovery is disabled. Enable tools.discoveryMode or mcp.discoveryMode to use search_tool_bm25.")`
-4. `query` is trimmed and validated; `limit` is defaulted/validated.
-5. `getDiscoverableToolSearchIndexForExecution()` fetches the cached generic search index from the session when available, otherwise rebuilds an index from the current discoverable-tool list.
-6. `getSelectedToolNames()` reads the current discovered selections so already-selected tools can be excluded from fresh results.
-7. `searchDiscoverableTools()` in `packages/coding-agent/src/tool-discovery/tool-index.ts` tokenizes the query, scores every document with BM25, sorts by descending score then `tool.name`, and returns up to `searchIndex.documents.length` results; `execute()` then filters already-selected names and slices to `limit`.
-8. If any matches remain, `activateTools()` activates all matched tool names through `session.activateDiscoveredTools()` or legacy `activateDiscoveredMCPTools()`.
-9. `details` is assembled from the activated names, current selected names, corpus size, and formatted matches; `content` is reduced to the compact JSON summary from `buildSearchToolBm25Content()`.
-10. `searchToolBm25Renderer` renders either:
-   - the structured `details` view, or
-   - a fallback text-only warning block if `details` is absent.
-
-## Modes / Variants
-- Discovery-mode gating:
-  - `tools.discoveryMode = "auto"` (default): when the registered tool set has more than 40 tools, searches hidden MCP tools only; otherwise discovery stays off.
-  - `tools.discoveryMode = "all"`: searches hidden discoverable built-ins plus hidden MCP tools.
-  - `tools.discoveryMode = "mcp-only"`: searches hidden MCP tools only.
-  - legacy `mcp.discoveryMode = true`: same as MCP-only.
-- Search-index source:
-  - generic cached discoverable index from the session (`getDiscoverableToolSearchIndex()`)
-  - rebuilt ad hoc from the current discoverable-tool list when the cache path fails
-- Activation backend:
-  - generic `activateDiscoveredTools()`
-  - legacy `activateDiscoveredMCPTools()` fallback
-
-## Side Effects
-- Session state
-  - Adds matched tools to the active session tool set through `activateDiscoveredTools()` / `activateDiscoveredMCPTools()`.
-  - Updates discovered-tool selection state so repeated searches accumulate selections instead of replacing them.
-  - Invalidates the cached discoverable search index when newly activated built-ins change the hidden corpus (`packages/coding-agent/src/session/agent-session.ts`).
-  - Tool availability changes before the next model call in the same turn; the prompt text says this explicitly.
-- User-visible prompts / interactive UI
-  - The tool description includes discoverable server summaries and total discoverable-tool count.
-  - The TUI renderer shows ranked matches, but the model-visible text summary does not.
-
-## Limits & Caps
-- Default result cap: `8` (`DEFAULT_LIMIT` in `packages/coding-agent/src/tools/search-tool-bm25.ts`).
-- `limit` must be a positive integer; no tool-level upper bound beyond corpus size.
-- Renderer collapsed list cap: `5` (`COLLAPSED_MATCH_LIMIT`).
-- Renderer truncation widths:
-  - label: `72` chars (`MATCH_LABEL_LEN`)
-  - description: `96` chars (`MATCH_DESCRIPTION_LEN`)
-- BM25+ parameters in `packages/coding-agent/src/tool-discovery/tool-index.ts`:
-  - `BM25_K1 = 1.2`
-  - `BM25_B = 0.75`
-  - `BM25_DELTA = 1.0`
-- Weighted corpus fields (`FIELD_WEIGHTS`):
-  - `name`: `6`
-  - `label`: `4`
-  - `mcpToolName`: `4`
-  - `serverName`: `2`
-  - `summary`: `2`
-  - each `schemaKey`: `1`
-- Summary fallback length for discoverable metadata: first `200` chars of `description` when no explicit summary exists (`getDiscoverableTool()` in `packages/coding-agent/src/tool-discovery/tool-index.ts`).
-
-## Errors
-- `execute()` throws `ToolError` for unavailable discovery hooks, disabled discovery mode, empty trimmed query, and non-positive/non-integer `limit`.
-- `searchDiscoverableTools()` throws `Error("Query must contain at least one letter or number.")` if tokenization produces no letter/number tokens; `execute()` catches `Error` and rethrows `ToolError(error.message)`.
-- Empty corpus is not an error; search returns `[]`, activation is skipped, and the renderer message becomes either `No discoverable tools are currently loaded.` or `No matching tools found.`
-- `getDiscoverableToolsForDescription()` and `getDiscoverableToolSearchIndexForExecution()` swallow discovery-hook/cache errors and fall back to an empty corpus or rebuilt index.
-
-## Notes
-- The tool wire name stays `search_tool_bm25` for persisted-session back-compat, even though the source file is `search-tool-bm25.ts`.
-- Corpus composition is session-dependent and excludes already-active tools:
-  - MCP entries come from `#discoverableMCPTools` (built by `#collectDiscoverableMCPToolsFromRegistry()`), filtered to names not currently active; `MCPTool` carries no `summary`, so `getDiscoverableTool()` derives `summary` from the first `200` chars of `description`.
-  - Built-in entries appear only in `"all"` mode and only for registry tools whose `loadMode === "discoverable"` and are not currently active.
-  - Hidden/internal built-ins are intentionally excluded from the built-in corpus: `resolve`, `yield`, `report_finding`, `report_tool_issue` are called out in the `#collectDiscoverableBuiltinTools()` comment.
-- `DiscoverableToolSource` includes `"extension"` and `"custom"`, but `AgentSession.getDiscoverableTools()` currently assembles only built-in and MCP sources.
-- On startup, `packages/coding-agent/src/sdk.ts` resolves `"auto"` after the full registry exists and injects `search_tool_bm25` when the count exceeds 40. It hides non-essential discoverable built-ins only in `tools.discoveryMode = "all"`. Tools whose class is marked as `loadMode === "essential"` (defaults are `read`, `bash`, `edit`, `write`, `glob`, and `eval`) are always active; they survive hiding regardless of configuration. `tools.essentialOverride` can be used to treat additional discoverable tools as essential (active on startup) or to explicitly specify the active essential list.
-- Query tokenization is simple and deterministic: Unicode is NFKD-normalized, combining marks are dropped, acronym/camelCase and digit-to-capital boundaries are split, non-letter/non-number characters become spaces, tokens are lowercased, and only non-empty tokens survive.
-- Scores are rounded differently by surface: `details.tools[].score` keeps 6 decimals; the TUI line renders 3.
diff --git a/docs/tools/ssh.md b/docs/tools/ssh.md
deleted file mode 100644
index 15c3f8162..000000000
--- a/docs/tools/ssh.md
+++ /dev/null
@@ -1,127 +0,0 @@
-# ssh
-
-> Execute one remote command on a discovered SSH host.
-
-## Source
-- Entry: `packages/coding-agent/src/tools/ssh.ts`
-- Model-facing prompt: `packages/coding-agent/src/prompts/tools/ssh.md`
-- Key collaborators:
-  - `packages/coding-agent/src/ssh/ssh-executor.ts` — runs `ssh`, captures output
-  - `packages/coding-agent/src/ssh/connection-manager.ts` — master-connection reuse, host probing
-  - `packages/coding-agent/src/ssh/sshfs-mount.ts` — optional `sshfs` mount side effect
-  - `packages/coding-agent/src/discovery/ssh.ts` — discovers host configs
-  - `packages/coding-agent/src/capability/ssh.ts` — canonical host shape
-  - `packages/coding-agent/src/session/streaming-output.ts` — tail streaming, truncation, artifacts
-  - `packages/coding-agent/src/tools/tool-timeouts.ts` — timeout clamp rules
-  - `packages/utils/src/dirs.ts` — user/project ssh config paths
-
-## Inputs
-
-| Field | Type | Required | Description |
-| --- | --- | --- | --- |
-| `host` | `string` | Yes | Host name key from discovered SSH config entries, not an arbitrary hostname/IP. |
-| `command` | `string` | Yes | Remote command string passed to `ssh` as the remote command. |
-| `cwd` | `string` | No | Remote working directory. The tool prepends a shell-specific `cd`/`Set-Location` wrapper. |
-| `timeout` | `number` | No | Timeout in seconds. Default `60`; clamped to `1..3600`. |
-
-## Outputs
-The tool returns a standard text tool result built in `packages/coding-agent/src/tools/ssh.ts`:
-
-- `content`: one text block containing combined remote stdout+stderr, or `"(no output)"` when empty.
-- `details.meta.truncation`: present when output exceeded the in-memory tail window; derived from the executor summary.
-
-Streaming behavior:
-
-- While the command runs, `onUpdate` receives tail-only text snapshots built from `TailBuffer` in `packages/coding-agent/src/session/streaming-output.ts`.
-- Final output is single-shot after process exit.
-
-Side-channel artifacts:
-
-- When session artifact allocation is available and output exceeds the spill threshold, full output is written to a session artifact file and the returned summary carries its `artifactId` internally.
-- The ssh tool itself does not print the `artifact://...` URI into the result text.
-
-Failure behavior:
-
-- Unknown host, missing host config, timeout, cancellation, SSH startup failure, key validation failure, or non-zero remote exit all surface as thrown `ToolError`s.
-- Non-zero remote exit includes captured output plus `Command exited with code N`.
-
-## Flow
-1. `loadSshTool()` in `packages/coding-agent/src/tools/ssh.ts` calls `loadCapability(sshCapability.id, { cwd: session.cwd })` to discover hosts.
-2. `packages/coding-agent/src/discovery/ssh.ts` loads host entries from, in this order: project managed ssh config, user managed ssh config, `ssh.json` in the repo root, `.ssh.json` in the repo root.
-3. `getSSHConfigPath("project")` and `getSSHConfigPath("user")` in `packages/utils/src/dirs.ts` resolve those managed files to `.omp/ssh.json` in the project and `~/.omp/agent/ssh.json` in the user config dir. This tool does not read `~/.ssh/config`.
-4. Capability loading deduplicates by host name with first item winning; provider order is priority-sorted and the SSH JSON provider registers at priority `5`.
-5. `loadHosts()` in `packages/coding-agent/src/tools/ssh.ts` builds `hostsByName` and drops later duplicates again with `if (!hostsByName.has(host.name))`.
-6. Tool description text is built from `packages/coding-agent/src/prompts/tools/ssh.md` plus an `Available hosts:` list. Each host entry calls `getCachedHostInfoSync()` to show detected shell/OS when cached; otherwise it renders `detecting...`.
-7. On execute, `SshTool.execute()` rejects any `host` not in the discovered host-name set.
-8. `ensureHostInfo()` in `packages/coding-agent/src/ssh/connection-manager.ts` ensures an SSH master connection exists, loads cached host info from disk if present, and probes remote OS/shell when cache is missing or stale.
-9. `buildRemoteCommand()` in `packages/coding-agent/src/tools/ssh.ts` prepends a cwd change when `cwd` is provided:
-   - Unix-like or Windows compat shells: `cd -- '<cwd>' && <command>`
-   - Windows PowerShell: `Set-Location -Path '<cwd>'; <command>`
-   - Windows cmd: `cd /d "<cwd>" && <command>`
-10. `clampTimeout("ssh", rawTimeout)` applies the `1..3600` second clamp from `packages/coding-agent/src/tools/tool-timeouts.ts`.
-11. `executeSSH()` in `packages/coding-agent/src/ssh/ssh-executor.ts` calls `ensureConnection(host)` again, opportunistically mounts the remote host root with `sshfs` if available, optionally wraps the command in `bash -c` or `sh -c` for Windows compat mode, then spawns `ssh` with `ptree.spawn`.
-12. Output from both stdout and stderr is piped into one `OutputSink`; chunks are sanitized and forwarded to streaming updates through `streamTailUpdates()`.
-13. On normal exit, the sink returns combined output plus truncation counters. On timeout or abort, `executeSSH()` returns `cancelled: true` and prefixes the output with a notice line such as `[SSH: ...]` or `[Command aborted: ...]`.
-14. `SshTool.execute()` converts `cancelled: true` into `ToolError`, converts non-zero exit codes into `ToolError`, otherwise returns the text result with truncation metadata.
-
-## Modes / Variants
-- **Tool unavailable**: `loadSshTool()` returns `null` when discovery finds no hosts, so the tool is not registered for that session.
-- **Unix-like target**: remote command is passed through directly, with optional `cd -- ... &&` prefix.
-- **Windows native shell**: cwd wrapper uses PowerShell `Set-Location` or cmd `cd /d`; command otherwise runs in the remote default Windows shell.
-- **Windows compat shell**: if host probing finds `bash` or `sh` on Windows, `executeSSH()` wraps the remote command as `bash -c '...'` or `sh -c '...'`. Host config can force compat on/off with `compat`.
-- **Cached vs probed host info**: shell/OS detection comes from in-memory cache, persisted JSON under the remote-host dir, or a fresh probe over SSH.
-- **Truncated vs untruncated output**: small output stays in memory; large output keeps only the last 50 KiB in memory and may spill full output to an artifact file.
-
-## Side Effects
-- Filesystem
-  - Reads managed SSH config JSON plus legacy `ssh.json` / `.ssh.json`.
-  - Validates private-key path existence and permissions before connecting.
-  - Persists probed host info as JSON under the remote-host cache dir via `persistHostInfo()`.
-  - May create the SSH control socket dir and, when `sshfs` exists, remote mount dirs.
-  - May write full command output to a session artifact file.
-- Network
-  - Opens SSH connections to the selected host.
-  - May issue extra probe commands to detect OS/shell and compat shells.
-- Subprocesses / native bindings
-  - Requires `ssh` on `PATH`; spawns it for connection checks, master startup, probing, and command execution.
-  - May call `sshfs`, `mountpoint`, `fusermount`/`fusermount3`, or `umount`.
-  - Sanitizes streamed text with `@oh-my-pi/pi-natives` text sanitization.
-- Session state (transcript, memory, jobs, checkpoints, registries)
-  - Uses session artifact allocation when available.
-  - Registers postmortem cleanup hooks for SSH master connections and sshfs mounts.
-  - Tool concurrency is `exclusive`, so the agent scheduler should not run multiple ssh tool calls concurrently.
-- Background work / cancellation
-  - Process spawn receives the tool `AbortSignal`.
-  - Cancellation/timeout ends the running ssh process and returns a cancelled result that the tool turns into an error.
-
-## Limits & Caps
-- Timeout defaults/clamps: `default=60`, `min=1`, `max=3600` in `packages/coding-agent/src/tools/tool-timeouts.ts`.
-- Output tail window: `DEFAULT_MAX_BYTES = 50 * 1024` in `packages/coding-agent/src/session/streaming-output.ts`.
-- Output sink spill threshold defaults to the same `50 KiB`; once exceeded, only the tail remains in memory.
-- SSH master reuse persistence: `ControlPersist=3600` in `packages/coding-agent/src/ssh/connection-manager.ts` and `packages/coding-agent/src/ssh/sshfs-mount.ts`.
-- SSH host info schema version: `HOST_INFO_VERSION = 2` in `packages/coding-agent/src/ssh/connection-manager.ts`; stale cache entries are reprobed.
-- Streaming tail buffer compacts after more than `10` pending chunks (`MAX_PENDING`) before trimming.
-
-## Errors
-- `Unknown SSH host: ... Available hosts: ...` when the model passes a host name not present in discovery.
-- `SSH host not loaded: ...` if the discovered-name set and `hostsByName` map diverge.
-- `ssh binary not found on PATH` when `ssh` is unavailable.
-- `SSH key not found: ...`, `SSH key is not a file: ...`, or `SSH key permissions must be 600 or stricter: ...` from key validation.
-- `Failed to start SSH master for <target>: <stderr>` when control-master startup fails.
-- Non-zero remote command exit becomes `ToolError` with captured output and `Command exited with code N`.
-- Timeout becomes a cancelled result with output notice `[SSH: <timeout message>]`, then `ToolError`.
-- Abort becomes a cancelled result with output notice `[Command aborted: <message>]`, then `ToolError`.
-- `sshfs` mount failures are logged and ignored in `executeSSH()`; they do not fail the tool call.
-- Discovery parse problems do not fail tool loading; they become capability warnings. If all sources are empty/invalid, the tool simply does not load.
-
-## Notes
-- Host discovery is JSON-based only. The tool does not parse OpenSSH config files.
-- Discovery expands environment variables recursively in the parsed JSON and expands `~` in `key`/`keyPath`.
-- Host names are capability keys; the model must pass the config key, not the raw hostname.
-- Commands run without a PTY. `executeSSH()` uses `ptree.spawn(..., { stdin: "pipe", stderr: "full" })` and does not request an interactive terminal.
-- The tool exposes `cwd` but no `env`, `pty`, upload, download, or explicit file-transfer fields.
-- Lower layers support an `artifactId` for full output and a `remotePath` mount target, but `SshTool.execute()` does not expose those knobs.
-- Both stdout and stderr are merged into one output stream; ordering is whatever arrives through the two streams.
-- `StrictHostKeyChecking=accept-new` and `BatchMode=yes` are always set for connection checks, master startup, and command runs.
-- Connection reuse is keyed by discovered host name, not by raw target tuple alone.
-- `closeAllConnections()` and sshfs unmount cleanup run through postmortem hooks, not per-call teardown.
diff --git a/docs/tools/task.md b/docs/tools/task.md
index 61be00580..1a5a98be9 100644
--- a/docs/tools/task.md
+++ b/docs/tools/task.md
@@ -51,9 +51,9 @@ There is no per-call `schema` parameter. Structured output comes from the agent
 The tool returns one text block plus `details: TaskToolDetails`.
 
 Background response (`async.enabled=true`):
-- `content`: `` Spawned agent `<id>` (job `<jobId>`). The result will be delivered when it yields. ... `` plus a coordination hint (`irc` DM when enabled, otherwise `job`). A batch call instead returns `` Spawned N background agents using <agent types>. ... `` (the deduped per-item agent types, comma-joined) with a per-agent `- `<id>` (job `<jobId>`)` listing.
+- `content`: `` Spawned agent `<id>` (job `<jobId>`). The result will be delivered when it yields. ... `` plus a coordination hint (`hub` DM when messaging is enabled, otherwise `hub` job control). A batch call instead returns `` Spawned N background agents using <agent types>. ... `` (the deduped per-item agent types, comma-joined) with a per-agent `- `<id>` (job `<jobId>`)` listing.
 - `details`: `{ projectAgentsDir, results, totalDurationMs, progress: [<AgentProgress per spawn>], async: { state, jobId, type: "task" } }`. The call keeps one shared `progress[]` snapshot; `async.jobId` is the first started job and `async.state` aggregates over the async spawns ("running" until every job settles, "failed" if any spawn failed) — jobs that settled before the call returned are already reflected. A mixed call's `results` carries the blocking spawns' inline `SingleResult`s (pure background calls return `results: []`).
-- Live progress keeps streaming into the same tool block via `onUpdate(...)`; each final result arrives later as an async-result injection into the parent conversation. The delivery text appends a follow-up hint: `` <id> is now idle — message it via `irc` to follow up; transcript at history://<id> `` (aborted variant points at the transcript only).
+- Live progress keeps streaming into the same tool block via `onUpdate(...)`; each final result arrives later as an async-result injection into the parent conversation. The delivery text appends a follow-up hint: `` <id> is now idle — message it via `hub` to follow up; transcript at history://<id> `` (aborted variant points at the transcript only).
 
 Settled response (`async.enabled=false`, no job manager, every item's agent `blocking: true`, or async job body):
 - `content`: summary rendered from `packages/coding-agent/src/prompts/tools/task-summary.md` with a preview capped at 5000 chars; `agent://<id>` holds the full output. A sync batch concatenates the per-spawn summaries.
@@ -64,7 +64,7 @@ Settled response (`async.enabled=false`, no job manager, every item's agent `blo
 - status: `exitCode`, optional `error`, optional `aborted`, optional `abortReason`, optional `retryFailure`
 - output: `output`, `stderr`, `truncated`, `durationMs`, `tokens`, `requests`, optional `contextTokens`/`contextWindow`
 - artifact metadata: `outputPath?`, `patchPath?`, `branchName?`, `nestedPatches?`, `outputMeta?`
-- extracted tool data: `extractedToolData?` from registered subprocess tool handlers such as `yield` and `report_finding`
+- extracted tool data: `extractedToolData?` from registered subprocess tool handlers such as `yield`
 
 Artifacts and side channels:
 - Every subagent with an artifacts dir writes `<id>.md`; `agent://<id>` resolves to that file.
@@ -90,13 +90,13 @@ Artifacts and side channels:
 10. Artifacts dir comes from the parent session file when available, otherwise a temp dir. When the session is executing an approved plan, the plan reference is handed to the subagent.
 11. Non-isolated spawns call `runSubprocess(...)` directly with parent cwd; isolated spawns run inside the isolation workspace, then commit to a branch (`mergeMode === "branch"`) or capture a patch, and always clean up the workspace.
 12. `runSubprocess(...)` creates a child agent session with an isolated settings snapshot (forcing `async.enabled = false` and `bash.autoBackground.enabled = false` — subagents are internally synchronous), child `agentId` equal to the allocated id, child internal URL router/`AgentOutputManager`, output schema, the shared `context` (batch calls) in the system prompt's `CONTEXT` section, and the IRC peer roster in the system prompt.
-13. Child tool availability: explicit `agent.tools` if provided; auto-add `task` when the agent has `spawns` and depth allows; strip `task` at `task.maxRecursionDepth`; ensure `irc` is present in explicit tool lists; expand `exec` to `eval` + `bash`; strip parent-owned `todo` — unless the spawn is prewalk-armed, whose plan nudge + todo gate need the child to commit its own todo list before the model hand-off.
-14. The child must finish through the hidden `yield` tool; up to 3 reminder prompts, the last forcing `toolChoice = yield` when supported. `finalizeSubprocessOutput(...)` reconciles raw text, `yield` payloads, structured schemas, `report_finding` data, and abort states.
+13. Child tool availability: explicit `agent.tools` if provided; auto-add `task` when the agent has `spawns` and depth allows; strip `task` at `task.maxRecursionDepth`; ensure `hub` is present in explicit tool lists; expand `exec` to `eval` + `bash`; strip parent-owned `todo` — unless the spawn is prewalk-armed, whose plan nudge + todo gate need the child to commit its own todo list before the model hand-off.
+14. The child must finish through the hidden `yield` tool; up to 3 reminder prompts, the last forcing `toolChoice = yield` when supported. `finalizeSubprocessOutput(...)` reconciles raw text, `yield` payloads, structured schemas, and abort states.
 15. End-of-run lifecycle (keep-alive, in `runSubprocess`'s finalizer):
     - hard abort (caller signal / wall-clock / budget) → registry status `aborted`, session disposed — terminal;
     - isolated run → status `parked` without a reviver (workspace is merged + cleaned, so the session is not revivable; transcript stays readable via `history://`), then session disposed and detached;
     - everything else (success and failure alike) → status `idle` with the live session attached, and `AgentLifecycleManager.global().adopt(id, { idleTtlMs, revive })` arms the park timer. The reviver reopens the session JSONL (park closed the writer, so the single-writer lock is taken cleanly).
-16. Lifecycle thereafter: `idle` agents are parked after `task.agentIdleTtlMs` (session disposed; `AgentRef` + session file retained); messaging (`irc`) or the Agent Hub revives them back to `idle`. `"Main"` is never parked.
+16. Lifecycle thereafter: `idle` agents are parked after `task.agentIdleTtlMs` (session disposed; `AgentRef` + session file retained); messaging (`hub`) or the Agent Hub revives them back to `idle`. `"Main"` is never parked.
 
 ## Modes / Variants
 - Execution mode
@@ -127,7 +127,7 @@ Artifacts and side channels:
   - Allocates session-scoped output ids through `AgentOutputManager` so `agent://` stays unique across invocations.
   - Shares the parent `local://` root and `ArtifactManager` with subagents.
 - Background work / cancellation
-  - `job cancel` (or parent tool-call abort) cancels background jobs; parent tool-call abort cancels sync runs through the call signal. A hard-aborted run lands `aborted` and is torn down.
+  - `hub` cancel (or parent tool-call abort) cancels background jobs; parent tool-call abort cancels sync runs through the call signal. A hard-aborted run lands `aborted` and is torn down.
   - Missing-`yield` recovery sends up to three internal reminder prompts to the child session.
 
 ## Limits & Caps
@@ -157,8 +157,8 @@ Artifacts and side channels:
 ## Notes
 - Parallelism is parallel `task` calls in one assistant message — or, with `task.batch`, a `tasks[]` batch in one call; either way the session-scoped semaphore bounds the fan-out. With `async.enabled=true`, each spawn is an independent background job.
 - Shared background convention without batch mode: write it once to a `local://` file and reference that path in each spawn's `task` — subagents share the parent's `local://` root. With `task.batch`, the required `context` parameter carries the shared background directly into each spawn's system prompt.
-- Prefer messaging an existing agent (`irc`) over a fresh spawn for follow-up work: it already holds the relevant context. `irc` op:"list" shows idle/parked candidates; messaging a parked agent revives it. `history://<id>` shows what an agent has done.
-- `irc` availability is derived, not configured (`isIrcEnabled` in `packages/coding-agent/src/tools/irc.ts`): it exists exactly when there is someone to message — the session can spawn subagents, or it is a subagent itself. Messaging is the only follow-up path to a finished subagent, so task without irc would strand idle agents.
+- Prefer messaging an existing agent (`hub`) over a fresh spawn for follow-up work: it already holds the relevant context. `hub` op:"list" shows idle/parked candidates; messaging a parked agent revives it. `history://<id>` shows what an agent has done.
+- Peer-messaging availability is derived, not configured (`isIrcEnabled` in `packages/coding-agent/src/tools/hub/messaging.ts`): it exists exactly when there is someone to message — the session can spawn subagents, or it is a subagent itself. Messaging is the only follow-up path to a finished subagent, so task without hub messaging would strand idle agents.
 - Subagents are internally synchronous: the executor forces `async.enabled = false` and `bash.autoBackground.enabled = false` in the child settings snapshot, so there are no fire-and-forget grandchildren.
 - Agent discovery precedence is first-wins by exact name: project `.omp` agents dir before the user `.omp` dir (task agents only load from `.omp` roots; `.claude`/`.codex`/`.gemini` agent dirs are skipped), Claude plugin agent dirs after config dirs, bundled agents last. Create-time discovery is memoized per cwd for the prompt description; execution-time discovery stays fresh.
 - Child sessions do not inherit conversation history. Built-in carry-over is the workspace tree/skills/context files, the shared `local://` root, and the approved-plan reference when one exists.
diff --git a/packages/agent/CHANGELOG.md b/packages/agent/CHANGELOG.md
index 6f84e20f9..c3afd4cc5 100644
--- a/packages/agent/CHANGELOG.md
+++ b/packages/agent/CHANGELOG.md
@@ -2,6 +2,33 @@
 
 ## [Unreleased]
 
+### Breaking Changes
+
+- Tool discovery (`search-tool-bm25`) and discovery mode settings removed
+- Plan approval workflow changed: `resolve { action: "apply", extra: { title } }` → write slug to `xd://propose`
+- `irc`, `job`, `launch` tools replaced by `hub` with unified API
+
+### Added
+
+- Added `xd://` virtual device protocol for mounting tools as URLs readable/writable via read/write tools
+- Added `hub` tool consolidating agent peer messaging, background job control, and supervised long-running processes (replacing `irc`, `job`, and `launch`)
+- Added `tools.xdev` setting to enable xd:// device mounting (default: true)
+- Added `edit.enforceSeenLines` setting for opt-in seen-line guard rejecting edits on lines not fully displayed (default: false)
+- Added `ToolLoadMode` type clarifying "essential" vs "discoverable" tool presentation
+- Added an optional `satisfies` predicate to `SoftToolRequirement`: compliance can now require a specific invocation shape (e.g. a `write` targeting a virtual device path) instead of any call to `toolName`; escalation still forces `toolName`.
+
+### Changed
+
+- Plan approval now uses `xd://propose` write instead of `resolve` tool action
+- Tool discovery system removed; `search-tool-bm25` tool no longer available
+- Tool loading behavior: discoverable tools now mounted under xd:// or surfaced via BM25 search instead of staying top-level
+
+### Removed
+
+- Removed `resolve` tool; plan approval and preview actions now use xd:// writes
+- Removed `irc`, `job`, and `launch` tools (consolidated into `hub`)
+- Removed tool discovery settings: `tools.discoveryMode`, `tools.essentialOverride`, `mcp.discoveryMode`, `mcp.discoveryDefaultServers`
+
 ## [16.5.2] - 2026-07-14
 
 ### Fixed
diff --git a/packages/agent/src/agent-loop.ts b/packages/agent/src/agent-loop.ts
index 937437a74..a2400e44e 100644
--- a/packages/agent/src/agent-loop.ts
+++ b/packages/agent/src/agent-loop.ts
@@ -67,6 +67,7 @@ import type {
 	AgentToolResult,
 	AgentTurnEndContext,
 	AsideMessage,
+	SoftToolRequirement,
 	SteeringInterruptSource,
 	SteeringQueueState,
 	StreamFn,
@@ -803,6 +804,7 @@ async function runLoopBody(
 		// getToolChoice is never advanced twice; the flag resets at the message boundary.
 		let hostToolChoice: ToolChoice | undefined;
 		let softRequiredTool: string | undefined;
+		let softSatisfies: SoftToolRequirement["satisfies"];
 		let directiveResolvedForTurn = false;
 
 		// Outer loop: continues when queued follow-up messages arrive after agent would stop
@@ -861,6 +863,7 @@ async function runLoopBody(
 					const softReq = isSoftToolRequirement(directive) ? directive : undefined;
 					hostToolChoice = directive === undefined || isSoftToolRequirement(directive) ? undefined : directive;
 					softRequiredTool = softReq?.toolName;
+					softSatisfies = softReq?.satisfies;
 					if (softReq !== undefined) {
 						if (softReq.id !== softRequirementId) {
 							softRequirementId = softReq.id;
@@ -1024,7 +1027,7 @@ async function runLoopBody(
 				const calledOnlyRequiredTool =
 					softRequiredTool !== undefined &&
 					toolCalls.length > 0 &&
-					toolCalls.every(toolCall => toolCall.name === softRequiredTool);
+					toolCalls.every(toolCall => softSatisfies?.(toolCall) ?? toolCall.name === softRequiredTool);
 				const softGateActive =
 					softRequiredTool !== undefined && !hardToolChoiceBlocks(config.toolChoice, softRequiredTool);
 				const softNonCompliant = softGateActive && !calledOnlyRequiredTool;
diff --git a/packages/agent/src/compaction/branch-summarization.ts b/packages/agent/src/compaction/branch-summarization.ts
index ec1e3bb73..341d31ec7 100644
--- a/packages/agent/src/compaction/branch-summarization.ts
+++ b/packages/agent/src/compaction/branch-summarization.ts
@@ -200,7 +200,6 @@ function getMessageFromEntry(entry: SessionEntry): AgentMessage | undefined {
 		case "label":
 		case "service_tier_change":
 		case "ttsr_injection":
-		case "mcp_tool_selection":
 		case "session_init":
 		case "mode_change":
 			return undefined;
diff --git a/packages/agent/src/compaction/entries.ts b/packages/agent/src/compaction/entries.ts
index a3735805b..3f7ebb51e 100644
--- a/packages/agent/src/compaction/entries.ts
+++ b/packages/agent/src/compaction/entries.ts
@@ -97,12 +97,6 @@ export interface TtsrInjectionEntry extends SessionEntryBase {
 	injectedRules: string[];
 }
 
-export interface MCPToolSelectionEntry extends SessionEntryBase {
-	type: "mcp_tool_selection";
-	/** MCP tool names selected for visibility in discovery mode. */
-	selectedToolNames: string[];
-}
-
 export interface SessionInitEntry extends SessionEntryBase {
 	type: "session_init";
 	/** Full system prompt sent to the model */
@@ -137,7 +131,6 @@ export type SessionEntry =
 	| LabelEntry
 	| TitleChangeEntry
 	| TtsrInjectionEntry
-	| MCPToolSelectionEntry
 	| SessionInitEntry
 	| ModeChangeEntry
 	| CustomCompactionSessionEntries[keyof CustomCompactionSessionEntries];
diff --git a/packages/agent/src/types.ts b/packages/agent/src/types.ts
index 30234b352..5119d38c2 100644
--- a/packages/agent/src/types.ts
+++ b/packages/agent/src/types.ts
@@ -68,6 +68,13 @@ export interface SoftToolRequirement {
 	id: string;
 	/** Tool that must be called before the loop runs other tools or yields. */
 	toolName: string;
+	/**
+	 * Per-call compliance check: a turn satisfies the requirement only when every
+	 * tool call passes. Defaults to `name === toolName`. Lets a host demand a
+	 * specific invocation shape (e.g. `write` targeting a virtual device path)
+	 * instead of any call to `toolName`. Escalation still forces `toolName`.
+	 */
+	satisfies?(toolCall: { name: string; arguments?: Record<string, unknown> }): boolean;
 	/** Host-owned reminder messages, injected once per `id` activation. */
 	reminder: AgentMessage[];
 }
@@ -587,6 +594,17 @@ export interface RenderResultOptions {
 /** Capability tier a tool exercises. Determines which approval modes auto-approve it. */
 export type ToolTier = "read" | "write" | "exec";
 
+/**
+ * How an enabled tool is presented to the model. `"essential"` tools are exposed
+ * as normal top-level tools. `"discoverable"` tools are removed from the top-level
+ * schema and either mounted under `xd://` device URLs (when that transport is
+ * active) or surfaced through BM25 tool search — keeping their schemas off every
+ * request. Selection (settings, `hidden`, `defaultInactive`, explicit `--tools`,
+ * provider availability) decides whether a tool is enabled; `loadMode` only
+ * decides how an enabled tool is presented.
+ */
+export type ToolLoadMode = "essential" | "discoverable";
+
 /**
  * Per-tool approval declaration.
  * - bare tier ("read" / "write" / "exec") — static classification.
@@ -625,8 +643,8 @@ export interface AgentTool<TParameters extends TSchema = TSchema, TDetails = any
 	hidden?: boolean;
 	/** If true, tool can stage a pending action that requires explicit resolution via the resolve tool. */
 	deferrable?: boolean;
-	/** Built-in tool loading behavior. "essential" loads initially; "discoverable" can be activated by tool search. */
-	loadMode?: "essential" | "discoverable";
+	/** How an enabled tool is presented. See {@link ToolLoadMode}. Omitted is treated as `"essential"` for built-ins; custom-tool adapters normalize omission to `"discoverable"`. */
+	loadMode?: ToolLoadMode;
 	/** Short one-line summary used for tool discovery indexes. */
 	summary?: string;
 	/**
diff --git a/packages/agent/test/soft-tool-requirement.test.ts b/packages/agent/test/soft-tool-requirement.test.ts
index c52550918..65e3e2261 100644
--- a/packages/agent/test/soft-tool-requirement.test.ts
+++ b/packages/agent/test/soft-tool-requirement.test.ts
@@ -134,6 +134,64 @@ describe("agentLoop soft tool requirement", () => {
 		expect(peekResult).toBeDefined();
 	});
 
+	it("uses the satisfies predicate over bare name matching for compliance", async () => {
+		let pendingPreview = true;
+		const writeRuns: string[] = [];
+		const reminder = createUserMessage("<system-reminder>Write the resolution to /xdev/resolve.</system-reminder>");
+		const writeSchema = type({ path: "string" });
+		const writeTool: AgentTool<typeof writeSchema, Record<string, never>> = {
+			name: "write",
+			label: "Write",
+			description: "Write a file or device",
+			parameters: writeSchema,
+			async execute(_id, args) {
+				writeRuns.push(args.path);
+				if (args.path === "/xdev/resolve") pendingPreview = false;
+				return { content: [{ type: "text", text: "written" }], details: {} };
+			},
+		};
+		const getToolChoice = (): SoftToolRequirement | undefined =>
+			pendingPreview
+				? {
+						soft: true,
+						id: "preview-1",
+						toolName: "write",
+						satisfies: toolCall => toolCall.name === "write" && toolCall.arguments?.path === "/xdev/resolve",
+						reminder: [reminder],
+					}
+				: undefined;
+		const context: AgentContext = { systemPrompt: ["sys"], messages: [], tools: [writeTool] };
+		const mock = createMockModel({
+			responses: [
+				// Turn 1: right tool name, wrong target — the predicate rejects it.
+				{ content: [{ type: "toolCall", id: "w1", name: "write", arguments: { path: "/tmp/out.md" } }] },
+				// Turn 2: forced to write; this call satisfies the predicate.
+				{ content: [{ type: "toolCall", id: "w2", name: "write", arguments: { path: "/xdev/resolve" } }] },
+				{ content: ["done"] },
+			],
+		});
+		const config: AgentLoopConfig = {
+			model: mock.model,
+			convertToLlm: identityConverter,
+			getToolChoice,
+		};
+
+		const stream = agentLoop([createUserMessage("go")], context, config, undefined, mock.stream);
+		for await (const _ of stream) {
+			// drain
+		}
+		const messages = await stream.result();
+
+		// The non-satisfying write was skipped, not executed; only the device write ran.
+		expect(writeRuns).toEqual(["/xdev/resolve"]);
+		// Escalation still forces the requirement's toolName.
+		expect(mock.calls[0]?.options?.toolChoice).toBeUndefined();
+		expect(mock.calls[1]?.options?.toolChoice).toEqual({ type: "tool", name: "write" });
+		// The skipped write call still produced a paired tool result (API pairing).
+		const skipped = messages.find(m => m.role === "toolResult" && m.toolCallId === "w1");
+		expect(skipped).toBeDefined();
+	});
+
 	it("does not yield while the requirement is unmet — escalates after a bare-text turn", async () => {
 		const h = makeSoftResolveHarness();
 		const context: AgentContext = { systemPrompt: ["sys"], messages: [], tools: h.tools };
diff --git a/packages/coding-agent/CHANGELOG.md b/packages/coding-agent/CHANGELOG.md
index b9aa77227..e2ba228a2 100644
--- a/packages/coding-agent/CHANGELOG.md
+++ b/packages/coding-agent/CHANGELOG.md
@@ -2,22 +2,42 @@
 
 ## [Unreleased]
 
+### Breaking Changes
+
+- Merged the `irc`, `job`, and `launch` tools into a single `hub` tool (`loadMode: "essential"`). Messaging keeps its op names (`send`/`inbox`/`list`); job control maps `{poll}` → `op:"wait"` + `ids`, `{cancel}` → `op:"cancel"` + `ids`, and `{list:true}` → `op:"jobs"`; process supervision keeps `start`/`logs`/`stop`/`restart`/`describe` with the broker's `list` renamed to `op:"ps"`, and `send`/`wait` route to a process when they carry `name`. The unified `wait` races watched background jobs against incoming peer messages and returns on the first event, replacing the old `irc wait` / `job poll` split. TUI and collab-web rendering are unchanged per op family. SDK: `IrcTool`, `JobTool`, `LaunchTool`, `IrcDetails`, and `JobToolDetails` are removed; use `HubTool`, `CoordinationDetails`, `LaunchToolDetails`, and `hubToolRenderer` from `tools/hub` (`isIrcEnabled`, `isWaitingPollDetails`, and `createIrcMessageCard` moved there). The default `model.toolCallLoopGuard.exemptTools` is now `["hub"]`.
+- Removed the hidden `resolve` tool. Staged actions now finalize through three plain-text resolution devices: `xd://resolve` (apply preview), `xd://reject` (discard preview), and `xd://propose` (submit a plan slug/title for approval). The `write` tool is auto-included whenever a deferrable tool is present (`createTools`) or plan mode is enabled (`createAgentSession`), replacing the auto-included `resolve` tool. SDK: `ResolveTool` and `HIDDEN_TOOLS.resolve` are removed; use `dispatchResolutionDevice()` / `queueResolveHandler()` from `tools/resolve`. Plan-mode prompts and the preview reminder now teach the device-write call shapes when they become relevant.
+- Unified tool presentation on `loadMode` (`essential` | `discoverable`), replacing the custom-tool `xdev?: boolean` opt-out. Custom, extension, MCP, RPC host, image-generation, and TTS tools now default to `discoverable` and mount under `xd://` when enabled (set `loadMode: "essential"` to stay top-level). `generate_image`/`tts`/MCP tools are exposed as `xd://` devices in a default session instead of shipping their schemas top-level.
+- Removed the BM25 tool-discovery system: the `search_tool_bm25` tool, the `tools.discoveryMode` / `mcp.discoveryMode` / `mcp.discoveryDefaultServers` settings, and per-tool MCP selection. `xd://` is now the sole transport for discoverable tools; every connected MCP tool is enabled and mounted under `xd://`. SDK: `search_tool_bm25`, the `tool-discovery` module, and the `AgentSession` discovery/MCP-selection methods (`getDiscoverableTools`, `activateDiscoveredTools`, `isMCPDiscoveryEnabled`, …) are removed.
+
 ### Added
 
+- Added the `edit.enforceSeenLines` setting (default off) to gate the hashline seen-line guard. When off, hashline tags validate on content hash alone and any anchor into the tagged content applies; when on, edits anchored on lines a prior `read`/`grep` never displayed are rejected.
 - Added per-agent prewalk for subagents: a `prewalk` frontmatter field (`true` = hand off to the default prewalk target, a string = custom target model pattern) and a `task.agentPrewalk` settings override toggled per agent from the `/agents` dashboard with `P`. The bundled generic `task` agent ships with prewalk enabled by default (skipped when the target resolves to the subagent's own starting model, and never armed for plan-mode spawns). Prewalk-armed subagents keep the normally parent-owned `todo` tool so the plan-nudge → todo → hand-off flow works, and the prewalk todo gate now keys on the active tool set instead of the registry so a deactivated todo tool can no longer stall the switch.
+- Added `xd://` virtual tool devices (setting `tools.xdev`, default on): built-ins declaring `loadMode: "discoverable"` (browser, debug, lsp, ast_grep/ast_edit, github, web_search, ...) are unmounted from the request's tools array entirely and driven through the tools the model already has: `read xd://` lists mounted devices, `read xd://<tool>` returns docs + JSON schema, and `write xd://<tool>` with a JSON args object as content executes the tool. Args validate against the mounted tool's real schema (returned on mismatch), and the tools array (and prompt-cache prefix) never changes shape when devices mount or unmount mid-session. `todo`, `ask`, and `grep` stay top-level for their harness integrations; `/tools` lists mounted devices; and `xd://` writes render with the mounted tool's own TUI renderer — streamed call previews draw nothing until the path is provably not an `xd://` device, then forward the incrementally decoded JSON content as live inner args. Explicit `--tools read,...,xdev` lists opt lean sets into the same mounting; `tools.discoveryMode: "all"` takes precedence when active. Full docs + JSON schema for every mounted device are inlined into the system prompt's `xd://` section, so no discovery `read` is required before first use; `read xd://<tool>` remains available for on-demand re-fetch.
 
 ### Changed
 
+- Made the hashline seen-line guard opt-in and off by default (see `edit.enforceSeenLines`), and stopped excluding column-clipped (>512-char) lines from a snapshot's seen set: a displayed line now counts as seen even when its display was column-truncated, so single-line edits on long lines found via `read`/`grep` apply without a separate full-width re-read.
 - Changed the default `astGrep.enabled` setting to `false`
 - Batched todo operations with real tool calls to prevent solo todo turns and extra round trips
+- Changed every bundled TTSR rule to warn without interrupting generation.
+- Renamed the system prompt's project-context section wrapper from `<context>` to `<repo-rules>` to stop it colliding with the `task` tool's `context` parameter under in-band XML tool dialects: models were closing `<parameter name="context">` with a stray `</context>` (primed by the ambient section tag) and emitting sibling params as bare `<tasks>` elements, so `tasks` arrived missing.
+- Rendered `read xd://` calls in the compact grouped read view instead of a full tool-execution card; other internal URLs (`skill://`, `agent://`, …) still render full so their resolved content stays visible.
+
+### Removed
+
+- Removed the `tools.essentialOverride` setting; essential tools are configured through device mounting
+- Removed `mcp_tool_selection` session message type; MCP tool discovery now uses device mounting instead
+- Removed the legacy `report_finding` tool; reviewer agents record findings through incremental `yield` sections (`type: ["findings"]`). SDK: `reportFindingTool` and `HIDDEN_TOOLS.report_finding` are removed (the `FindingDetails` shape and `parseFindingDetails` helper remain for reviewer rendering).
+- Removed the `ssh` agent tool (remote command execution). The `ssh://` read/write/search protocol, the `omp ssh` host-management CLI, and SSH host discovery are retained. SDK: `SshTool`/`loadSshTool`, the `ssh/ssh-executor` module, and `AgentSession.refreshSshTool` are removed.
+- Removed the `xdev` `--tools` token; the `xd://` device system now mounts only via the `tools.xdev` setting (the `--tools ...,xdev` opt-in and `HIDDEN_TOOLS.xdev` are gone).
 
-- Added the `edit.enforceSeenLines` setting (default off) to gate the hashline seen-line guard. When off, hashline tags validate on content hash alone and any anchor into the tagged content applies; when on, edits anchored on lines a prior `read`/`grep` never displayed are rejected.
 ### Fixed
 
 - Fixed Bash internal URLs remaining unresolved when used as unquoted arguments inside command substitutions ([#5535](https://github.com/can1357/oh-my-pi/issues/5535)).
+- Fixed `--tools` silently dropping hidden tool names (`xdev`, `yield`, ...); hidden built-ins are now addressable per the `hidden` tool contract.
 - Fixed the built-in `fd` printing `fd: Broken pipe (os error 32)` when a downstream pipeline reader exited early (e.g. `fd … | head`); it now exits silently with 141 (128+SIGPIPE), matching real fd.
 - Fixed prewalk repeatedly continuing after a bash-only task such as `commit` had already completed ([#5551](https://github.com/can1357/oh-my-pi/issues/5551)).
-- Made the hashline seen-line guard opt-in and off by default (see `edit.enforceSeenLines`), and stopped excluding column-clipped (>512-char) lines from a snapshot's seen set: a displayed line now counts as seen even when its display was column-truncated, so single-line edits on long lines found via `read`/`grep` apply without a separate full-width re-read.
 - Fixed the Bash tool hanging when in-process commands read process substitution operands such as `<(cmd)` ([#5557](https://github.com/can1357/oh-my-pi/issues/5557)).
 - Fixed `/share` and `/export` web views rendering inline Markdown inside list items as literal text ([#5567](https://github.com/can1357/oh-my-pi/issues/5567)).
 
diff --git a/packages/coding-agent/DEVELOPMENT.md b/packages/coding-agent/DEVELOPMENT.md
index 76b3c5bd5..ae4c3d2d4 100644
--- a/packages/coding-agent/DEVELOPMENT.md
+++ b/packages/coding-agent/DEVELOPMENT.md
@@ -71,7 +71,7 @@ Top-level entry modules: `cli.ts`, `main.ts`, `sdk.ts`, `index.ts` (SDK barrel),
 | `web/`, `exa/` | Fetch, browser automation, search providers, scrapers | [tools/web_search.md](../../docs/tools/web_search.md), [tools/browser.md](../../docs/tools/browser.md) |
 | `mcp/` | MCP transport / manager / loader / tool bridge | [mcp-config.md](../../docs/mcp-config.md), [mcp-runtime-lifecycle.md](../../docs/mcp-runtime-lifecycle.md) |
 | `extensibility/`, `slash-commands/` | Extensions, hooks, custom tools/commands, skills, plugins | [extensions.md](../../docs/extensions.md), [hooks.md](../../docs/hooks.md), [skills.md](../../docs/skills.md) |
-| `capability/`, `discovery/`, `tool-discovery/` | Capability registry + provider discovery modules | [extension-loading.md](../../docs/extension-loading.md), [context-files.md](../../docs/context-files.md) |
+| `capability/`, `discovery/` | Capability registry + provider discovery modules | [extension-loading.md](../../docs/extension-loading.md), [context-files.md](../../docs/context-files.md) |
 | `advisor/`, `autolearn/`, `autoresearch/` | Advisor/watchdog, managed skills, background research | [advisor-watchdog.md](../../docs/advisor-watchdog.md) |
 | `memories/`, `memory-backend/`, `mnemopi/`, `hindsight/` | Memory subsystems and backends | [memory.md](../../docs/memory.md), [mnemosyne-memory-backend.md](../../docs/mnemosyne-memory-backend.md) |
 | `internal-urls/` | Router + handlers (`agent://`, `docs://`, `rule://`, …) | [tree.md](../../docs/tree.md) |
@@ -107,7 +107,7 @@ Top-level entry modules: `cli.ts`, `main.ts`, `sdk.ts`, `index.ts` (SDK barrel),
 - Authoring + registry: [custom-tools.md](../../docs/custom-tools.md)
 - Output/artifacts: [blob-artifact-architecture.md](../../docs/blob-artifact-architecture.md)
 - Gating/approval: [approval-mode.md](../../docs/approval-mode.md), [resolve-tool-runtime.md](../../docs/resolve-tool-runtime.md)
-- Per-tool reference: [`docs/tools/`](../../docs/tools/) — `read`, `write`, `edit`, `ast-edit`, `ast-grep`, `search`, `search_tool_bm25`, `find`, `bash`, `eval`, `job`, `lsp`, `debug`, `task`, `irc`, `web_search`, `browser`, `github`, `ssh`, `inspect_image`, `ask`, `resolve`, `todo`, `recall`, `retain`, `reflect`, `checkpoint`, `rewind`
+- Per-tool reference: [`docs/tools/`](../../docs/tools/) — `read`, `write`, `edit`, `ast-edit`, `ast-grep`, `search`, `find`, `bash`, `eval`, `job`, `lsp`, `debug`, `task`, `irc`, `web_search`, `browser`, `github`, `ssh`, `inspect_image`, `ask`, `todo`, `recall`, `retain`, `reflect`, `checkpoint`, `rewind`
 
 ### Execution backends
 - [bash-tool-runtime.md](../../docs/bash-tool-runtime.md), [tools/bash.md](../../docs/tools/bash.md)
diff --git a/packages/coding-agent/examples/sdk/README.md b/packages/coding-agent/examples/sdk/README.md
index faf2f208b..aa0e90680 100644
--- a/packages/coding-agent/examples/sdk/README.md
+++ b/packages/coding-agent/examples/sdk/README.md
@@ -47,7 +47,6 @@ import {
 	BUILTIN_TOOLS,
 	HIDDEN_TOOLS,
 	createTools,
-	ResolveTool,
 } from "@oh-my-pi/pi-coding-agent";
 
 // Auth and models setup
@@ -108,22 +107,20 @@ await session.prompt("Hello");
 
 ## Resolve preview workflow (AST edit apply/discard)
 
-`ast_edit` now always returns a preview. To finalize, call hidden `resolve` with a required reason.
+`ast_edit` now always returns a preview. To finalize, write plain text to the appropriate virtual device with the `write` tool.
 
-- `action: "apply"` → commit pending preview changes
-- `action: "discard"` → drop pending preview changes
-- `reason: string` is required for both paths
+- `xd://resolve` → apply the pending preview; body = reason text
+- `xd://reject` → discard the pending preview; body = reason text
 
-`createAgentSession()` / `createTools()` include `resolve` automatically, even when filtering `toolNames`.
-If you are composing tools manually, use `HIDDEN_TOOLS.resolve` (or `ResolveTool`) and wire the same `pendingActionStore`.
+`createAgentSession()` / `createTools()` auto-include `write` whenever a deferrable tool (e.g. `ast_edit`) is present, so the devices are always reachable.
 
 ```typescript
-const tools = await createTools(toolSession, ["ast_edit"]); // resolve is auto-included
-const resolveTool = tools.find(t => t.name === "resolve") as ResolveTool;
+const tools = await createTools(toolSession, ["ast_edit"]); // write is auto-included
+const writeTool = tools.find(t => t.name === "write")!;
 
-await resolveTool.execute("call-1", {
-  action: "apply",
-  reason: "Preview matches expected replacements",
+await writeTool.execute("call-1", {
+  path: "xd://resolve",
+  content: "Preview matches expected replacements",
 });
 ```
 ## Options
diff --git a/packages/coding-agent/package.json b/packages/coding-agent/package.json
index 6bbcef8d7..67467a825 100644
--- a/packages/coding-agent/package.json
+++ b/packages/coding-agent/package.json
@@ -537,14 +537,18 @@
       "types": "./src/task/*.ts",
       "import": "./src/task/*.ts"
     },
-    "./tool-discovery/*": {
-      "types": "./src/tool-discovery/*.ts",
-      "import": "./src/tool-discovery/*.ts"
-    },
     "./tools": {
       "types": "./src/tools/index.ts",
       "import": "./src/tools/index.ts"
     },
+    "./tools/hub": {
+      "types": "./src/tools/hub/index.ts",
+      "import": "./src/tools/hub/index.ts"
+    },
+    "./tools/hub/*": {
+      "types": "./src/tools/hub/*.ts",
+      "import": "./src/tools/hub/*.ts"
+    },
     "./tools/*": {
       "types": "./src/tools/*.ts",
       "import": "./src/tools/*.ts"
diff --git a/packages/coding-agent/src/async/job-manager.ts b/packages/coding-agent/src/async/job-manager.ts
index bdb3cbdb7..761acb457 100644
--- a/packages/coding-agent/src/async/job-manager.ts
+++ b/packages/coding-agent/src/async/job-manager.ts
@@ -7,7 +7,7 @@ const DEFAULT_RETENTION_MS = 5 * 60 * 1000;
 const DEFAULT_MAX_RUNNING_JOBS = 15;
 
 /**
- * Adaptive ("smart") `job` poll-wait ladder (ms). A tight poll loop climbs
+ * Adaptive ("smart") `hub` poll-wait ladder (ms). A tight poll loop climbs
  * these rungs so each immediate re-poll backs off and stops spending turns on
  * "still running" frames; the floor (first rung) is the shortest wait and the
  * top rung is the longest a smart poll will ever block. Only used when
@@ -327,7 +327,7 @@ export class AsyncJobManager {
 	}
 
 	/**
-	 * Compute the next adaptive ("smart") wait (ms) for a blocking `job` poll by
+	 * Compute the next adaptive ("smart") wait (ms) for a blocking `hub` wait by
 	 * the given owner. Consecutive polls — those starting within
 	 * POLL_ESCALATION_RESET_MS of the previous poll returning — climb
 	 * POLL_WAIT_LADDER_MS so a tight wait loop backs off; a longer gap means the
diff --git a/packages/coding-agent/src/cli/args.ts b/packages/coding-agent/src/cli/args.ts
index 0a6fc149b..b4b0b8db7 100644
--- a/packages/coding-agent/src/cli/args.ts
+++ b/packages/coding-agent/src/cli/args.ts
@@ -4,7 +4,7 @@
 import { APP_NAME, CONFIG_DIR_NAME, logger } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { CLI_THINKING_LEVELS, type ConfiguredThinkingLevel, parseCliThinkingLevel } from "../thinking";
-import { BUILTIN_TOOL_NAMES, normalizeToolNames } from "../tools/builtin-names";
+import { BUILTIN_TOOL_NAMES, HIDDEN_TOOL_NAMES, normalizeToolNames } from "../tools/builtin-names";
 import {
 	OPTIONAL_FLAGS,
 	OPTIONAL_VALUE_FLAGS,
@@ -96,7 +96,7 @@ export interface Args {
 const PARSE_DEPS: ParseDeps = {
 	logger,
 	parseThinking: parseCliThinkingLevel,
-	builtinToolNames: BUILTIN_TOOL_NAMES,
+	builtinToolNames: [...BUILTIN_TOOL_NAMES, ...HIDDEN_TOOL_NAMES],
 	normalizeToolNames,
 	thinkingEfforts: CLI_THINKING_LEVELS,
 };
diff --git a/packages/coding-agent/src/cli/gallery-fixtures/agentic.ts b/packages/coding-agent/src/cli/gallery-fixtures/agentic.ts
index 15c576555..c50904901 100644
--- a/packages/coding-agent/src/cli/gallery-fixtures/agentic.ts
+++ b/packages/coding-agent/src/cli/gallery-fixtures/agentic.ts
@@ -1,7 +1,7 @@
-// Gallery fixtures for the agentic orchestration tools (task, irc, goal, job).
+// Gallery fixtures for the agentic orchestration tools (task, hub, goal).
 import type { Usage } from "@oh-my-pi/pi-ai";
 import type { TaskToolDetails } from "../../task/types";
-import type { IrcDetails } from "../../tools/irc";
+import type { HubDetails } from "../../tools/hub";
 import type { GalleryFixture } from "./types";
 
 /** Message/activity timestamps are offsets from load time so gallery ages stay plausible. */
@@ -142,8 +142,9 @@ export const agenticFixtures: Record<string, GalleryFixture> = {
 		},
 	},
 
-	irc: {
-		label: "IRC",
+	hub_send: {
+		label: "Hub send",
+		renderer: "hub",
 		// Streaming: recipient known; the message body still arriving.
 		streamingArgs: { op: "send", to: "AuthLoader", message: "Are you still touching" },
 		args: {
@@ -178,7 +179,7 @@ export const agenticFixtures: Record<string, GalleryFixture> = {
 					ts: FIXTURE_NOW - 5_000,
 					replyTo: "7181122334455667788",
 				},
-			} satisfies IrcDetails,
+			} satisfies HubDetails,
 		},
 		errorResult: {
 			isError: true,
@@ -193,14 +194,14 @@ export const agenticFixtures: Record<string, GalleryFixture> = {
 				from: "Main",
 				to: "RateLimiter",
 				receipts: [{ to: "RateLimiter", outcome: "failed", error: 'unknown agent "RateLimiter"' }],
-			} satisfies IrcDetails,
+			} satisfies HubDetails,
 		},
 	},
 
-	irc_wait: {
-		label: "IRC (wait)",
+	hub_wait: {
+		label: "Hub wait",
 		customRendered: true,
-		renderer: "irc",
+		renderer: "hub",
 		streamingArgs: { op: "wait", from: "AuthLoader" },
 		args: { op: "wait", from: "AuthLoader", timeoutMs: 60_000 },
 		result: {
@@ -220,14 +221,14 @@ export const agenticFixtures: Record<string, GalleryFixture> = {
 					body: "session-store rename is merged; auth.ts is yours.",
 					ts: FIXTURE_NOW - 30_000,
 				},
-			} satisfies IrcDetails,
+			} satisfies HubDetails,
 		},
 	},
 
-	irc_inbox: {
-		label: "IRC (inbox)",
+	hub_inbox: {
+		label: "Hub inbox",
 		customRendered: true,
-		renderer: "irc",
+		renderer: "hub",
 		streamingArgs: { op: "inbox" },
 		args: { op: "inbox", peek: true },
 		result: {
@@ -261,19 +262,19 @@ export const agenticFixtures: Record<string, GalleryFixture> = {
 						replyTo: "7181122334455667791",
 					},
 				],
-			} satisfies IrcDetails,
+			} satisfies HubDetails,
 		},
 		errorResult: {
 			isError: true,
 			content: [{ type: "text", text: "IRC inbox failed: message store unavailable." }],
-			details: { op: "inbox" } satisfies IrcDetails,
+			details: { op: "inbox" } satisfies HubDetails,
 		},
 	},
 
-	irc_list: {
-		label: "IRC (list)",
+	hub_list: {
+		label: "Hub peers",
 		customRendered: true,
-		renderer: "irc",
+		renderer: "hub",
 		streamingArgs: { op: "list" },
 		args: { op: "list" },
 		result: {
@@ -312,12 +313,12 @@ export const agenticFixtures: Record<string, GalleryFixture> = {
 						lastActivity: FIXTURE_NOW - 12 * 60_000,
 					},
 				],
-			} satisfies IrcDetails,
+			} satisfies HubDetails,
 		},
 		errorResult: {
 			isError: true,
 			content: [{ type: "text", text: "IRC list failed: agent hub is unavailable." }],
-			details: { op: "list" } satisfies IrcDetails,
+			details: { op: "list" } satisfies HubDetails,
 		},
 	},
 
@@ -360,14 +361,16 @@ export const agenticFixtures: Record<string, GalleryFixture> = {
 		},
 	},
 
-	job: {
-		label: "Job",
-		// Streaming: polling a single job id; the second id is still arriving.
-		streamingArgs: { poll: ["job_a1"] },
-		args: { poll: ["job_a1", "job_b2", "job_c3"] },
+	hub_jobs: {
+		label: "Hub jobs",
+		renderer: "hub",
+		// Streaming: waiting on a single job id; the second id is still arriving.
+		streamingArgs: { op: "wait", ids: ["job_a1"] },
+		args: { op: "wait", ids: ["job_a1", "job_b2", "job_c3"] },
 		result: {
 			content: [{ type: "text", text: "3 jobs settled." }],
 			details: {
+				op: "wait",
 				jobs: [
 					{
 						id: "job_a1",
@@ -400,6 +403,7 @@ export const agenticFixtures: Record<string, GalleryFixture> = {
 			isError: true,
 			content: [{ type: "text", text: "1 job failed." }],
 			details: {
+				op: "wait",
 				jobs: [
 					{
 						id: "job_d4",
diff --git a/packages/coding-agent/src/cli/gallery-fixtures/misc.ts b/packages/coding-agent/src/cli/gallery-fixtures/misc.ts
index 4860d01f2..37980e078 100644
--- a/packages/coding-agent/src/cli/gallery-fixtures/misc.ts
+++ b/packages/coding-agent/src/cli/gallery-fixtures/misc.ts
@@ -1,4 +1,4 @@
-/** Gallery fixtures for the ask / resolve / ssh / github / inspect_image tools. */
+/** Gallery fixtures for the ask / ssh / github / inspect_image tools. */
 import type { GalleryFixture } from "./types";
 
 export const miscFixtures: Record<string, GalleryFixture> = {
@@ -70,79 +70,6 @@ export const miscFixtures: Record<string, GalleryFixture> = {
 		},
 	},
 
-	resolve: {
-		label: "Resolve",
-		streamingArgs: {
-			action: "apply",
-		},
-		args: {
-			action: "apply",
-			reason: "Rename is mechanical and the staged diff matches the intended refactor.",
-			extra: { title: "rename-usecredentials-hook" },
-		},
-		result: {
-			content: [{ type: "text", text: "Applied pending ast_edit: 7 replacements across 3 files" }],
-			details: {
-				action: "apply",
-				reason: "Rename is mechanical and the staged diff matches the intended refactor.",
-				extra: { title: "rename-usecredentials-hook" },
-				sourceToolName: "ast_edit",
-				label: "ast_edit: 7 replacements across 3 files",
-			},
-		},
-		errorResult: {
-			content: [{ type: "text", text: "No pending action to resolve" }],
-			isError: true,
-			details: {
-				action: "apply",
-				reason: "Rename is mechanical and the staged diff matches the intended refactor.",
-				sourceToolName: "ast_edit",
-				label: "ast_edit: 7 replacements across 3 files",
-			},
-		},
-	},
-
-	ssh: {
-		label: "SSH",
-		streamingArgs: {
-			host: "deploy@web-01",
-			command: "systemctl status",
-		},
-		args: {
-			host: "deploy@web-01",
-			command: "systemctl status omp-api --no-pager | head -n 12",
-			cwd: "/srv/omp",
-			timeout: 60,
-		},
-		result: {
-			content: [
-				{
-					type: "text",
-					text: [
-						"● omp-api.service - Oh My Pi API",
-						"     Loaded: loaded (/etc/systemd/system/omp-api.service; enabled)",
-						"     Active: active (running) since Sat 2026-06-06 09:14:02 UTC; 3h 21min ago",
-						"   Main PID: 4812 (bun)",
-						"      Tasks: 17 (limit: 4915)",
-						"     Memory: 142.6M",
-						"        CPU: 38.214s",
-						"     CGroup: /system.slice/omp-api.service",
-						"             └─4812 /usr/local/bin/bun run dist/server.js",
-					].join("\n"),
-				},
-			],
-		},
-		errorResult: {
-			content: [
-				{
-					type: "text",
-					text: "ssh: connect to host web-01 port 22: Connection timed out",
-				},
-			],
-			isError: true,
-		},
-	},
-
 	github: {
 		label: "GitHub",
 		streamingArgs: {
diff --git a/packages/coding-agent/src/cli/gallery-fixtures/search.ts b/packages/coding-agent/src/cli/gallery-fixtures/search.ts
index 3789f3b43..8725e86c5 100644
--- a/packages/coding-agent/src/cli/gallery-fixtures/search.ts
+++ b/packages/coding-agent/src/cli/gallery-fixtures/search.ts
@@ -1,4 +1,4 @@
-/** Gallery fixtures for the search tools (grep, search_tool_bm25, ast_grep). */
+/** Gallery fixtures for the search tools (grep, ast_grep). */
 import type { GalleryFixture } from "./types";
 
 export const searchFixtures: Record<string, GalleryFixture> = {
@@ -75,84 +75,6 @@ export const searchFixtures: Record<string, GalleryFixture> = {
 		},
 	},
 
-	search_tool_bm25: {
-		label: "SearchTools",
-		streamingArgs: {
-			query: "read pdf and ext",
-		},
-		args: {
-			query: "read pdf and extract tables",
-			limit: 5,
-		},
-		result: {
-			content: [
-				{
-					type: "text",
-					text: JSON.stringify({
-						query: "read pdf and extract tables",
-						activated_tools: ["docling_extract_tables", "docling_convert", "pdf_read_text"],
-						match_count: 4,
-						total_tools: 142,
-					}),
-				},
-			],
-			details: {
-				query: "read pdf and extract tables",
-				limit: 5,
-				total_tools: 142,
-				activated_tools: ["docling_extract_tables", "docling_convert", "pdf_read_text"],
-				active_selected_tools: ["read", "grep", "edit", "bash"],
-				tools: [
-					{
-						name: "docling_extract_tables",
-						label: "Extract Tables",
-						description: "Extract tabular data from PDF documents into CSV or JSON rows.",
-						server_name: "docling",
-						mcp_tool_name: "extract_tables",
-						schema_keys: ["path", "pages", "format"],
-						score: 9.412037,
-					},
-					{
-						name: "docling_convert",
-						label: "Convert Document",
-						description: "Convert PDF, DOCX, or PPTX into structured Markdown with layout preserved.",
-						server_name: "docling",
-						mcp_tool_name: "convert",
-						schema_keys: ["path", "target", "ocr"],
-						score: 6.83102,
-					},
-					{
-						name: "pdf_read_text",
-						label: "Read PDF Text",
-						description: "Read raw text from a PDF, optionally scoped to a page range.",
-						server_name: "pdf-tools",
-						mcp_tool_name: "read_text",
-						schema_keys: ["path", "page_start", "page_end"],
-						score: 5.207884,
-					},
-					{
-						name: "tabula_scan",
-						label: "Scan Tables",
-						description: "Detect table bounding boxes on scanned PDF pages before extraction.",
-						server_name: "pdf-tools",
-						mcp_tool_name: "scan",
-						schema_keys: ["path", "dpi"],
-						score: 3.119556,
-					},
-				],
-			},
-		},
-		errorResult: {
-			content: [
-				{
-					type: "text",
-					text: "Tool discovery is disabled. Enable tools.discoveryMode or mcp.discoveryMode to use search_tool_bm25.",
-				},
-			],
-			isError: true,
-		},
-	},
-
 	ast_grep: {
 		label: "AST Grep",
 		streamingArgs: {
diff --git a/packages/coding-agent/src/cli/gallery-fixtures/shell.ts b/packages/coding-agent/src/cli/gallery-fixtures/shell.ts
index 1261b672c..f27bf1bad 100644
--- a/packages/coding-agent/src/cli/gallery-fixtures/shell.ts
+++ b/packages/coding-agent/src/cli/gallery-fixtures/shell.ts
@@ -56,8 +56,9 @@ export const shellFixtures: Record<string, GalleryFixture> = {
 		},
 	},
 
-	launch: {
-		label: "Launch",
+	hub_start: {
+		label: "Hub start",
+		renderer: "hub",
 		streamingArgs: { op: "start", name: "web" },
 		args: {
 			op: "start",
@@ -99,9 +100,9 @@ export const shellFixtures: Record<string, GalleryFixture> = {
 		},
 	},
 
-	launch_logs: {
-		label: "Launch",
-		renderer: "launch",
+	hub_logs: {
+		label: "Hub logs",
+		renderer: "hub",
 		args: { op: "logs", name: "comp-debug", lines: 100, follow: true, cursor: 233_512, timeout: 30 },
 		result: {
 			content: [
diff --git a/packages/coding-agent/src/cli/gallery-fixtures/types.ts b/packages/coding-agent/src/cli/gallery-fixtures/types.ts
index a17b9d53f..90990ad39 100644
--- a/packages/coding-agent/src/cli/gallery-fixtures/types.ts
+++ b/packages/coding-agent/src/cli/gallery-fixtures/types.ts
@@ -38,7 +38,7 @@ export interface GalleryFixture {
 	customRendered?: boolean;
 	/**
 	 * Renderer-registry key to use when the fixture key is a variant of a tool
-	 * (e.g. `irc_wait` → `irc`). Defaults to the fixture key.
+	 * (e.g. `hub_wait` → `hub`). Defaults to the fixture key.
 	 */
 	renderer?: string;
 	/**
diff --git a/packages/coding-agent/src/config/settings-schema.ts b/packages/coding-agent/src/config/settings-schema.ts
index 2999c127f..67be5cacc 100644
--- a/packages/coding-agent/src/config/settings-schema.ts
+++ b/packages/coding-agent/src/config/settings-schema.ts
@@ -285,7 +285,7 @@ const EMPTY_STRING_ARRAY: string[] = [];
 const EMPTY_STRING_RECORD: Record<string, string> = {};
 const EMPTY_NUMBER_RECORD: Record<string, number> = {};
 const DEFAULT_CYCLE_ORDER: string[] = ["smol", "default", "slow"];
-const DEFAULT_TOOL_CALL_LOOP_EXEMPT_TOOLS: string[] = ["job", "irc"];
+const DEFAULT_TOOL_CALL_LOOP_EXEMPT_TOOLS: string[] = ["hub"];
 const EMPTY_MODEL_TAGS_RECORD: ModelTagsSettings = {};
 const HINDSIGHT_RECALL_TYPES_DEFAULT: string[] = ["world", "experience"];
 export const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
@@ -333,22 +333,22 @@ export const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
 	},
 	{
 		pattern: "^\\s*nohup\\s+|(?<!&)\\&\\s*$",
-		tool: "launch",
+		tool: "hub",
 		message:
-			"Use the `launch` tool instead of nohup or background shell syntax so the process stays observable and managed.",
+			'Use the `hub` tool (`op:"start"`) instead of nohup or background shell syntax so the process stays observable and managed.',
 	},
 	{
 		pattern:
 			"^\\s*(?:(?:bun|npm|pnpm|yarn)\\s+(?:run\\s+)?(?:dev|start)(?:\\s|$)|(?:vite|next\\s+dev|nuxt\\s+dev|nodemon|lldb|gdb|tail\\s+-f)(?:\\s|$)|docker\\s+compose\\s+up(?!.*(?:\\s-d(?:\\s|$)|--detach))(?:\\s|$))",
-		tool: "launch",
+		tool: "hub",
 		message:
-			"Use the `launch` tool for services, watchers, and debuggers so other omp instances can observe and control them.",
+			'Use the `hub` tool (`op:"start"`) for services, watchers, and debuggers so other omp instances can observe and control them.',
 	},
 	{
 		pattern:
 			"^\\s*(?:(?:bun|npm|pnpm|yarn)\\s+(?:run\\s+)?\\S+|cargo\\s+watch|watchexec|pytest|vitest|jest|tsc)(?:.|\\n)*(?:--watch|-w)(?:\\s|$)",
-		tool: "launch",
-		message: "Use the `launch` tool for watch mode so its output, input, and lifecycle stay managed.",
+		tool: "hub",
+		message: 'Use the `hub` tool (`op:"start"`) for watch mode so its output, input, and lifecycle stay managed.',
 	},
 ];
 
@@ -724,7 +724,7 @@ export const SETTINGS_SCHEMA = {
 			group: "Output Limits",
 			label: "Output Column Cap",
 			description:
-				"Per-line byte cap for streaming tool outputs (bash, ssh, python, js eval) and `read`. Lines wider than this are ellipsis-truncated; remaining bytes up to the next newline are dropped. 0 disables.",
+				"Per-line byte cap for streaming tool outputs (bash, python, js eval) and `read`. Lines wider than this are ellipsis-truncated; remaining bytes up to the next newline are dropped. 0 disables.",
 			options: [
 				{ value: "0", label: "Off", description: "No per-line cap" },
 				{ value: "256", label: "256", description: "Tight" },
@@ -3425,7 +3425,7 @@ export const SETTINGS_SCHEMA = {
 					value: "write",
 					label: "Write",
 					description:
-						"Auto-approve read-only and write tools; require confirmation for exec tools such as bash, eval, browser, task, and ssh.",
+						"Auto-approve read-only and write tools; require confirmation for exec tools such as bash, eval, browser, and task.",
 				},
 				{
 					value: "yolo",
@@ -3621,7 +3621,8 @@ export const SETTINGS_SCHEMA = {
 			tab: "tools",
 			group: "Available Tools",
 			label: "Generate Image",
-			description: "Enable the generate_image tool for text-to-image generation and editing",
+			description:
+				"Enable the generate_image tool (text-to-image generation and editing). Exposed as an xd:// device when tools.xdev is on.",
 		},
 	},
 
@@ -3853,7 +3854,7 @@ export const SETTINGS_SCHEMA = {
 			group: "Execution",
 			label: "Max Poll Time",
 			description:
-				"How long the poll tool waits for background job updates before returning the current state. A fixed value waits that exact duration every time. `smart` adapts: it starts at 5s and lengthens with each back-to-back poll (up to 5m), then resets to 5s after about a minute without polling.",
+				"How long a `hub` wait watches background jobs before returning the current state. A fixed value waits that exact duration every time. `smart` adapts: it starts at 5s and lengthens with each back-to-back wait (up to 5m), then resets to 5s after about a minute without waiting.",
 			options: [
 				{ value: "5s", label: "5 seconds" },
 				{ value: "10s", label: "10 seconds" },
@@ -3872,7 +3873,8 @@ export const SETTINGS_SCHEMA = {
 			tab: "tools",
 			group: "Execution",
 			label: "IRC Timeout",
-			description: "Default timeout for irc wait (and send await:true) in milliseconds; 0 disables the timeout",
+			description:
+				"Default timeout for hub message waits (and send await:true) in milliseconds; 0 disables the timeout",
 			options: [
 				{ value: "0", label: "Disabled" },
 				{ value: "30000", label: "30 seconds" },
@@ -3888,29 +3890,15 @@ export const SETTINGS_SCHEMA = {
 		default: 60_000,
 	},
 
-	// Tool Discovery
-	"tools.discoveryMode": {
-		type: "enum",
-		values: ["auto", "off", "mcp-only", "all"] as const,
-		default: "auto",
+	"tools.xdev": {
+		type: "boolean",
+		default: true,
 		ui: {
 			tab: "tools",
 			group: "Discovery & MCP",
-			label: "Tool Discovery",
+			label: "xd:// Tools",
 			description:
-				"Hide tools behind a search tool to save tokens. 'auto' hides MCP tools once the tool set has more than 40 tools; 'mcp-only' always hides MCP tools; 'all' hides all non-essential built-ins too.",
-		},
-	},
-
-	"tools.essentialOverride": {
-		type: "array",
-		default: [] as string[],
-		ui: {
-			tab: "tools",
-			group: "Discovery & MCP",
-			label: "Essential Tools Override",
-			description:
-				"Override the always-loaded built-in tools (default: read, bash, edit, write, glob, eval). Leave empty to use defaults.",
+				"Mount rarely-used (discoverable) tools under xd:// device URLs driven via read/write instead of shipping their schemas on every request. Disable to expose every enabled tool top-level.",
 		},
 	},
 
@@ -3926,28 +3914,6 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
-	"mcp.discoveryMode": {
-		type: "boolean",
-		default: false,
-		ui: {
-			tab: "tools",
-			group: "Discovery & MCP",
-			label: "MCP Tool Discovery",
-			description: "Hide MCP tools by default and expose them through a tool discovery tool",
-		},
-	},
-
-	"mcp.discoveryDefaultServers": {
-		type: "array",
-		default: [] as string[],
-		ui: {
-			tab: "tools",
-			group: "Discovery & MCP",
-			label: "MCP Discovery Default Servers",
-			description: "Keep MCP tools from these servers visible while discovery mode hides other MCP tools",
-		},
-	},
-
 	"mcp.notifications": {
 		type: "boolean",
 		default: false,
diff --git a/packages/coding-agent/src/config/settings.ts b/packages/coding-agent/src/config/settings.ts
index cf13e271c..fdf661edb 100644
--- a/packages/coding-agent/src/config/settings.ts
+++ b/packages/coding-agent/src/config/settings.ts
@@ -32,7 +32,6 @@ import type { ModelRole } from "../config/model-roles";
 import { loadCapability } from "../discovery";
 import { isLightTheme, setAutoThemeMapping, setColorBlindMode, setSymbolPreset } from "../modes/theme/theme";
 import { AgentStorage } from "../session/agent-storage";
-import { normalizeToolName } from "../tools/builtin-names";
 import { type EditMode, normalizeEditMode } from "../utils/edit-mode";
 import { withFileLock } from "./file-lock";
 import {
@@ -1195,43 +1194,6 @@ export class Settings {
 			delete raw["search.contextAfter"];
 		}
 
-		// 3. Tool-name arrays use wire IDs too. Preserve user overrides across
-		// the rename without duplicating entries if they already added grep/glob.
-		const migrateToolNameList = (names: unknown): unknown => {
-			if (!Array.isArray(names)) return names;
-			const out: unknown[] = [];
-			const seen = new Set<string>();
-			for (const name of names) {
-				const migrated = typeof name === "string" ? normalizeToolName(name) : name;
-				if (typeof migrated === "string") {
-					if (seen.has(migrated)) continue;
-					seen.add(migrated);
-				}
-				out.push(migrated);
-			}
-			return out;
-		};
-		const ensureToolsObject = (): Record<string, unknown> => {
-			const current = raw.tools;
-			if (current && typeof current === "object" && !Array.isArray(current)) {
-				return current as Record<string, unknown>;
-			}
-			const created: Record<string, unknown> = {};
-			raw.tools = created;
-			return created;
-		};
-		const toolsObj = raw.tools as Record<string, unknown> | undefined;
-		if (toolsObj && "essentialOverride" in toolsObj) {
-			toolsObj.essentialOverride = migrateToolNameList(toolsObj.essentialOverride);
-		}
-		if ("tools.essentialOverride" in raw) {
-			const nestedToolsObj = ensureToolsObject();
-			if (!("essentialOverride" in nestedToolsObj)) {
-				nestedToolsObj.essentialOverride = migrateToolNameList(raw["tools.essentialOverride"]);
-			}
-			delete raw["tools.essentialOverride"];
-		}
-
 		// Also clean up any empty nested objects we might have created or left behind
 		if (raw.glob && typeof raw.glob === "object" && Object.keys(raw.glob).length === 0) {
 			delete raw.glob;
diff --git a/packages/coding-agent/src/extensibility/custom-tools/types.ts b/packages/coding-agent/src/extensibility/custom-tools/types.ts
index 7beb91624..3882a5924 100644
--- a/packages/coding-agent/src/extensibility/custom-tools/types.ts
+++ b/packages/coding-agent/src/extensibility/custom-tools/types.ts
@@ -9,6 +9,7 @@ import type {
 	AgentToolUpdateCallback,
 	ToolApproval,
 	ToolApprovalDecision,
+	ToolLoadMode,
 	ToolTier,
 } from "@oh-my-pi/pi-agent-core";
 import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
@@ -208,6 +209,8 @@ export interface CustomTool<TParams extends TSchema = TSchema, TDetails = any> {
 	parameters: TParams;
 	/** If true, tool is excluded unless explicitly listed in --tools or agent's tools field */
 	hidden?: boolean;
+	/** How this tool is presented when enabled. See {@link ToolLoadMode}. Custom tools default to `"discoverable"`; set `"essential"` to stay top-level. */
+	loadMode?: ToolLoadMode;
 	/** If true, tool may stage deferred changes that require explicit resolve/discard. */
 	deferrable?: boolean;
 	/** MCP server name for discovery/search metadata when this tool fronts an MCP server. */
diff --git a/packages/coding-agent/src/extensibility/custom-tools/wrapper.ts b/packages/coding-agent/src/extensibility/custom-tools/wrapper.ts
index 421b6851b..301e76082 100644
--- a/packages/coding-agent/src/extensibility/custom-tools/wrapper.ts
+++ b/packages/coding-agent/src/extensibility/custom-tools/wrapper.ts
@@ -1,7 +1,7 @@
 /**
  * CustomToolAdapter wraps CustomTool instances into AgentTool for use with the agent.
  */
-import type { AgentTool, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolUpdateCallback, ToolLoadMode } from "@oh-my-pi/pi-agent-core";
 import type { Static, TSchema } from "@oh-my-pi/pi-ai";
 import type { Theme } from "../../modes/theme/theme";
 import { applyToolProxy } from "../tool-proxy";
@@ -15,6 +15,7 @@ export class CustomToolAdapter<TParams extends TSchema = TSchema, TDetails = any
 	declare description: string;
 	declare parameters: TParams;
 	readonly strict: boolean | undefined;
+	readonly loadMode: ToolLoadMode;
 
 	constructor(
 		private tool: CustomTool<TParams, TDetails>,
@@ -22,6 +23,7 @@ export class CustomToolAdapter<TParams extends TSchema = TSchema, TDetails = any
 	) {
 		applyToolProxy(tool, this);
 		this.strict = tool.strict;
+		this.loadMode = tool.loadMode ?? "discoverable";
 	}
 
 	execute(
diff --git a/packages/coding-agent/src/extensibility/extensions/types.ts b/packages/coding-agent/src/extensibility/extensions/types.ts
index 551f50af0..e8b75fed8 100644
--- a/packages/coding-agent/src/extensibility/extensions/types.ts
+++ b/packages/coding-agent/src/extensibility/extensions/types.ts
@@ -13,6 +13,7 @@ import type {
 	AgentToolUpdateCallback,
 	ThinkingLevel,
 	ToolApproval,
+	ToolLoadMode,
 } from "@oh-my-pi/pi-agent-core";
 import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type {
@@ -517,6 +518,8 @@ export interface ToolDefinition<TParams extends TSchema = TSchema, TDetails = un
 	/** If true, tool is registered but not auto-included in the initial active set.
 	 *  The registering extension is responsible for activating/deactivating it via setActiveTools(). */
 	defaultInactive?: boolean;
+	/** How this tool is presented when enabled. See {@link ToolLoadMode}. Extension tools default to `"discoverable"`; set `"essential"` to stay top-level. */
+	loadMode?: ToolLoadMode;
 	/** If true, tool may stage deferred changes that require explicit resolve/discard. */
 	deferrable?: boolean;
 	/** Tool approval tier. Defaults to `"exec"` when omitted.
diff --git a/packages/coding-agent/src/extensibility/extensions/wrapper.ts b/packages/coding-agent/src/extensibility/extensions/wrapper.ts
index fd2d49ec0..32f740336 100644
--- a/packages/coding-agent/src/extensibility/extensions/wrapper.ts
+++ b/packages/coding-agent/src/extensibility/extensions/wrapper.ts
@@ -1,7 +1,13 @@
 /**
  * Tool wrappers for extensions.
  */
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type {
+	AgentTool,
+	AgentToolContext,
+	AgentToolResult,
+	AgentToolUpdateCallback,
+	ToolLoadMode,
+} from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Static, TextContent, TSchema } from "@oh-my-pi/pi-ai";
 import type { Settings } from "../../config/settings";
 import type { Theme } from "../../modes/theme/theme";
@@ -23,12 +29,14 @@ export class RegisteredToolAdapter implements AgentTool<any, any, any> {
 
 	renderCall?: (args: any, options: any, theme: any) => any;
 	renderResult?: (result: any, options: any, theme: any, args?: any) => any;
+	readonly loadMode: ToolLoadMode;
 
 	constructor(
 		private registeredTool: RegisteredTool,
 		private runner: ExtensionRunner,
 	) {
 		applyToolProxy(registeredTool.definition, this);
+		this.loadMode = registeredTool.definition.loadMode ?? "discoverable";
 
 		// Only define render methods when the underlying definition provides them.
 		// If these exist unconditionally on the prototype, ToolExecutionComponent
diff --git a/packages/coding-agent/src/internal-urls/index.ts b/packages/coding-agent/src/internal-urls/index.ts
index f91616f2e..99311f10c 100644
--- a/packages/coding-agent/src/internal-urls/index.ts
+++ b/packages/coding-agent/src/internal-urls/index.ts
@@ -1,6 +1,6 @@
 /**
  * Internal URL routing system for internal protocols like agent://, memory://,
- * skill://, mcp://, and local://.
+ * skill://, mcp://, local://, and xd://.
  *
  * One process-global `InternalUrlRouter` is shared across sessions. Handlers
  * are stateless; they pull whatever they need (active skills/rules, active
@@ -24,3 +24,4 @@ export * from "./skill-protocol";
 export * from "./ssh-protocol";
 export type * from "./types";
 export * from "./vault-protocol";
+export * from "./xd-protocol";
diff --git a/packages/coding-agent/src/internal-urls/router.ts b/packages/coding-agent/src/internal-urls/router.ts
index 935f63be7..041cda4f8 100644
--- a/packages/coding-agent/src/internal-urls/router.ts
+++ b/packages/coding-agent/src/internal-urls/router.ts
@@ -1,5 +1,5 @@
 /**
- * Internal URL router for internal protocols (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, `ssh://`, and `vault://`).
+ * Internal URL router for internal protocols (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, `ssh://`, `vault://`, and `xd://`).
  *
  * One process-global router with one handler per scheme. Access via
  * `InternalUrlRouter.instance()`. Handlers are stateless; per-session and
@@ -17,8 +17,16 @@ import { parseInternalUrl } from "./parse";
 import { RuleProtocolHandler } from "./rule-protocol";
 import { SkillProtocolHandler } from "./skill-protocol";
 import { SshProtocolHandler } from "./ssh-protocol";
-import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types";
+import type {
+	InternalResource,
+	InternalUrl,
+	ProtocolHandler,
+	ResolveContext,
+	UrlCompletion,
+	WriteContext,
+} from "./types";
 import { VaultProtocolHandler } from "./vault-protocol";
+import { XdProtocolHandler } from "./xd-protocol";
 
 export class InternalUrlRouter {
 	static #instance: InternalUrlRouter | undefined;
@@ -39,6 +47,7 @@ export class InternalUrlRouter {
 		this.register(new PrProtocolHandler());
 		this.register(new HistoryProtocolHandler());
 		this.register(new SshProtocolHandler());
+		this.register(new XdProtocolHandler());
 	}
 
 	/** Process-global router instance. */
@@ -89,19 +98,33 @@ export class InternalUrlRouter {
 		return handler.complete(query, context);
 	}
 
-	async resolve(input: string, context?: ResolveContext): Promise<InternalResource> {
+	#route(input: string): { parsed: InternalUrl; handler: ProtocolHandler } {
 		const parsed = parseInternalUrl(input);
 		const scheme = parsed.protocol.replace(/:$/, "").toLowerCase();
 		const handler = this.#handlers.get(scheme);
-
 		if (!handler) {
 			const available = Array.from(this.#handlers.keys())
-				.map(s => `${s}://`)
+				.map(candidate => `${candidate}://`)
 				.join(", ");
 			throw new Error(`Unknown protocol: ${scheme}://\nSupported: ${available || "none"}`);
 		}
+		return { parsed, handler };
+	}
 
-		const resource = await handler.resolve(parsed as InternalUrl, context);
+	/** Resolve an internal URL through its registered protocol handler. */
+	async resolve(input: string, context?: ResolveContext): Promise<InternalResource> {
+		const { parsed, handler } = this.#route(input);
+		const resource = await handler.resolve(parsed, context);
 		return { ...resource, immutable: resource.immutable ?? handler.immutable };
 	}
+
+	/** Write an internal URL through its registered protocol handler. */
+	async write(input: string, content: string, context?: WriteContext): Promise<void> {
+		const { parsed, handler } = this.#route(input);
+		if (!handler.write) {
+			const scheme = parsed.protocol.replace(/:$/, "").toLowerCase();
+			throw new Error(`${scheme}:// URLs are read-only for write; use the protocol-specific tool for mutations.`);
+		}
+		await handler.write(parsed, content, context);
+	}
 }
diff --git a/packages/coding-agent/src/internal-urls/types.ts b/packages/coding-agent/src/internal-urls/types.ts
index 59bcb311d..a1ae61f87 100644
--- a/packages/coding-agent/src/internal-urls/types.ts
+++ b/packages/coding-agent/src/internal-urls/types.ts
@@ -1,7 +1,7 @@
 /**
  * Types for the internal URL routing system.
  *
- * Internal URLs (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, `ssh://`, and `vault://`) are resolved by tools like read,
+ * Internal URLs (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, `ssh://`, `vault://`, and `xd://`) are resolved by tools like read,
  * providing access to agent outputs and server resources without exposing filesystem paths.
  */
 
@@ -100,6 +100,10 @@ export interface ResolveContext {
 	localProtocolOptions?: LocalProtocolOptions;
 	/** Calling session's loaded skills. Prefer this over process-global skill state. */
 	skills?: readonly Skill[];
+	/** Session-bound `xd://` documentation resolver. */
+	xd?: {
+		read(name: string | null): Promise<string>;
+	};
 	/**
 	 * When set, handlers that would otherwise materialize an expensive directory
 	 * listing (e.g. the ssh:// handler draining a full remote `ls`) instead return
@@ -131,10 +135,14 @@ export interface WriteContext {
 	signal?: AbortSignal;
 	/** Calling session's `local://` root mapping — see {@link ResolveContext.localProtocolOptions}. */
 	localProtocolOptions?: LocalProtocolOptions;
+	/** Session-bound `xd://` device dispatcher. */
+	xd?: {
+		write(name: string | null, content: string): Promise<void>;
+	};
 }
 
 /**
- * Handler for a specific internal URL scheme (e.g., agent://, memory://, skill://, mcp://).
+ * Handler for a specific internal URL scheme (e.g., agent://, memory://, skill://, xd://).
  */
 export interface ProtocolHandler {
 	/** The scheme this handler processes (without trailing ://) */
diff --git a/packages/coding-agent/src/internal-urls/xd-protocol.ts b/packages/coding-agent/src/internal-urls/xd-protocol.ts
new file mode 100644
index 000000000..7b8ae74ab
--- /dev/null
+++ b/packages/coding-agent/src/internal-urls/xd-protocol.ts
@@ -0,0 +1,46 @@
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, WriteContext } from "./types";
+
+/** Canonical prefix for virtual tool-device URLs. */
+export const XD_URL_PREFIX = "xd://";
+
+/**
+ * Parse an `xd://` URL into its device target.
+ * Returns `null` for other or malformed URLs and `name: null` for the root.
+ */
+export function parseXdUrl(input: string): { name: string | null } | null {
+	const trimmed = input.trim();
+	if (!trimmed.toLowerCase().startsWith(XD_URL_PREFIX)) return null;
+	const name = trimmed.slice(XD_URL_PREFIX.length);
+	if (name.length === 0) return { name: null };
+	if (/[/?#]/.test(name)) return null;
+	return { name };
+}
+
+/** Whether a streaming path prefix could still become an `xd://` URL. */
+export function couldBecomeXdUrl(partialPath: string): boolean {
+	if (partialPath.length <= XD_URL_PREFIX.length) {
+		return XD_URL_PREFIX.startsWith(partialPath.toLowerCase());
+	}
+	return partialPath.toLowerCase().startsWith(XD_URL_PREFIX);
+}
+
+/** Routes session-bound virtual tool devices through `xd://` URLs. */
+export class XdProtocolHandler implements ProtocolHandler {
+	readonly scheme = "xd";
+	readonly immutable = true;
+
+	async resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
+		const target = parseXdUrl(url.href);
+		if (!target) throw new Error(`Invalid xd:// URL: ${url.href}. Use xd:// or xd://<tool>.`);
+		if (!context?.xd) throw new Error("xd:// is not mounted in this session.");
+		const content = await context.xd.read(target.name);
+		return { url: url.href, content, contentType: "text/plain", size: Buffer.byteLength(content) };
+	}
+
+	async write(url: InternalUrl, content: string, context?: WriteContext): Promise<void> {
+		const target = parseXdUrl(url.href);
+		if (!target) throw new Error(`Invalid xd:// URL: ${url.href}. Use xd://<tool>.`);
+		if (!context?.xd) throw new Error("xd:// is not mounted in this session.");
+		await context.xd.write(target.name, content);
+	}
+}
diff --git a/packages/coding-agent/src/modes/acp/acp-agent.ts b/packages/coding-agent/src/modes/acp/acp-agent.ts
index 3bca86ddc..b4f78df9e 100644
--- a/packages/coding-agent/src/modes/acp/acp-agent.ts
+++ b/packages/coding-agent/src/modes/acp/acp-agent.ts
@@ -60,7 +60,7 @@ import { MCPManager } from "../../mcp/manager";
 import type { MCPServerConfig } from "../../mcp/types";
 import { loadAllExtensions } from "../../modes/components/extensions/state-manager";
 import { theme } from "../../modes/theme/theme";
-import { type PlanApprovalDetails, resolveApprovedPlan } from "../../plan-mode/approved-plan";
+import { normalizePlanTitle, type PlanApprovalDetails, resolveApprovedPlan } from "../../plan-mode/approved-plan";
 import type { AgentSession, AgentSessionEvent } from "../../session/agent-session";
 import { BlobStore, resolveImageDataSync } from "../../session/blob-store";
 import { isSilentAbort, SKILL_PROMPT_MESSAGE_TYPE, USER_INTERRUPT_LABEL } from "../../session/messages";
@@ -72,7 +72,6 @@ import { buildAvailableSlashCommands, toAcpAvailableCommands } from "../../slash
 import { DEFAULT_STT_MODEL_KEY, STT_MODEL_OPTIONS } from "../../stt/models";
 import { AUTO_THINKING, parseConfiguredThinkingLevel } from "../../thinking";
 import { normalizeLocalScheme } from "../../tools/path-utils";
-import { runResolveInvocation } from "../../tools/resolve";
 import { ToolError } from "../../tools/tool-errors";
 import {
 	DEFAULT_TTS_LOCAL_MODEL_KEY,
@@ -1641,93 +1640,90 @@ export class AcpAgent implements Agent {
 				workflow: previous?.workflow ?? "parallel",
 				reentry: previous !== undefined,
 			});
-			// Mirror `InteractiveMode.#enterPlanMode`: register the standing resolve
-			// handler that consumes `resolve { action: "apply" }` from plan-mode.
-			// Without this, the agent's resolve call falls through to the "No
-			// pending action to resolve" error (issue #1869).
-			session.setStandingResolveHandler?.(input => this.#runAcpPlanApprovalResolve(session, input));
+			// Mirror `InteractiveMode.#enterPlanMode`: register the plan-proposal
+			// handler that consumes `xd://propose` writes from plan mode. Without
+			// this, proposal dispatch falls through and plan mode has no approval
+			// path (issue #1869).
+			session.setPlanProposalHandler?.(title => this.#handleAcpPlanProposal(session, title));
 		} else {
-			session.setStandingResolveHandler?.(null);
+			session.setPlanProposalHandler?.(null);
 			session.setPlanModeState(undefined);
 		}
 	}
 
 	/**
-	 * Standing resolve handler installed while ACP plan mode is active. The agent
-	 * submits the finalized plan via `resolve { action: "apply", extra: { title } }`;
-	 * this handler validates the plan file, normalizes the title, asks the ACP
-	 * client to confirm (via `unstable_createElicitation` when supported), and on
-	 * approval renames the plan to `local://<title>.md`, exits plan mode, and
-	 * notifies the client of both mode surfaces so the agent regains full tools.
+	 * Plan-proposal handler installed while ACP plan mode is active. The agent
+	 * submits the finalized plan by writing its `<slug>`/title to
+	 * `xd://propose`; this handler validates the plan file, normalizes the
+	 * title, asks the ACP client to confirm (via `unstable_createElicitation`
+	 * when supported), and on approval keeps the chosen plan path, exits plan
+	 * mode, and notifies the client so the agent regains full tools.
 	 *
-	 * Mirrors `InteractiveMode.#runPlanApprovalResolve` for the parts the agent
-	 * sees (same `PlanApprovalDetails` shape, same source tool name `plan_approval`).
-	 * Clients without form-mode elicitation get an auto-approve so plan mode is
-	 * never stranded — the agent always has a way out.
+	 * Mirrors `InteractiveMode.#handlePlanProposal` for the parts the agent sees
+	 * (same `PlanApprovalDetails` shape). Clients without form-mode elicitation
+	 * get an auto-approve so plan mode is never stranded — the agent always has
+	 * a way out.
 	 */
-	#runAcpPlanApprovalResolve(session: AgentSession, input: unknown): Promise<AgentToolResult<unknown>> {
-		return runResolveInvocation(input as Parameters<typeof runResolveInvocation>[0], {
-			sourceToolName: "plan_approval",
-			label: "Plan ready for approval",
-			apply: async (_reason, extra) => {
-				const state = session.getPlanModeState();
-				if (!state?.enabled) {
-					throw new ToolError("Plan mode is not active.");
-				}
-				const { planFilePath, planContent, title } = await resolveApprovedPlan({
-					suppliedTitle: extra?.title,
-					statePlanFilePath: state.planFilePath,
-					readPlan: url => this.#readAcpPlanFile(session, url),
-					listPlanFiles: () => this.#listAcpLocalPlanFiles(session),
-				});
-				const approved = await this.#requestAcpPlanApprovalChoice(session.sessionId, title, planContent);
-				const details: PlanApprovalDetails = {
-					planFilePath,
-					title,
-					planExists: true,
-				};
-				if (!approved) {
-					// User chose to refine: leave plan mode active so the agent
-					// keeps the read-only toolset and can iterate on the plan file.
-					return {
-						content: [
-							{
-								type: "text" as const,
-								text: 'Plan refinement requested. Update the plan file, then call `resolve { action: "apply" }` again when ready.',
-							},
-						],
-						details,
-					};
-				}
-				// Approved. Set the plan reference so the next turn injects the plan
-				// content as context (the file keeps its agent-chosen name — no
-				// rename), then exit plan mode so the agent regains full tools.
-				session.setPlanReferencePath(planFilePath);
-				session.setStandingResolveHandler?.(null);
-				session.setPlanModeState(undefined);
-				try {
-					await this.#connection.sessionUpdate({
-						sessionId: session.sessionId,
-						update: this.#buildCurrentModeUpdate(session),
-					});
-					await this.#pushConfigOptionUpdateForSession(session);
-				} catch (error) {
-					logger.warn("Failed to emit mode updates after plan approval", {
-						sessionId: session.sessionId,
-						error,
-					});
-				}
-				return {
-					content: [
-						{
-							type: "text" as const,
-							text: `Plan approved at ${planFilePath}. Plan mode exited; proceed with the implementation.`,
-						},
-					],
-					details,
-				};
-			},
+	async #handleAcpPlanProposal(session: AgentSession, title: string): Promise<AgentToolResult<unknown>> {
+		const state = session.getPlanModeState();
+		if (!state?.enabled) {
+			throw new ToolError("Plan mode is not active.");
+		}
+		const {
+			planFilePath,
+			planContent,
+			title: resolvedTitle,
+		} = await resolveApprovedPlan({
+			suppliedTitle: title,
+			statePlanFilePath: state.planFilePath,
+			readPlan: url => this.#readAcpPlanFile(session, url),
+			listPlanFiles: () => this.#listAcpLocalPlanFiles(session),
 		});
+		const approved = await this.#requestAcpPlanApprovalChoice(session.sessionId, resolvedTitle, planContent);
+		const details: PlanApprovalDetails = {
+			planFilePath,
+			title: resolvedTitle,
+			planExists: true,
+		};
+		if (!approved) {
+			const normalizedTitle = normalizePlanTitle(resolvedTitle).title;
+			return {
+				content: [
+					{
+						type: "text" as const,
+						text: `Plan refinement requested. Update the plan file, then write ${normalizedTitle} to xd://propose again when ready.`,
+					},
+				],
+				details,
+			};
+		}
+		// Approved. Set the plan reference so the next turn injects the plan
+		// content as context (the file keeps its agent-chosen name — no rename),
+		// then exit plan mode so the agent regains full tools.
+		session.setPlanReferencePath(planFilePath);
+		session.setPlanProposalHandler?.(null);
+		session.setPlanModeState(undefined);
+		try {
+			await this.#connection.sessionUpdate({
+				sessionId: session.sessionId,
+				update: this.#buildCurrentModeUpdate(session),
+			});
+			await this.#pushConfigOptionUpdateForSession(session);
+		} catch (error) {
+			logger.warn("Failed to emit mode updates after plan approval", {
+				sessionId: session.sessionId,
+				error,
+			});
+		}
+		return {
+			content: [
+				{
+					type: "text" as const,
+					text: `Plan approved at ${planFilePath}. Plan mode exited; proceed with the implementation.`,
+				},
+			],
+			details,
+		};
 	}
 
 	#resolveAcpPlanFilePath(session: AgentSession, planFilePath: string): string {
@@ -1918,7 +1914,6 @@ export class AcpAgent implements Agent {
 		resetCapabilities();
 		const fileCommands = await loadSlashCommands({ cwd });
 		record.session.setSlashCommands(fileCommands);
-		await record.session.refreshSshTool({ activateIfAvailable: true });
 		await this.#emitAvailableCommandsUpdate(record);
 	}
 
@@ -2284,7 +2279,7 @@ export class AcpAgent implements Agent {
 				setLabel: (targetId, label) => {
 					record.session.sessionManager.appendLabelChange(targetId, label);
 				},
-				getActiveTools: () => record.session.getActiveToolNames(),
+				getActiveTools: () => record.session.getEnabledToolNames(),
 				getAllTools: () => record.session.getAllToolNames(),
 				setActiveTools: toolNames => record.session.setActiveToolsByName(toolNames),
 				getCommands: () => getSessionSlashCommands(record.session),
@@ -2362,7 +2357,7 @@ export class AcpAgent implements Agent {
 		}
 		if (servers.length === 0) {
 			record.mcpManager = undefined;
-			await record.session.refreshMCPTools([], { activateAll: true });
+			await record.session.refreshMCPTools([]);
 			return;
 		}
 
@@ -2389,7 +2384,7 @@ export class AcpAgent implements Agent {
 		}
 
 		record.mcpManager = manager;
-		await record.session.refreshMCPTools(result.tools, { activateAll: true });
+		await record.session.refreshMCPTools(result.tools);
 	}
 
 	#toMcpConfig(server: McpServer): MCPServerConfig {
diff --git a/packages/coding-agent/src/modes/components/chat-transcript-builder.ts b/packages/coding-agent/src/modes/components/chat-transcript-builder.ts
index f3b666cfe..ace89611c 100644
--- a/packages/coding-agent/src/modes/components/chat-transcript-builder.ts
+++ b/packages/coding-agent/src/modes/components/chat-transcript-builder.ts
@@ -51,7 +51,7 @@ import {
 import { CustomMessageComponent } from "./custom-message";
 import { EvalExecutionComponent } from "./eval-execution";
 import { type LateDiagnosticsFile, LateDiagnosticsMessageComponent } from "./late-diagnostics-message";
-import { ReadToolGroupComponent, readArgsHaveTarget, readArgsTargetInternalUrl } from "./read-tool-group";
+import { ReadToolGroupComponent, readArgsCollapseIntoGroup } from "./read-tool-group";
 import { SkillMessageComponent } from "./skill-message";
 import { ToolExecutionComponent } from "./tool-execution";
 import { TranscriptContainer } from "./transcript-container";
@@ -150,12 +150,12 @@ export class ChatTranscriptBuilder {
 		this.#expandables.push(component);
 	}
 
-	/** A `job` poll showing all-running is displaced by the next `job` call. */
+	/** A `hub` wait showing all-running is displaced by the next `hub` call. */
 	#resolveWaitingPoll(nextToolName?: string): void {
 		const previous = this.#waitingPoll;
 		if (!previous) return;
 		this.#waitingPoll = null;
-		if (nextToolName === "job" && previous.isDisplaceableBlock() && this.container.isBlockUncommitted(previous)) {
+		if (nextToolName === "hub" && previous.isDisplaceableBlock() && this.container.isBlockUncommitted(previous)) {
 			this.container.removeChild(previous);
 		}
 		previous.seal();
@@ -321,11 +321,7 @@ export class ChatTranscriptBuilder {
 			this.#resolveWaitingPoll(content.name);
 
 			const afterToolSegment = timeline.afterToolCalls.get(content.id);
-			if (
-				content.name === "read" &&
-				readArgsHaveTarget(content.arguments) &&
-				!readArgsTargetInternalUrl(content.arguments)
-			) {
+			if (content.name === "read" && readArgsCollapseIntoGroup(content.arguments)) {
 				if (hasErrorStop && errorMessage) {
 					const group = this.#ensureReadGroup();
 					group.updateArgs(content.arguments, content.id);
@@ -404,7 +400,7 @@ export class ChatTranscriptBuilder {
 		if (!pending) return;
 		pending.updateResult(message, false, message.toolCallId);
 		this.#pendingTools.delete(message.toolCallId);
-		if (message.toolName === "job" && pending instanceof ToolExecutionComponent && pending.isDisplaceableBlock()) {
+		if (message.toolName === "hub" && pending instanceof ToolExecutionComponent && pending.isDisplaceableBlock()) {
 			this.#waitingPoll = pending;
 		} else if (
 			message.toolName === "todo" &&
diff --git a/packages/coding-agent/src/modes/components/read-tool-group.ts b/packages/coding-agent/src/modes/components/read-tool-group.ts
index 4b247c264..de76bd3aa 100644
--- a/packages/coding-agent/src/modes/components/read-tool-group.ts
+++ b/packages/coding-agent/src/modes/components/read-tool-group.ts
@@ -1,7 +1,7 @@
 import * as path from "node:path";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Container, Text } from "@oh-my-pi/pi-tui";
-import { InternalUrlRouter } from "../../internal-urls";
+import { InternalUrlRouter, XD_URL_PREFIX } from "../../internal-urls";
 import { getLanguageFromPath, theme } from "../../modes/theme/theme";
 import { parseLineRanges, selectorLineRanges, splitPathAndSel } from "../../tools/path-utils";
 import { PREVIEW_LIMITS, shortenPath } from "../../tools/render-utils";
@@ -9,10 +9,8 @@ import { fileHyperlink, renderCodeCell, tryResolveInternalUrlSync } from "../../
 import type { ToolExecutionHandle } from "./tool-execution";
 
 /**
- * Read calls whose target is resolved through {@link InternalUrlRouter} are
- * rendered as full tool executions (not collapsed into the read group) so the
- * resolved content is visible. `path` is the canonical arg; `file_path` is the
- * legacy alias still tolerated by the read tool schema.
+ * Extract the read call's target path. `path` is the canonical arg; `file_path`
+ * is the legacy alias still tolerated by the read tool schema.
  */
 function readArgsTarget(args: unknown): string | undefined {
 	if (!args || typeof args !== "object" || Array.isArray(args)) return undefined;
@@ -28,10 +26,17 @@ export function readArgsHaveTarget(args: unknown): boolean {
 	return readArgsTarget(args) !== undefined;
 }
 
-export function readArgsTargetInternalUrl(args: unknown): boolean {
+/**
+ * Whether a read collapses into the compact {@link ReadToolGroupComponent}
+ * rather than a full tool execution. Filesystem/external targets always
+ * collapse; other internal URLs (`skill://`, `agent://`, …) render full so
+ * their resolved content is visible. `xd://` device reads are the exception —
+ * they list devices/docs and read better in the compact grouped view.
+ */
+export function readArgsCollapseIntoGroup(args: unknown): boolean {
 	const target = readArgsTarget(args);
-	if (!target) return false;
-	return InternalUrlRouter.instance().canHandle(target);
+	if (target === undefined) return false;
+	return target.startsWith(XD_URL_PREFIX) || !InternalUrlRouter.instance().canHandle(target);
 }
 
 type ReadRenderArgs = {
diff --git a/packages/coding-agent/src/modes/components/tool-execution.ts b/packages/coding-agent/src/modes/components/tool-execution.ts
index 1a99b2902..3910fd9b9 100644
--- a/packages/coding-agent/src/modes/components/tool-execution.ts
+++ b/packages/coding-agent/src/modes/components/tool-execution.ts
@@ -20,7 +20,7 @@ import type { Theme } from "../../modes/theme/theme";
 import { getThemeEpoch, theme } from "../../modes/theme/theme";
 import { BASH_DEFAULT_PREVIEW_LINES } from "../../tools/bash";
 import { EVAL_DEFAULT_PREVIEW_LINES } from "../../tools/eval";
-import { isWaitingPollDetails } from "../../tools/job";
+import { isWaitingPollDetails } from "../../tools/hub";
 import {
 	formatArgsInline,
 	JSON_TREE_MAX_DEPTH_COLLAPSED,
@@ -75,7 +75,7 @@ function stripTrailingUnbalancedRemoval(diff: string | undefined): string | unde
 	return lines.slice(0, lastAddIdx + 1).join("\n");
 }
 
-type DisplaceableToolName = "job" | "todo";
+type DisplaceableToolName = "hub" | "todo";
 
 function isTodoToolDetails(details: unknown): details is TodoToolDetails {
 	return (
@@ -92,7 +92,7 @@ function displaceableToolName(
 	isPartial: boolean,
 ): DisplaceableToolName | undefined {
 	if (result.isError === true) return undefined;
-	if (toolName === "job" && isWaitingPollDetails(result.details)) return "job";
+	if (toolName === "hub" && isWaitingPollDetails(result.details)) return "hub";
 	if (toolName === "todo" && !isPartial && isTodoToolDetails(result.details)) return "todo";
 	return undefined;
 }
@@ -273,7 +273,7 @@ export class ToolExecutionComponent extends Container implements NativeScrollbac
 	// late result still repaints instead of stranding the streaming preview.
 	#sealed = false;
 	// Tool result snapshots that may be superseded by a later same-tool call
-	// while still in the transcript live region. `job` uses this for repeated
+	// while still in the transcript live region. `hub` uses this for repeated
 	// all-running polls; `todo` uses it for per-turn state snapshots so only the
 	// latest list remains visible.
 	#displaceableByToolName: DisplaceableToolName | undefined;
@@ -610,7 +610,7 @@ export class ToolExecutionComponent extends Container implements NativeScrollbac
 			this.#toolName !== "todo" &&
 			!isBackgroundAsyncRunning &&
 			(pendingCallConsumesSpinner || partialResultConsumesSpinner);
-		const needsSpinner = isStreamingArgs || isLivePartialTool || this.#displaceableByToolName === "job";
+		const needsSpinner = isStreamingArgs || isLivePartialTool || this.#displaceableByToolName === "hub";
 		if (needsSpinner && !this.#spinnerInterval) {
 			const frameCount = theme.spinnerFrames.length;
 			const frame = sharedSpinnerFrame(frameCount);
@@ -1195,6 +1195,14 @@ export class ToolExecutionComponent extends Container implements NativeScrollbac
 				if (fallback) context.editStreamingFallback = fallback;
 			}
 			context.renderDiff = renderDiff;
+		} else if (this.#toolName === "write") {
+			// Device-dispatch previews delegate to the mounted tool's own renderer;
+			// expose the session's xd:// registry so custom/MCP renderers survive dispatch.
+			const writeTool = this.#tool as
+				| { session?: { xdevRegistry?: { get(name: string): AgentTool | undefined } } }
+				| undefined;
+			const registry = writeTool?.session?.xdevRegistry;
+			if (registry) context.resolveXdevMounted = (name: string) => registry.get(name);
 		}
 
 		return context;
diff --git a/packages/coding-agent/src/modes/controllers/command-controller.ts b/packages/coding-agent/src/modes/controllers/command-controller.ts
index 96c37c5da..181723305 100644
--- a/packages/coding-agent/src/modes/controllers/command-controller.ts
+++ b/packages/coding-agent/src/modes/controllers/command-controller.ts
@@ -515,7 +515,10 @@ export class CommandController {
 	}
 
 	handleToolsCommand(): void {
-		const tools = buildToolsMarkdown({ tools: this.ctx.session.agent.state.tools });
+		const tools = buildToolsMarkdown({
+			tools: this.ctx.session.agent.state.tools,
+			xdevTools: this.ctx.session.getXdevToolEntries(),
+		});
 		showMarkdownPanel(this.ctx, "Available Tools", tools);
 	}
 
diff --git a/packages/coding-agent/src/modes/controllers/event-controller.ts b/packages/coding-agent/src/modes/controllers/event-controller.ts
index 9e9a4a42e..c244a9d9b 100644
--- a/packages/coding-agent/src/modes/controllers/event-controller.ts
+++ b/packages/coding-agent/src/modes/controllers/event-controller.ts
@@ -11,8 +11,8 @@ import { AssistantMessageComponent } from "../../modes/components/assistant-mess
 import { detectCacheInvalidation } from "../../modes/components/cache-invalidation-marker";
 import {
 	ReadToolGroupComponent,
+	readArgsCollapseIntoGroup,
 	readArgsHaveTarget,
-	readArgsTargetInternalUrl,
 } from "../../modes/components/read-tool-group";
 import { TodoReminderComponent } from "../../modes/components/todo-reminder";
 import { ToolExecutionComponent } from "../../modes/components/tool-execution";
@@ -20,12 +20,11 @@ import { TtsrNotificationComponent } from "../../modes/components/ttsr-notificat
 import { createUsageRowBlock } from "../../modes/components/usage-row";
 import { getSymbolTheme, theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext, TodoPhase } from "../../modes/types";
-import type { PlanApprovalDetails } from "../../plan-mode/approved-plan";
 import idleRecapPrompt from "../../prompts/system/recap-user.md" with { type: "text" };
 import type { AgentSessionEvent } from "../../session/agent-session";
 import { isSilentAbort, readQueueChipText, resolveAbortLabel } from "../../session/messages";
 import { previewLine, TRUNCATE_LENGTHS } from "../../tools/render-utils";
-import type { ResolveToolDetails } from "../../tools/resolve";
+import { PROPOSE_DEVICE_NAME, writeDeviceDispatch } from "../../tools/resolve";
 import { nextActionableTask } from "../../tools/todo";
 import { SpeechEnhancer } from "../../tts/speech-enhancer";
 import { vocalizer } from "../../tts/vocalizer";
@@ -102,8 +101,8 @@ export class EventController {
 	// Insertion-ordered IRC cards not yet retired; values are the transcript
 	// components each card contributed (see #retireIrcCard for the guard).
 	#liveIrcCards = new Map<string, Component[]>();
-	// Most recent `job` tool block whose result still had every watched job
-	// running. Kept un-finalized (live) so the next `job` call displaces it —
+	// Most recent `hub` tool block whose result still had every watched job
+	// running. Kept un-finalized (live) so the next `hub` call displaces it —
 	// one persistent poll instead of a stack of "waiting on N jobs" frames —
 	// and sealed in place the moment anything else lands below it.
 	#displaceablePollComponent: ToolExecutionComponent | undefined = undefined;
@@ -576,7 +575,7 @@ export class EventController {
 
 	/**
 	 * Resolve the pending displaceable poll block before the next block lands.
-	 * A follow-up `job` call displaces it — the stale "waiting on N jobs" frame
+	 * A follow-up `hub` call displaces it — the stale "waiting on N jobs" frame
 	 * is removed so repeated polls read as one persistent poll — while anything
 	 * else seals it in place as final history. Removal is gated on none of the
 	 * block's rows having entered native scrollback: rows already on the tape
@@ -588,7 +587,7 @@ export class EventController {
 		if (!previous) return;
 		this.#displaceablePollComponent = undefined;
 		if (
-			nextToolName === "job" &&
+			nextToolName === "hub" &&
 			previous.isDisplaceableBlock() &&
 			this.ctx.chatContainer.isBlockUncommitted(previous)
 		) {
@@ -724,11 +723,11 @@ export class EventController {
 				if (content.name === "read") {
 					if (!readArgsHaveTarget(content.arguments)) {
 						// Args still streaming — defer until path is parseable so we can route to the
-						// read group (regular files) vs ToolExecutionComponent (internal URLs).
+						// read group (files + xd:// devices) vs ToolExecutionComponent (other internal URLs).
 						// Creating either component now would lock the read into the wrong shape.
 						continue;
 					}
-					if (!readArgsTargetInternalUrl(content.arguments)) {
+					if (readArgsCollapseIntoGroup(content.arguments)) {
 						if (!this.ctx.pendingTools.has(content.id)) this.#resolveDisplaceablePoll(content.name);
 						this.#trackReadToolCall(content.id, content.arguments);
 						const component = this.ctx.pendingTools.get(content.id);
@@ -742,7 +741,7 @@ export class EventController {
 						}
 						continue;
 					}
-					// Internal URL read falls through to ToolExecutionComponent below.
+					// Other internal-URL reads fall through to ToolExecutionComponent below.
 				}
 
 				// Preserve the raw partial JSON only for renderers that need to surface fields before the JSON object closes.
@@ -938,7 +937,7 @@ export class EventController {
 		this.#updateWorkingMessageFromIntent(event.intent);
 		this.#resolveDisplaceablePoll(event.toolName);
 		if (!this.ctx.pendingTools.has(event.toolCallId)) {
-			if (event.toolName === "read" && readArgsHaveTarget(event.args) && !readArgsTargetInternalUrl(event.args)) {
+			if (event.toolName === "read" && readArgsCollapseIntoGroup(event.args)) {
 				this.#trackReadToolCall(event.toolCallId, event.args);
 				const component = this.ctx.pendingTools.get(event.toolCallId);
 				if (component) {
@@ -1071,8 +1070,8 @@ export class EventController {
 					this.#backgroundTaskCallIds.delete(event.toolCallId);
 				}
 				if (component instanceof ToolExecutionComponent && component.isDisplaceableBlock()) {
-					if (event.toolName === "job" && component.canBeDisplacedBy("job")) {
-						// Remember the waiting poll so the next `job` call can displace it.
+					if (event.toolName === "hub" && component.canBeDisplacedBy("hub")) {
+						// Remember the waiting poll so the next `hub` call can displace it.
 						this.#displaceablePollComponent = component;
 					} else if (event.toolName === "todo" && component.canBeDisplacedBy("todo")) {
 						// Successful todo update supersedes the prior live snapshot. A failed
@@ -1106,13 +1105,27 @@ export class EventController {
 				`Todo update failed${textContent ? `: ${textContent}` : ". Progress may be stale until todo succeeds."}`,
 			);
 		}
-		if (event.toolName === "resolve" && !event.isError) {
-			const details = event.result.details as ResolveToolDetails | undefined;
-			if (details?.sourceToolName === "plan_approval" && details.action === "apply") {
-				const planDetails = details.sourceResultDetails as PlanApprovalDetails | undefined;
-				if (planDetails) {
-					await this.ctx.handlePlanApproval(planDetails);
-				}
+		// Plan approval rides a `write` to xd://propose: the dispatch metadata on
+		// the write details carries the approval payload as `inner`.
+		if (!event.isError) {
+			const dispatch = writeDeviceDispatch(event.toolName, event.result);
+			const details =
+				dispatch?.tool === PROPOSE_DEVICE_NAME && dispatch.mode === "execute" ? dispatch.inner : undefined;
+			if (
+				details &&
+				typeof details === "object" &&
+				"planFilePath" in details &&
+				"title" in details &&
+				"planExists" in details &&
+				typeof details.planFilePath === "string" &&
+				typeof details.title === "string" &&
+				typeof details.planExists === "boolean"
+			) {
+				await this.ctx.handlePlanApproval({
+					planFilePath: details.planFilePath,
+					title: details.title,
+					planExists: details.planExists,
+				});
 			}
 		}
 	}
diff --git a/packages/coding-agent/src/modes/controllers/extension-ui-controller.ts b/packages/coding-agent/src/modes/controllers/extension-ui-controller.ts
index ac628285d..3cf407412 100644
--- a/packages/coding-agent/src/modes/controllers/extension-ui-controller.ts
+++ b/packages/coding-agent/src/modes/controllers/extension-ui-controller.ts
@@ -148,7 +148,7 @@ export class ExtensionUiController {
 			setLabel: (targetId, label) => {
 				this.ctx.sessionManager.appendLabelChange(targetId, label);
 			},
-			getActiveTools: () => this.ctx.session.getActiveToolNames(),
+			getActiveTools: () => this.ctx.session.getEnabledToolNames(),
 			getAllTools: () => this.ctx.session.getAllToolNames(),
 			setActiveTools: toolNames => this.ctx.session.setActiveToolsByName(toolNames),
 			setModel: async model => {
@@ -368,7 +368,7 @@ export class ExtensionUiController {
 			setLabel: (targetId, label) => {
 				this.ctx.sessionManager.appendLabelChange(targetId, label);
 			},
-			getActiveTools: () => this.ctx.session.getActiveToolNames(),
+			getActiveTools: () => this.ctx.session.getEnabledToolNames(),
 			getAllTools: () => this.ctx.session.getAllToolNames(),
 			setActiveTools: toolNames => this.ctx.session.setActiveToolsByName(toolNames),
 			setModel: async model => {
diff --git a/packages/coding-agent/src/modes/controllers/mcp-command-controller.ts b/packages/coding-agent/src/modes/controllers/mcp-command-controller.ts
index 49ae2363f..8f2bd263f 100644
--- a/packages/coding-agent/src/modes/controllers/mcp-command-controller.ts
+++ b/packages/coding-agent/src/modes/controllers/mcp-command-controller.ts
@@ -1178,7 +1178,7 @@ export class MCPCommandController {
 			if (isConnected && this.ctx.mcpManager) {
 				const serverTools = this.ctx.mcpManager.getTools().filter(t => t.mcpServerName === name);
 				if (serverTools.length > 0) {
-					const currentActive = this.ctx.session.getActiveToolNames();
+					const currentActive = this.ctx.session.getEnabledToolNames();
 					const toActivate = serverTools.map(t => t.name).filter(n => this.ctx.session.getToolByName(n));
 					if (toActivate.length > 0) {
 						await this.ctx.session.setActiveToolsByName([...new Set([...currentActive, ...toActivate])]);
diff --git a/packages/coding-agent/src/modes/controllers/selector-controller.ts b/packages/coding-agent/src/modes/controllers/selector-controller.ts
index 682944396..26faa9ac8 100644
--- a/packages/coding-agent/src/modes/controllers/selector-controller.ts
+++ b/packages/coding-agent/src/modes/controllers/selector-controller.ts
@@ -12,6 +12,7 @@ import {
 	resolveAdvisorConfigEditPath,
 	saveWatchdogConfigFile,
 } from "../../advisor";
+import { reset as resetCapabilities } from "../../capability";
 import { formatModelSelectorValue, resolveAdvisorRoleSelection } from "../../config/model-resolver";
 import { getRoleInfo } from "../../config/model-roles";
 import { settings } from "../../config/settings";
@@ -188,7 +189,7 @@ export class SelectorController {
 						const projectPath = await resolveActiveProjectRegistryPath(this.ctx.sessionManager.getCwd());
 						clearPluginRootsAndCaches(projectPath ? [projectPath] : undefined);
 						await this.ctx.refreshSlashCommandState();
-						await this.ctx.session.refreshSshTool({ activateIfAvailable: true });
+						resetCapabilities();
 						this.ctx.ui.requestRender();
 					},
 					onCancel: () => {
diff --git a/packages/coding-agent/src/modes/controllers/ssh-command-controller.ts b/packages/coding-agent/src/modes/controllers/ssh-command-controller.ts
index 6b01508bf..054919005 100644
--- a/packages/coding-agent/src/modes/controllers/ssh-command-controller.ts
+++ b/packages/coding-agent/src/modes/controllers/ssh-command-controller.ts
@@ -4,6 +4,7 @@
  * Handles /ssh subcommands for managing SSH host configurations.
  */
 import { getProjectDir, getSSHConfigPath } from "@oh-my-pi/pi-utils";
+import { reset as resetCapabilities } from "../../capability";
 import { type SSHHost, sshCapability } from "../../capability/ssh";
 import { loadCapability } from "../../discovery";
 import { addSSHHost, readSSHConfigFile, removeSSHHost, type SSHHostConfig } from "../../ssh/config-writer";
@@ -204,7 +205,7 @@ export class SSHCommandController {
 			if (compat) hostConfig.compat = true;
 
 			await addSSHHost(filePath, name, hostConfig);
-			await this.ctx.session.refreshSshTool({ activateIfAvailable: true });
+			resetCapabilities();
 
 			const scopeLabel = scope === "user" ? "user" : "project";
 			const lines = [
@@ -365,7 +366,7 @@ export class SSHCommandController {
 			}
 
 			await removeSSHHost(filePath, name);
-			await this.ctx.session.refreshSshTool();
+			resetCapabilities();
 
 			this.#showMessage(
 				["", theme.fg("success", `- Removed SSH host "${name}" from ${scope} config`), ""].join("\n"),
diff --git a/packages/coding-agent/src/modes/controllers/tool-args-reveal.ts b/packages/coding-agent/src/modes/controllers/tool-args-reveal.ts
index cf4d09312..b331f8f99 100644
--- a/packages/coding-agent/src/modes/controllers/tool-args-reveal.ts
+++ b/packages/coding-agent/src/modes/controllers/tool-args-reveal.ts
@@ -13,6 +13,8 @@ type ToolArgsRevealComponent = Component & {
 // STREAMING_JSON_PARSE_MIN_GROWTH bytes at a time. Nested-array modes (edit
 // patch/replace `edits[].diff`) still fall through to the throttled parse.
 const STREAMING_STRING_KEYS_BY_TOOL: Record<string, readonly string[]> = {
+	// write.content also carries xd:// device args (a JSON string) — the same
+	// incremental decode feeds the delegated tool renderer live inner args.
 	write: ["content"],
 	edit: ["input", "_input"],
 	eval: ["code"],
diff --git a/packages/coding-agent/src/modes/interactive-mode.ts b/packages/coding-agent/src/modes/interactive-mode.ts
index 3bdd97bee..5e39ddae6 100644
--- a/packages/coding-agent/src/modes/interactive-mode.ts
+++ b/packages/coding-agent/src/modes/interactive-mode.ts
@@ -115,7 +115,6 @@ import type { LspStartupServerInfo } from "../tools";
 import { normalizeLocalScheme } from "../tools/path-utils";
 import { replaceTabs, TRUNCATE_LENGTHS, truncateToWidth } from "../tools/render-utils";
 import { setAutoQaConsentHandler } from "../tools/report-tool-issue";
-import { type ResolveToolDetails, runResolveInvocation } from "../tools/resolve";
 import { formatPhaseDisplayName, todoMatchesAnyDescription } from "../tools/todo";
 import { ToolError } from "../tools/tool-errors";
 import { vocalizer } from "../tts/vocalizer";
@@ -680,8 +679,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.errorBannerContainer = new AnchoredLiveContainer();
 		this.modelCycleContainer = new AnchoredLiveContainer();
 		this.editor = new CustomEditor(getEditorTheme());
-		this.editor.setImeSafeCursorLayout(settings.get("tui.imeSafeCursor"));
 		this.editor.setUseTerminalCursor(this.ui.getShowHardwareCursor());
+		this.editor.setImeSafeCursorLayout(settings.get("tui.imeSafeCursor"));
 		this.editor.setAutocompleteMaxVisible(settings.get("autocompleteMaxVisible"));
 		this.editor.onAutocompleteCancel = () => {
 			this.ui.requestRender(true);
@@ -1177,7 +1176,6 @@ export class InteractiveMode implements InteractiveModeContext {
 		await this.refreshTitleSystemPrompt(newCwd);
 		resetCapabilities();
 		await this.refreshSlashCommandState(newCwd);
-		await this.session.refreshSshTool({ activateIfAvailable: true });
 		setSessionTerminalTitle(this.sessionManager.getSessionName(), this.sessionManager.getCwd());
 		this.statusLine.invalidate();
 		this.ui.requestRender();
@@ -2102,7 +2100,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			if (this.#planModePreviousTools !== undefined) {
 				await this.session.setActiveToolsByName(this.#planModePreviousTools);
 			}
-			this.session.setStandingResolveHandler?.(null);
+			this.session.setPlanProposalHandler?.(null);
 			this.session.setPlanModeState(undefined);
 			this.planModeEnabled = false;
 			this.planModePaused = false;
@@ -2171,7 +2169,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			// sdk.ts excludes "goal" from the initial active tool set unconditionally.
 			// Re-add it now so the agent can call resume, complete, or drop on this goal.
 			if (restored?.goal) {
-				const previousTools = this.session.getActiveToolNames().filter(name => name !== "goal");
+				const previousTools = this.session.getEnabledToolNames().filter(name => name !== "goal");
 				this.#goalModePreviousTools = previousTools;
 				await this.session.setActiveToolsByName([...new Set([...previousTools, "goal"])]);
 			}
@@ -2217,18 +2215,18 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.planModePaused = false;
 
 		const planFilePath = options?.planFilePath ?? (await this.#getPlanFilePath());
-		const previousTools = this.session.getActiveToolNames();
+		const previousTools = this.session.getEnabledToolNames();
 		// `plan-mode-active.md` instructs the agent to draft the plan file with
-		// `write` and refine it with `edit`. Both must be in the active set or the
-		// agent falls back to `edit` on a non-existent file and stalls. `edit` is an
-		// essential built-in so it survives `tools.discoveryMode === "all"`, but
-		// `write` has `loadMode: "discoverable"` and is hidden behind
-		// `search_tool_bm25` — re-activate it here only when the current registry
-		// entry is the built-in write tool (issue #3165). A shadowing extension
-		// tool named `write` must stay inactive because plan mode's read-only
-		// guarantee relies on the built-in write/edit guard. `resolve` is hidden
-		// too; the standing handler below consumes plan-approval calls through it.
-		const planAugmentations = ["resolve"];
+		// `write` and refine it with `edit`, and plan approval itself is a `write`
+		// to `xd://propose`. Both must be in the active set or the agent falls
+		// back to `edit` on a non-existent file and stalls — and cannot submit the plan.
+		// `edit` is an essential built-in so it survives `tools.discoveryMode ===
+		// "all"`; re-activate `write` here only when the current registry entry is
+		// the built-in write tool (issue #3165). A shadowing extension tool named
+		// `write` must stay inactive because plan mode's read-only guarantee relies
+		// on the built-in write/edit guard. The standing handler below consumes
+		// plan-approval dispatches.
+		const planAugmentations: string[] = [];
 		if (this.session.hasBuiltInTool("write")) {
 			planAugmentations.push("write");
 		}
@@ -2248,7 +2246,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			workflow: options?.workflow ?? "parallel",
 			reentry: this.#planModeHasEntered,
 		});
-		this.session.setStandingResolveHandler?.(input => this.#runPlanApprovalResolve(input));
+		this.session.setPlanProposalHandler?.(title => this.#handlePlanProposal(title));
 		if (this.session.isStreaming) {
 			await this.session.sendPlanModeContext({ deliverAs: "steer" });
 		}
@@ -2259,36 +2257,31 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.showStatus(`Plan mode enabled. Plan file: ${planFilePath}`);
 	}
 
-	/** Standing resolve dispatcher registered while plan mode is active. The agent
-	 *  submits the finalized plan by calling `resolve { action: "apply", extra: { title } }`;
-	 *  this handler validates the plan file exists, normalizes the title, and shapes the
-	 *  payload that `event-controller` forwards to `handlePlanApproval`. */
-	#runPlanApprovalResolve(input: unknown): Promise<AgentToolResult<ResolveToolDetails>> {
-		return runResolveInvocation(input as Parameters<typeof runResolveInvocation>[0], {
-			sourceToolName: "plan_approval",
-			label: "Plan ready for approval",
-			apply: async (_reason, extra) => {
-				const state = this.session.getPlanModeState?.();
-				if (!state?.enabled) {
-					throw new ToolError("Plan mode is not active.");
-				}
-				const { planFilePath, title } = await resolveApprovedPlan({
-					suppliedTitle: extra?.title,
-					statePlanFilePath: state.planFilePath,
-					readPlan: url => this.#readPlanFile(url),
-					listPlanFiles: () => this.#listLocalPlanFiles(),
-				});
-				const details: PlanApprovalDetails = {
-					planFilePath,
-					title,
-					planExists: true,
-				};
-				return {
-					content: [{ type: "text" as const, text: "Plan ready for approval." }],
-					details,
-				};
-			},
+	/** Plan-proposal handler registered while plan mode is active. The agent
+	 *  submits the finalized plan by writing the chosen `<slug>`/title to
+	 *  `xd://propose`; this handler validates the plan file exists, normalizes
+	 *  the title, and shapes the payload that `event-controller` forwards to
+	 *  `handlePlanApproval`. */
+	async #handlePlanProposal(title: string): Promise<AgentToolResult<unknown>> {
+		const state = this.session.getPlanModeState?.();
+		if (!state?.enabled) {
+			throw new ToolError("Plan mode is not active.");
+		}
+		const { planFilePath, title: resolvedTitle } = await resolveApprovedPlan({
+			suppliedTitle: title,
+			statePlanFilePath: state.planFilePath,
+			readPlan: url => this.#readPlanFile(url),
+			listPlanFiles: () => this.#listLocalPlanFiles(),
 		});
+		const details: PlanApprovalDetails = {
+			planFilePath,
+			title: resolvedTitle,
+			planExists: true,
+		};
+		return {
+			content: [{ type: "text" as const, text: "Plan ready for approval." }],
+			details,
+		};
 	}
 
 	async #restorePlanPreviousModel(prev: { model: Model; thinkingLevel?: ConfiguredThinkingLevel }): Promise<void> {
@@ -2354,7 +2347,7 @@ export class InteractiveMode implements InteractiveModeContext {
 				}
 			}
 		}
-		this.session.setStandingResolveHandler?.(null);
+		this.session.setPlanProposalHandler?.(null);
 		this.session.setPlanModeState(undefined);
 		this.planModeEnabled = false;
 		// Suppress cache-miss marker on the next turn: plan exit changes the system
@@ -2384,7 +2377,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.showWarning("Exit vibe mode first.");
 			return;
 		}
-		const previousTools = this.session.getActiveToolNames().filter(name => name !== "goal");
+		const previousTools = this.session.getEnabledToolNames().filter(name => name !== "goal");
 		const goalTools = [...new Set([...previousTools, "goal"])];
 		this.#goalModePreviousTools = previousTools;
 		this.goalModePaused = false;
@@ -2749,7 +2742,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			executionModel?: ResolvedRoleModel;
 		},
 	): Promise<void> {
-		const previousTools = this.#planModePreviousTools ?? this.session.getActiveToolNames();
+		const previousTools = this.#planModePreviousTools ?? this.session.getEnabledToolNames();
 
 		// Mark the pending abort caused by the plan-mode → compaction transition as
 		// silent BEFORE #exitPlanMode raises it. The `finally` below clears the
@@ -2977,7 +2970,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			return;
 		}
 
-		const previousTools = this.session.getActiveToolNames();
+		const previousTools = this.session.getEnabledToolNames();
 		await this.session.activateVibeTools(["read"]);
 		this.#vibeModePreviousTools = previousTools;
 		this.vibeModeEnabled = true;
@@ -3329,7 +3322,7 @@ export class InteractiveMode implements InteractiveModeContext {
 
 	/** Manually (re-)open the plan-review overlay — bound to `/plan-review`. Lets
 	 *  the operator pull the review back up after dismissing it, or review a plan
-	 *  the agent wrote without calling `resolve`. There is no fixed plan filename:
+	 *  the agent wrote without dispatching approval. There is no fixed plan filename:
 	 *  `getPlanReferencePath()` is empty until a plan is actually approved (and does
 	 *  not survive a restart), so this drives off the newest `local://<slug>-plan.md`
 	 *  the agent wrote — the files persist in the session artifacts dir, so the scan
@@ -3363,7 +3356,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		// Abort the agent to prevent it from continuing (e.g., re-submitting the
 		// plan) while the popup is showing. The event listener fires asynchronously
 		// (agent's #emit is fire-and-forget), so without this the model sees
-		// "Plan ready for approval." and immediately re-invokes `resolve` in a loop.
+		// "Plan ready for approval." and immediately re-dispatches approval in a loop.
 		// This abort is an internal UI transition, not operator cancellation.
 		await this.#abortPlanApprovalTurnSilently();
 
@@ -3670,13 +3663,13 @@ export class InteractiveMode implements InteractiveModeContext {
 		factory: ((tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) => CustomEditor) | undefined,
 	): void {
 		const previousEditor = this.editor;
-		nextEditor.setImeSafeCursorLayout(this.settings.get("tui.imeSafeCursor"));
 		const previousText = previousEditor.getText();
 		const nextEditor = factory
 			? factory(this.ui, getEditorTheme(), this.keybindings)
 			: new CustomEditor(getEditorTheme());
 
 		nextEditor.setUseTerminalCursor(this.ui.getShowHardwareCursor());
+		nextEditor.setImeSafeCursorLayout(this.settings.get("tui.imeSafeCursor"));
 		nextEditor.setAutocompleteMaxVisible(this.settings.get("autocompleteMaxVisible"));
 		nextEditor.onAutocompleteCancel = () => {
 			this.ui.requestRender(true);
diff --git a/packages/coding-agent/src/modes/rpc/host-tools.ts b/packages/coding-agent/src/modes/rpc/host-tools.ts
index 64573e867..23fe0fa89 100644
--- a/packages/coding-agent/src/modes/rpc/host-tools.ts
+++ b/packages/coding-agent/src/modes/rpc/host-tools.ts
@@ -1,4 +1,4 @@
-import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolResult, AgentToolUpdateCallback, ToolLoadMode } from "@oh-my-pi/pi-agent-core";
 import type { Static, TSchema } from "@oh-my-pi/pi-ai";
 import { Snowflake } from "@oh-my-pi/pi-utils";
 import { applyToolProxy } from "../../extensibility/tool-proxy";
@@ -46,6 +46,7 @@ class RpcHostToolAdapter<TParams extends TSchema = TSchema, TTheme extends Theme
 	declare parameters: TParams;
 	readonly strict = true;
 	concurrency: "shared" | "exclusive" = "shared";
+	readonly loadMode: ToolLoadMode;
 	#bridge: RpcHostToolBridge;
 	#definition: RpcHostToolDefinition;
 
@@ -53,6 +54,7 @@ class RpcHostToolAdapter<TParams extends TSchema = TSchema, TTheme extends Theme
 		this.#definition = definition;
 		this.#bridge = bridge;
 		applyToolProxy(definition, this);
+		this.loadMode = definition.loadMode ?? "discoverable";
 	}
 
 	execute(
diff --git a/packages/coding-agent/src/modes/rpc/rpc-client.ts b/packages/coding-agent/src/modes/rpc/rpc-client.ts
index fe157b6a5..3e36325a2 100644
--- a/packages/coding-agent/src/modes/rpc/rpc-client.ts
+++ b/packages/coding-agent/src/modes/rpc/rpc-client.ts
@@ -791,6 +791,7 @@ export class RpcClient {
 			description: tool.description,
 			parameters: tool.parameters,
 			hidden: tool.hidden,
+			loadMode: tool.loadMode,
 		}));
 		const response = await this.#send({ type: "set_host_tools", tools: definitions });
 		return this.#getData<{ toolNames: string[] }>(response).toolNames;
diff --git a/packages/coding-agent/src/modes/rpc/rpc-mode.ts b/packages/coding-agent/src/modes/rpc/rpc-mode.ts
index 880322a5f..32dcf26a3 100644
--- a/packages/coding-agent/src/modes/rpc/rpc-mode.ts
+++ b/packages/coding-agent/src/modes/rpc/rpc-mode.ts
@@ -507,6 +507,7 @@ function normalizeHostToolDefinitions(tools: RpcHostToolDefinition[]): RpcHostTo
 			description,
 			parameters: tool.parameters,
 			hidden: tool.hidden === true,
+			loadMode: tool.loadMode ?? "discoverable",
 		};
 	});
 }
@@ -914,7 +915,6 @@ export async function runRpcMode(
 		clearPluginRootsAndCaches(projectPath ? [projectPath] : undefined);
 		resetCapabilities();
 		session.setSlashCommands(await loadSlashCommands({ cwd }));
-		await session.refreshSshTool({ activateIfAvailable: true });
 		await emitAvailableCommandsUpdate();
 	};
 	const emitAvailableCommandsUpdate = async () => {
diff --git a/packages/coding-agent/src/modes/rpc/rpc-types.ts b/packages/coding-agent/src/modes/rpc/rpc-types.ts
index a877079cd..14c7886bd 100644
--- a/packages/coding-agent/src/modes/rpc/rpc-types.ts
+++ b/packages/coding-agent/src/modes/rpc/rpc-types.ts
@@ -4,7 +4,7 @@
  * Commands are sent as JSON lines on stdin.
  * Responses and events are emitted as JSON lines on stdout.
  */
-import type { AgentMessage, AgentToolResult, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { AgentMessage, AgentToolResult, ThinkingLevel, ToolLoadMode } from "@oh-my-pi/pi-agent-core";
 import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { Effort, ImageContent, Model, ToolExample } from "@oh-my-pi/pi-ai";
 import type { BashResult } from "../../exec/bash-executor";
@@ -394,6 +394,8 @@ export interface RpcHostToolDefinition {
 	description: string;
 	parameters: Record<string, unknown>;
 	hidden?: boolean;
+	/** How this host tool is presented when enabled; omission normalizes to `"discoverable"` at the adapter boundary. */
+	loadMode?: ToolLoadMode;
 }
 
 /** Emitted by the RPC server when it needs the host to execute a registered tool. */
diff --git a/packages/coding-agent/src/modes/runtime-init.ts b/packages/coding-agent/src/modes/runtime-init.ts
index ecf03755b..57d7775f2 100644
--- a/packages/coding-agent/src/modes/runtime-init.ts
+++ b/packages/coding-agent/src/modes/runtime-init.ts
@@ -83,7 +83,7 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 			setLabel: (targetId, label) => {
 				session.sessionManager.appendLabelChange(targetId, label);
 			},
-			getActiveTools: () => session.getActiveToolNames(),
+			getActiveTools: () => session.getEnabledToolNames(),
 			getAllTools: () => session.getAllToolNames(),
 			setActiveTools: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
 			getCommands: () => getSessionSlashCommands(session),
diff --git a/packages/coding-agent/src/modes/utils/tools-markdown.ts b/packages/coding-agent/src/modes/utils/tools-markdown.ts
index 70d440947..65325cf01 100644
--- a/packages/coding-agent/src/modes/utils/tools-markdown.ts
+++ b/packages/coding-agent/src/modes/utils/tools-markdown.ts
@@ -2,6 +2,8 @@ import type { Tool } from "../../tools";
 
 export interface ToolsMarkdownBindings {
 	tools: ReadonlyArray<Pick<Tool, "description" | "name">>;
+	/** Tools mounted under `xd://` URLs, listed after the active set. */
+	xdevTools?: ReadonlyArray<{ name: string; summary: string }>;
 }
 
 function escapeTableCell(value: string): string {
@@ -12,16 +14,18 @@ function escapeTableCell(value: string): string {
 }
 
 export function buildToolsMarkdown(bindings: ToolsMarkdownBindings): string {
-	if (bindings.tools.length === 0) {
+	if (bindings.tools.length === 0 && !bindings.xdevTools?.length) {
 		return "No tools are currently visible to the agent.";
 	}
 
-	return [
-		"| Tool | Description |",
-		"|------|-------------|",
-		...bindings.tools.map(tool => {
-			const description = escapeTableCell(tool.description) || "No description provided.";
-			return `| \`${tool.name}\` | ${description} |`;
-		}),
-	].join("\n");
+	const rows: string[] = [];
+	for (const tool of bindings.tools) {
+		const description = escapeTableCell(tool.description) || "No description provided.";
+		rows.push(`| \`${tool.name}\` | ${description} |`);
+	}
+	for (const mounted of bindings.xdevTools ?? []) {
+		rows.push(`| \`xd://${mounted.name}\` | ${escapeTableCell(mounted.summary) || "No description provided."} |`);
+	}
+
+	return ["| Tool | Description |", "|------|-------------|", ...rows].join("\n");
 }
diff --git a/packages/coding-agent/src/modes/utils/transcript-render-helpers.ts b/packages/coding-agent/src/modes/utils/transcript-render-helpers.ts
index caf774a5a..5d90d2454 100644
--- a/packages/coding-agent/src/modes/utils/transcript-render-helpers.ts
+++ b/packages/coding-agent/src/modes/utils/transcript-render-helpers.ts
@@ -13,7 +13,7 @@ import {
 	resolveAbortLabel,
 	shouldRenderAbortReason,
 } from "../../session/messages";
-import { createIrcMessageCard } from "../../tools/irc";
+import { createIrcMessageCard } from "../../tools/hub";
 import { replaceTabs, TRUNCATE_LENGTHS, truncateToWidth } from "../../tools/render-utils";
 import { canonicalizeMessage } from "../../utils/thinking-display";
 import { TranscriptBlock } from "../components/transcript-container";
diff --git a/packages/coding-agent/src/modes/utils/ui-helpers.ts b/packages/coding-agent/src/modes/utils/ui-helpers.ts
index d8b46d7c9..0839fb0a2 100644
--- a/packages/coding-agent/src/modes/utils/ui-helpers.ts
+++ b/packages/coding-agent/src/modes/utils/ui-helpers.ts
@@ -24,11 +24,7 @@ import {
 	type LateDiagnosticsFile,
 	LateDiagnosticsMessageComponent,
 } from "../../modes/components/late-diagnostics-message";
-import {
-	ReadToolGroupComponent,
-	readArgsHaveTarget,
-	readArgsTargetInternalUrl,
-} from "../../modes/components/read-tool-group";
+import { ReadToolGroupComponent, readArgsCollapseIntoGroup } from "../../modes/components/read-tool-group";
 import { SkillMessageComponent } from "../../modes/components/skill-message";
 import { ToolExecutionComponent } from "../../modes/components/tool-execution";
 import { TranscriptBlock } from "../../modes/components/transcript-container";
@@ -315,8 +311,8 @@ export class UiHelpers {
 			pendingUsageTtft = undefined;
 		};
 		// Rebuild-time mirror of the event controller's displaceable-poll
-		// bookkeeping: a `job` poll that found every watched job still running is
-		// superseded by the next `job` call, so a rebuilt transcript collapses a
+		// bookkeeping: a `hub` wait that found every watched job still running is
+		// superseded by the next `hub` call, so a rebuilt transcript collapses a
 		// repeated-poll run to its final snapshot instead of replaying the spam.
 		let waitingPoll: ToolExecutionComponent | null = null;
 		const resolveWaitingPoll = (nextToolName?: string) => {
@@ -324,7 +320,7 @@ export class UiHelpers {
 			if (!previous) return;
 			waitingPoll = null;
 			if (
-				nextToolName === "job" &&
+				nextToolName === "hub" &&
 				previous.isDisplaceableBlock() &&
 				this.ctx.chatContainer.isBlockUncommitted(previous)
 			) {
@@ -402,11 +398,7 @@ export class UiHelpers {
 					resolveWaitingPoll(content.name);
 					const afterToolSegment = timeline.afterToolCalls.get(content.id);
 
-					if (
-						content.name === "read" &&
-						readArgsHaveTarget(content.arguments) &&
-						!readArgsTargetInternalUrl(content.arguments)
-					) {
+					if (content.name === "read" && readArgsCollapseIntoGroup(content.arguments)) {
 						if (hasErrorStop && errorMessage) {
 							if (!readGroup) {
 								readGroup = new ReadToolGroupComponent({
@@ -565,7 +557,7 @@ export class UiHelpers {
 					component.updateResult(message, false, message.toolCallId);
 					this.ctx.pendingTools.delete(message.toolCallId);
 					if (
-						message.toolName === "job" &&
+						message.toolName === "hub" &&
 						component instanceof ToolExecutionComponent &&
 						component.isDisplaceableBlock()
 					) {
diff --git a/packages/coding-agent/src/plan-mode/approved-plan.ts b/packages/coding-agent/src/plan-mode/approved-plan.ts
index 120fd4212..fb6f7c16d 100644
--- a/packages/coding-agent/src/plan-mode/approved-plan.ts
+++ b/packages/coding-agent/src/plan-mode/approved-plan.ts
@@ -1,10 +1,10 @@
 import { ToolError } from "../tools/tool-errors";
 
-/** Shape forwarded from the plan-mode resolve handler to InteractiveMode's
- *  approval popup. Populated by the standing handler that the resolve tool
- *  dispatches to when the agent submits `resolve { action: "apply" }`.
- *  `planFilePath` is the agent-chosen `local://<slug>-plan.md` artifact — it is
- *  never renamed on approval, so links to it stay valid for the session. */
+/** Shape forwarded from the plan-proposal handler to InteractiveMode's
+ *  approval popup. Populated by the `xd://propose` dispatch when the agent
+ *  submits a plan for approval. `planFilePath` is the agent-chosen
+ *  `local://<slug>-plan.md` artifact — it is never renamed on approval, so
+ *  links to it stay valid for the session. */
 export interface PlanApprovalDetails {
 	planFilePath: string;
 	title: string;
diff --git a/packages/coding-agent/src/prompts/goals/goal-todo-context.md b/packages/coding-agent/src/prompts/goals/goal-todo-context.md
index 89535e14d..72dbe4935 100644
--- a/packages/coding-agent/src/prompts/goals/goal-todo-context.md
+++ b/packages/coding-agent/src/prompts/goals/goal-todo-context.md
@@ -1,14 +1,6 @@
 <todo_context>
 Current persisted todo state for this goal follows. Goal continuations do not get a visible user nudge, so treat this as live progress state, not old transcript decoration.
-{{#if canCallTodoTool}}
 Before continuing substantial work, compare your next action with these todos. If an item is stale, already finished, or no longer the active pointer, call the `todo` tool first to mark it done or rewrite the list. Do not leave a stale in_progress item while working on later phases.
-{{else}}
-{{#if canActivateTodoTool}}
-Before continuing substantial work, compare your next action with these todos as read-only progress state. The `todo` tool is discoverable but not active in this turn; if the list needs edits, call `search_tool_bm25` to activate `todo` first instead of ignoring the persisted state.
-{{else}}
-Before continuing substantial work, compare your next action with these todos as read-only progress state. The `todo` tool is not active in this turn, so do not claim todo updates unless a later turn exposes the tool.
-{{/if}}
-{{/if}}
 
 Overall: {{closed}}/{{total}} done, {{open}} open.
 {{#each phases}}
diff --git a/packages/coding-agent/src/prompts/system/irc-incoming.md b/packages/coding-agent/src/prompts/system/irc-incoming.md
index bcce7a92b..6926ddb2e 100644
--- a/packages/coding-agent/src/prompts/system/irc-incoming.md
+++ b/packages/coding-agent/src/prompts/system/irc-incoming.md
@@ -5,5 +5,5 @@ Incoming IRC message from agent `{{from}}`{{#if replyTo}} (replying to {{replyTo
 
 {{#if interrupting}}An agent sent this while you were waiting or working. Any active interruptible wait was stopped early so you can read it now.{{/if}}
 
-{{#if autoReplied}}You are mid-task, so a side-channel auto-reply was generated from your context and delivered to `{{from}}` on your behalf (recorded after this message). Follow up with the `irc` tool (`op: "send"`, `to: "{{from}}"`) only if that auto-reply needs correcting.{{else}}If a response is expected, reply with the `irc` tool (`op: "send"`, `to: "{{from}}"`) — you may finish your current step first. Nobody replies on your behalf.{{/if}}
+{{#if autoReplied}}You are mid-task, so a side-channel auto-reply was generated from your context and delivered to `{{from}}` on your behalf (recorded after this message). Follow up with the `hub` tool (`op: "send"`, `to: "{{from}}"`) only if that auto-reply needs correcting.{{else}}If a response is expected, reply with the `hub` tool (`op: "send"`, `to: "{{from}}"`) — you may finish your current step first. Nobody replies on your behalf.{{/if}}
 </irc>
diff --git a/packages/coding-agent/src/prompts/system/orchestrate-notice.md b/packages/coding-agent/src/prompts/system/orchestrate-notice.md
index 4e7187075..4e615351c 100644
--- a/packages/coding-agent/src/prompts/system/orchestrate-notice.md
+++ b/packages/coding-agent/src/prompts/system/orchestrate-notice.md
@@ -21,7 +21,7 @@ You decompose, dispatch, verify, and iterate. Substantial and parallelizable wor
 <workflow>
 1. **Ingest.** Read every referenced file (audits, plans, prior agent output, current branch state). Run `git status` to see uncommitted changes.
 2. **Plan.** Materialize the full work surface in `todo` as ordered phases. Within each phase, list the parallelizable units.
-3. **Dispatch phase.** Launch all parallel `task` subagents in one message, then collect every result (async results / `job poll`) before moving on.
+3. **Dispatch phase.** Launch all parallel `task` subagents in one message, then collect every result (async results / `hub` wait) before moving on.
 4. **Verify phase.** Run the gates. On failure, dispatch fix-up subagents and re-verify. Do not advance with a red gate.
 5. **Commit phase** (if applicable). Focused message naming the phase.
 6. **Advance.** Mark the phase done in `todo`, immediately start the next phase. No summary message between phases — keep going.
diff --git a/packages/coding-agent/src/prompts/system/plan-mode-active.md b/packages/coding-agent/src/prompts/system/plan-mode-active.md
index 047d60c68..7ecff66ba 100644
--- a/packages/coding-agent/src/prompts/system/plan-mode-active.md
+++ b/packages/coding-agent/src/prompts/system/plan-mode-active.md
@@ -6,9 +6,9 @@ Plan mode is active. You MUST preserve read-only working-tree and system semanti
 - You NEVER delete or rename `local://` artifacts.
 - You MUST write the canonical plan to `local://<slug>-plan.md`.
 
-To leave plan mode and implement: call `resolve` with `action: "apply"`, a `reason`, and `extra: { title: "<slug>" }`, where `<slug>` matches your `local://<slug>-plan.md`. The user then picks an execution option and full write access is restored. `<slug>` may contain only letters, numbers, underscores, and hyphens.
+To leave plan mode and implement: write your plan's `<slug>`/title as plain text to `xd://propose` with `{{writeToolName}}`, where `<slug>` matches your `local://<slug>-plan.md`. The user then picks an execution option and full write access is restored. `<slug>` may contain only letters, numbers, underscores, and hyphens.
 
-You NEVER ask the user to exit plan mode, and you NEVER request approval in prose or via `{{askToolName}}` — approval happens ONLY through `resolve`.
+You NEVER ask the user to exit plan mode, and you NEVER request approval in prose or via `{{askToolName}}` — approval happens ONLY through the `xd://propose` write.
 </critical>
 
 ## What a plan is
@@ -22,7 +22,7 @@ Detail exists to remove the implementer's decisions — not to look thorough. A
 {{#if planExists}}
 A plan already exists at `{{planFilePath}}` — read it, then update it incrementally with `{{editToolName}}`. If this request is a different task, leave that plan in place and start a fresh `local://<slug>-plan.md`.
 {{else}}
-Choose a short kebab-case `<slug>` naming this task and write the plan to `local://<slug>-plan.md` (e.g. `local://auth-token-refresh-plan.md`). The file is never renamed on approval, so the name you choose persists — pass that same `<slug>` as `title` when you `resolve`.
+Choose a short kebab-case `<slug>` naming this task and write the plan to `local://<slug>-plan.md` (e.g. `local://auth-token-refresh-plan.md`). The file is never renamed on approval, so the name you choose persists — write that same `<slug>` to `xd://propose` when you request approval.
 {{/if}}
 
 Use `{{editToolName}}` for incremental edits and `{{writeToolName}}` only to create or fully replace the file. You MUST write findings into the plan as you learn them — you NEVER batch all writing to the end.
@@ -52,7 +52,7 @@ Every question MUST change the plan or settle a load-bearing choice. Batch them.
 1. Read the existing plan.
 2. Compare the new request against it.
 3. Different task → overwrite it. Same task continuing → update it and delete outdated sections.
-4. Call `resolve` with `action: "apply"` and `extra: { title }` when complete.
+4. Write your plan's `<slug>`/title as plain text to `xd://propose` when complete.
 </procedure>
 {{/if}}
 
@@ -111,12 +111,12 @@ All three rely on the file being self-contained.
 </caution>
 
 <critical>
-Before you `resolve`, apply the test: an engineer who never saw this conversation executes every step without making one design decision and can tell, at each step, whether it worked. If any step would force a choice or leave "done" ambiguous, deepen it first.
+Before you request approval, apply the test: an engineer who never saw this conversation executes every step without making one design decision and can tell, at each step, whether it worked. If any step would force a choice or leave "done" ambiguous, deepen it first.
 
 Your turn ends ONLY by:
 1. Using `{{askToolName}}` to gather requirements or choose between approaches, OR
-2. Calling `resolve` with `action: "apply"`, `reason`, and `extra: { title: "<slug>" }` (the slug of your `local://<slug>-plan.md`).
+2. Writing your plan's `<slug>`/title as plain text to `xd://propose` with `{{writeToolName}}` (the slug of your `local://<slug>-plan.md`).
 
-You NEVER request plan approval via prose or `{{askToolName}}`; you MUST use `resolve`.
+You NEVER request plan approval via prose or `{{askToolName}}`; you MUST use the `xd://propose` write.
 You MUST keep going until the plan is decision-complete.
 </critical>
diff --git a/packages/coding-agent/src/prompts/system/plan-mode-tool-decision-reminder.md b/packages/coding-agent/src/prompts/system/plan-mode-tool-decision-reminder.md
index 20661a4ac..3031b6c6f 100644
--- a/packages/coding-agent/src/prompts/system/plan-mode-tool-decision-reminder.md
+++ b/packages/coding-agent/src/prompts/system/plan-mode-tool-decision-reminder.md
@@ -3,7 +3,7 @@ Plan mode turn ended without a required tool call.
 
 You MUST choose exactly one next action now:
 1. Call `{{askToolName}}` to gather required clarification, OR
-2. Call `resolve` with `action: "apply"`, `reason`, and `extra: { title: "<slug>" }` (the slug of your `local://<slug>-plan.md`) to finish planning and request approval
+2. Write the plan slug/title (`<slug>`, matching `local://<slug>-plan.md`) as plain text to `xd://propose` with `{{writeToolName}}` to finish planning and request approval
 
 You NEVER output plain text in this turn.
 </system-reminder>
diff --git a/packages/coding-agent/src/prompts/system/resolve-device-reminder.md b/packages/coding-agent/src/prompts/system/resolve-device-reminder.md
new file mode 100644
index 000000000..971f16ff5
--- /dev/null
+++ b/packages/coding-agent/src/prompts/system/resolve-device-reminder.md
@@ -0,0 +1,3 @@
+<system-reminder>
+This is a preview. Finalize it now with the `write` tool: write a one-sentence reason as plain text to `xd://resolve` to APPLY it, or to `xd://reject` to DISCARD it.
+</system-reminder>
diff --git a/packages/coding-agent/src/prompts/system/subagent-system-prompt.md b/packages/coding-agent/src/prompts/system/subagent-system-prompt.md
index 402581ce4..30c06b37f 100644
--- a/packages/coding-agent/src/prompts/system/subagent-system-prompt.md
+++ b/packages/coding-agent/src/prompts/system/subagent-system-prompt.md
@@ -33,12 +33,12 @@ You NEVER modify files outside this tree or in the original repository.
 {{/if}}
 
 {{#if ircPeers}}
-# IRC Peers
-You can reach other live agents via the `irc` tool. Your id is `{{ircSelfId}}`. Currently visible peers:
+# Peers
+You can reach other live agents via the `hub` tool. Your id is `{{ircSelfId}}`. Currently visible peers:
 {{ircPeers}}
 
-Use `irc` only for quick coordination, never long-form content. Address peers by id or use `"all"` to broadcast.
-- Discovery: the roster above shows each peer and what it is doing now; `irc` op:"list" refreshes it.
+Use `hub` messaging only for quick coordination, never long-form content. Address peers by id or use `"all"` to broadcast.
+- Discovery: the roster above shows each peer and what it is doing now; `hub` op:"list" refreshes it.
 - Coordination: before you edit a file or start work a sibling may already own, message that peer first — overlapping edits collide.
 - Follow-up: answer a peer's question with a short reply (set `replyTo`); use `await` only when you genuinely cannot proceed without the answer.
 {{/if}}
diff --git a/packages/coding-agent/src/prompts/system/system-prompt.md b/packages/coding-agent/src/prompts/system/system-prompt.md
index 6894976e5..a2f286b93 100644
--- a/packages/coding-agent/src/prompts/system/system-prompt.md
+++ b/packages/coding-agent/src/prompts/system/system-prompt.md
@@ -77,12 +77,13 @@ Special URLs for internal resources; with most FS/bash tools they auto-resolve t
 {{else}}
 {{toolInventory}}
 {{/if}}
-{{#if mcpDiscoveryMode}}
-<discovery-notice>
-{{#if hasMCPDiscoveryServers}}Discoverable MCP servers this session: {{#list mcpDiscoveryServerSummaries join=", "}}{{this}}{{/list}}.{{/if}}
-If the task may involve external systems (SaaS APIs, chat, tickets, databases, deployments, or other non-local integrations), you SHOULD call `{{toolRefs.search_tool_bm25}}` before concluding no such tool exists.
-</discovery-notice>
 {{/if}}
+
+{{#if xdevTools.length}}
+# xd:// Tool Devices
+Additional tools are mounted as virtual devices, executed by writing a JSON args object as `content` to `xd://<tool>` via `{{toolRefs.write}}`.
+Invalid args return the schema in the error — fix and retry
+{{xdevDocs}}
 {{/if}}
 
 TOOL POLICY
@@ -114,11 +115,11 @@ You MUST use the specialized tool over its shell equivalent:
 {{#has tools "bash"}}- `{{toolRefs.bash}}`: real binaries and short fact pipelines only. Commands shadowing the specialized tools above are blocked.{{/has}}
 {{#has tools "bash"}}- Litmus: one external-CLI call or short pipeline returning a count, frequency, set difference, or checksum → bash. Merely moves, pages, or trims bytes a tool can fetch → use the tool.{{/has}}
 
-{{#has tools "report_tool_issue"}}
+{{#if autoQaEnabled}}
 <critical>
-`{{toolRefs.report_tool_issue}}` powers automated QA. If ANY tool returns output inconsistent with its described behavior given your parameters, call it with the tool name and a concise description. Don't hesitate—false positives are fine.
+`{{toolRefs.write}} xd://report_issue` powers automated QA. If ANY tool returns output inconsistent with its described behavior given your parameters, write `<tool>: <concise description>` as plain text to `xd://report_issue`. Don't hesitate — false positives are fine.
 </critical>
-{{/has}}
+{{/if}}
 
 # Exploration
 You NEVER open a file hoping. Hope is not a strategy.
@@ -176,7 +177,7 @@ Everything else—multi-file changes, refactors, new features, tests, investigat
 {{#when MAX_CONCURRENCY ">" 0}}
 - **Concurrency cap:** At most {{pluralize MAX_CONCURRENCY "subagent" "subagents"}} run at once in this session — anything beyond that just queues, so a {{#if taskBatch}}`tasks[]` batch{{else}}set of parallel `task` calls{{/if}} larger than {{MAX_CONCURRENCY}} only delays results. Keep the fan-out at or under the cap.
 {{/when}}
-- **Sequence only when necessary:** The only reason to run A before B is if B strictly requires A's output to function (e.g., a core API contract or schema migration). {{#if taskIrcEnabled}}If the missing piece is small, run them in parallel and have B ask A via `irc`!{{/if}}
+- **Sequence only when necessary:** The only reason to run A before B is if B strictly requires A's output to function (e.g., a core API contract or schema migration). {{#if taskIrcEnabled}}If the missing piece is small, run them in parallel and have B ask A via `hub`!{{/if}}
 {{/has}}
 
 EXECUTION WORKFLOW
diff --git a/packages/coding-agent/src/prompts/tools/bash.md b/packages/coding-agent/src/prompts/tools/bash.md
index 931dfc587..fb10f9d95 100644
--- a/packages/coding-agent/src/prompts/tools/bash.md
+++ b/packages/coding-agent/src/prompts/tools/bash.md
@@ -1,9 +1,8 @@
-Runs commands in the embedded shell. NOT full GNU Bash — invokes real binaries with simple args.
+Runs commands in a persistent shell session.
 
-Use ONLY for: single binary call or short pipeline that COMPUTES a fact (`wc -l`, `sort | uniq -c`, `comm`, `diff`, checksum, `git status`).
-{{#if hasLaunch}}Services, watchers, debuggers, REPLs → `launch`.{{/if}}
+Use ONLY for: single binary call or short pipeline that COMPUTES a fact (`wc -l`, `sort | uniq -c`, `comm`, `diff`).
+{{#if hasLaunch}}Services, watchers, debuggers, REPLs → `hub` (`op:"start"`).{{/if}}
 {{#if hasEval}}Inline scripts, heredocs, shell control flow, `$(…)`, multi-stage pipelines, `&&`-chains, quote/JSON escaping → `eval` cells.{{else}}Inline scripts, heredocs, shell control flow, `$(…)`, multi-stage pipelines, `&&`-chains → purpose-built tool or checked-in script.{{/if}}
-GNU grep BRE not guaranteed: use `grep -E 'a|b'` not `grep 'a\|b'`{{#if hasGrep}}; prefer built-in `grep` tool{{/if}}.
 
 <instruction>
 - `cwd` sets working dir (not `cd dir && …`). `env: { NAME: "…" }` for multiline/quote-heavy values; `"$NAME"` to expand.
@@ -17,9 +16,9 @@ GNU grep BRE not guaranteed: use `grep -E 'a|b'` not `grep 'a\|b'`{{#if hasGrep}
 {{#if hasGrep}}- NEVER shell out to search: `grep`/`rg` → built-in `grep`.{{/if}}
 {{#if hasRead}}{{#if hasGlob}}- NEVER use `ls` or `find` — `ls` → `read`, `find` → `glob`. NON-NEGOTIABLE.{{/if}}{{/if}}
 - Avoid head/tail/redirections: stderr merged, output auto-truncated, full capture at `artifact://<id>`.
-{{#if hasLaunch}}- NEVER launch daemons/watchers/servers/debuggers/REPLs through bash — use `launch`.{{/if}}
+{{#if hasLaunch}}- NEVER launch daemons/watchers/servers/debuggers/REPLs through bash — use `hub` (`op:"start"`).{{/if}}
 </critical>
 
-{{#if asyncEnabled}}- `timeout`: nonzero clamped 1–3600, killed on elapse. `0` only for cancellation-owned. `async: true` defers reporting only, doesn't extend timeout.{{/if}}
+{{#if asyncEnabled}}- `timeout`: nonzero clamped 1–3600, killed on elapse. `async: true` defers reporting only, doesn't extend timeout.{{/if}}
 {{#if autoBackgroundEnabled}}- Long foreground calls may auto-background; result arrives as follow-up — NOT a failure. Need inline? Raise timeout{{#if asyncEnabled}} or `async: true`{{/if}}.{{/if}}
-- Long output truncated, test/lint filtered to failures. `[raw output: artifact://<id>]` footer links full capture. No footer = what you see is exact output.
+- Long output truncated, test/lint filtered to failures. Footer links full capture. No footer = what you see is exact output.
diff --git a/packages/coding-agent/src/prompts/tools/hub.md b/packages/coding-agent/src/prompts/tools/hub.md
new file mode 100644
index 000000000..73be57b32
--- /dev/null
+++ b/packages/coding-agent/src/prompts/tools/hub.md
@@ -0,0 +1,32 @@
+Agent coordination: peer messaging, background-job control, and supervised long-running processes. Main agent is `Main`; subagents inherit task ID.
+Use `op: "list"` to discover peers. Address peers by exact roster ID — NEVER invent names.
+
+# Messaging & Jobs
+
+Background jobs deliver their results automatically the moment they finish. You NEVER need to poll for output — intervene only to block, kill, or inspect.
+
+- **`send`** (with `to`): fire-and-forget, NEVER blocks. Delivery receipts (`delivered`/`failed`) immediate; `failed` → peer gone, don't retry.
+  Sending wakes `idle`/`parked` peers. Answering: lead with answer, NEVER quote, set `replyTo`.
+- **Format**: plain prose ONLY. No JSON status objects. Share paths via `local://`/`artifact://` URLs, not pasted blobs.
+- **`wait`**: use ONLY when completely blocked with no other work. Returns on the FIRST of: an incoming message, a watched job finishing, the wait window elapsing, or a steering interrupt — NOT when all jobs finish; re-issue to keep waiting.
+  - Bare `wait` watches every running job AND incoming messages. NEVER pass an array of every running ID; `ids` narrows to specific jobs, `from` to one peer (or use `await: true` on send).
+- **`inbox`**: drain queued messages without blocking.
+- **`cancel`**: kill background jobs by `ids` when they have hung, stalled, or are no longer needed. Returns immediately.
+- **`jobs`**: status snapshot of every job without waiting. Also names running subagents with no job entry — coordinate with those via `send`.
+- NEVER use shell tools, grep, or read other sessions' files to figure out what a peer is doing. Message them directly.
+- NEVER use hub messaging for something a tool can answer (e.g., grepping codebase, running a build).
+
+# Processes
+
+Project-scoped long-running processes shared by every omp instance in the same directory. A long-running service, watcher, debugger, REPL, or process needing later input MUST use `op:"start"`, not `bash`.
+
+- **`start`** launches `application` + `args` directly. `cwd` defaults to the session directory; `pty` defaults true.
+  - `ready.log` is a regex; `ready.port` is a TCP port. Both supplied? BOTH MUST pass. `ready.timeout` is seconds. Readiness MUST be observed; process creation alone is not readiness.
+  - Names are unique per project directory. A completed name MAY be started again; a live name MUST be stopped or restarted.
+  - `restart` policy defaults `no`; `on-failure` and `always` use bounded backoff.
+  - `persist: true` opts out of last-omp teardown; `detached: true` survives broker shutdown and all omp exits (implies persist, disables PTY input). Omit both unless their survival guarantees are required.
+- **`ps`**, **`logs`**, **`wait`** (with `name`), **`send`** (with `name`), **`stop`**, **`restart`**, and **`describe`** address the stable `name`.
+- **`logs`** defaults to the last 100 lines. `head: true` reads the beginning. `grep` is a regex. `follow: true` waits for output after `cursor`; reuse the returned cursor on the next call.
+- **`wait`** with `name` blocks until readiness/exit/`pattern` or `timeout` (seconds).
+- **`send`** with `name`: `text` writes stdin (`enter` defaults true); `keys` supports ENTER, TAB, ESCAPE, CTRL_C, CTRL_D, UP, DOWN, LEFT, RIGHT; `signal` supports SIGINT, SIGTERM, SIGHUP, SIGQUIT, SIGKILL. PTY input is serialized; writes share one input stream.
+- **`stop`** performs graceful process-tree termination before hard-kill; NEVER kill an unverified PID through bash. **`restart`** reuses the retained launch spec.
diff --git a/packages/coding-agent/src/prompts/tools/irc.md b/packages/coding-agent/src/prompts/tools/irc.md
deleted file mode 100644
index 1977670e5..000000000
--- a/packages/coding-agent/src/prompts/tools/irc.md
+++ /dev/null
@@ -1,11 +0,0 @@
-Agent-to-agent messaging. Main agent is `Main`; subagents inherit task ID.
-Use `op: "list"` to discover peers. Address by exact roster ID — NEVER invent names.
-
-- **`send`**: fire-and-forget, NEVER blocks. Delivery receipts (`delivered`/`failed`) immediate; `failed` → peer gone, don't retry.
-  Sending wakes `idle`/`parked` peers. Answering: lead with answer, NEVER quote, set `replyTo`.
-- **Format**: plain prose ONLY. No JSON status objects. Share paths via `local://`/`artifact://` URLs, not pasted blobs.
-- **`wait`** (or `await: true`): blocks until matching message, timeout, or steering interrupt. Parent IRC interrupts at steering priority.
-  Waits surface cross-channel interrupts — don't alternate `wait`/`inbox`/`job poll`.
-- **`inbox`**: drain queue without blocking.
-- 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).
diff --git a/packages/coding-agent/src/prompts/tools/job.md b/packages/coding-agent/src/prompts/tools/job.md
deleted file mode 100644
index c98acfa0d..000000000
--- a/packages/coding-agent/src/prompts/tools/job.md
+++ /dev/null
@@ -1,11 +0,0 @@
-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. The listing also names running subagents that have no job entry (e.g. agents woken via `irc`, or spawns owned by another agent) — those are coordinated through `irc`, not this tool.
diff --git a/packages/coding-agent/src/prompts/tools/launch.md b/packages/coding-agent/src/prompts/tools/launch.md
deleted file mode 100644
index 615e4f9e5..000000000
--- a/packages/coding-agent/src/prompts/tools/launch.md
+++ /dev/null
@@ -1,25 +0,0 @@
-Launches and controls project-scoped long-running processes shared by every omp instance in the same directory.
-
-<instruction>
-- Long-running service, watcher, debugger, REPL, or process needing later input? MUST use `launch`, not `bash`.
-- `start` launches `application` + `args` directly. `cwd` defaults to the session directory; `pty` defaults true.
-- `ready.log` is a regex; `ready.port` is a TCP port. Both supplied? BOTH MUST pass. `ready.timeout` is seconds.
-- Names are unique per project directory. A completed name MAY be started again; a live name MUST be stopped or restarted.
-- `list`, `logs`, `wait`, `send`, `stop`, `restart`, and `describe` address the stable `name`.
-- `logs` defaults to the last 100 lines. `head: true` reads the beginning. `grep` is a regex.
-- `logs` with `follow: true` waits for output after `cursor`; reuse the returned cursor on the next call.
-- `wait` blocks until readiness/exit/pattern or timeout. Use it only when blocked; do useful work instead of tight polling.
-- `send.text` writes stdin; `enter` defaults true. `keys` supports ENTER, TAB, ESCAPE, CTRL_C, CTRL_D, UP, DOWN, LEFT, RIGHT.
-- `send.signal` supports SIGINT, SIGTERM, SIGHUP, SIGQUIT, SIGKILL. PTY input is serialized; many clients MAY observe, but writes share one input stream.
-- `stop` performs graceful process-tree termination before hard-kill. `restart` reuses the retained launch spec.
-- `restart` policy defaults `no`; `on-failure` and `always` use bounded backoff.
-- `persist: true` opts out of last-omp teardown. Otherwise the broker stops every non-persistent supervised process after the last omp in this directory exits.
-- `detached: true` survives broker shutdown and all omp exits. It implies `persist` and disables PTY/stdin.
-</instruction>
-
-<critical>
-- Long-running work MUST use `launch`, not async/background bash.
-- Readiness MUST be observed; process creation alone is not readiness.
-- Omit `persist` and `detached` unless their survival guarantees are required.
-- Use `stop`; NEVER kill an unverified PID through bash.
-</critical>
diff --git a/packages/coding-agent/src/prompts/tools/resolve.md b/packages/coding-agent/src/prompts/tools/resolve.md
deleted file mode 100644
index 206360e87..000000000
--- a/packages/coding-agent/src/prompts/tools/resolve.md
+++ /dev/null
@@ -1,4 +0,0 @@
-Resolves a pending action — apply or discard. Valid only when a pending action exists; errors otherwise.
-- `action` (required): `"apply"` persists/submits; `"discard"` rejects.
-- `reason` (required): one short sentence explaining why.
-- `extra` (optional): free-form metadata. Plan-approval gate? Supply `extra.title` (kebab/PascalCase slug = approved plan filename). Unused for preview actions (e.g. `ast_edit`).
diff --git a/packages/coding-agent/src/prompts/tools/search-tool-bm25.md b/packages/coding-agent/src/prompts/tools/search-tool-bm25.md
deleted file mode 100644
index 75eea113a..000000000
--- a/packages/coding-agent/src/prompts/tools/search-tool-bm25.md
+++ /dev/null
@@ -1,32 +0,0 @@
-Search hidden tool metadata to discover and activate tools.
-
-Activate hidden tools (MCP and built-in) when you need a capability not in your active tool set.
-{{#if hasDiscoverableMCPServers}}
-Discoverable MCP servers in this session: {{#list discoverableMCPServerSummaries join=", "}}{{this}}{{/list}}.
-{{/if}}
-{{#if hasDiscoverableBuiltinTools}}
-Discoverable built-in tools: {{#list discoverableBuiltinToolNames join=", "}}{{this}}{{/list}}.
-{{/if}}
-{{#if discoverableToolCount}}
-Total discoverable tools available: {{discoverableToolCount}}.
-{{/if}}
-Input:
-- `query` — required natural-language or keyword query
-- `limit` — optional maximum number of tools to return and activate (default `8`)
-
-Behavior:
-- Matches against tool name, label, server name, description/summary, and input schema keys
-- Activates the top matching tools for the rest of the current session
-- Repeated searches add to the active tool set; they do not remove earlier selections
-- Newly activated tools become available before the next model call in the same overall turn
-
-Notes:
-- Start with `limit` 5–10 if unsure.
-
-Not for repository/file/code search. Tool discovery only.
-
-Returns JSON with:
-- `query`
-- `activated_tools` — tools activated by this search call
-- `match_count` — number of ranked matches returned by the search
-- `total_tools`
diff --git a/packages/coding-agent/src/prompts/tools/ssh.md b/packages/coding-agent/src/prompts/tools/ssh.md
deleted file mode 100644
index f8e351d05..000000000
--- a/packages/coding-agent/src/prompts/tools/ssh.md
+++ /dev/null
@@ -1,23 +0,0 @@
-Runs commands on remote hosts.
-
-<commands>
-**linux/bash, linux/zsh, macos/bash, macos/zsh** — Unix-like:
-- Files: `ls`, `cat`, `head`, `tail`, `grep`, `find`
-- System: `ps`, `top`, `df`, `uname` (all), `free` (Linux only)
-- Navigation: `cd`, `pwd`
-**windows/bash, windows/sh** — Windows Unix layer (WSL, Cygwin, Git Bash):
-- Files/System/Navigation: same as Unix-like above, minus `free`
-**windows/powershell** — PowerShell:
-- Files: `Get-ChildItem`, `Get-Content`, `Select-String`
-- System: `Get-Process`, `Get-ComputerInfo`
-- Navigation: `Set-Location`, `Get-Location`
-**windows/cmd** — Command Prompt:
-- Files: `dir`, `type`, `findstr`, `where`
-- System: `tasklist`, `systeminfo`
-- Navigation: `cd`, `echo %CD%`
-</commands>
-
-<critical>
-You MUST verify the shell type from "Available hosts" and use matching commands.
-You SHOULD omit `cwd` unless required. `cwd` MUST be an explicit remote path; NEVER use `~` or `~/…`.
-</critical>
diff --git a/packages/coding-agent/src/prompts/tools/task-summary.md b/packages/coding-agent/src/prompts/tools/task-summary.md
index 38bf32a34..a3ec08115 100644
--- a/packages/coding-agent/src/prompts/tools/task-summary.md
+++ b/packages/coding-agent/src/prompts/tools/task-summary.md
@@ -1,7 +1,7 @@
 <task-result id="{{id}}" agent="{{agentName}}" status="{{status}}" duration="{{duration}}">
 {{#if meta}}<meta lines="{{meta.lineCount}}" size="{{meta.charSize}}" />{{/if}}
 {{#if abortReason}}
-<abort-reason>{{abortReason}}{{#if resumable}} — the agent is still live with its full context; message it via `irc` to resume instead of redoing the work.{{/if}}</abort-reason>
+<abort-reason>{{abortReason}}{{#if resumable}} — the agent is still live with its full context; message it via `hub` to resume instead of redoing the work.{{/if}}</abort-reason>
 {{/if}}
 {{#if truncated}}
 <preview full-output="agent://{{id}}">
diff --git a/packages/coding-agent/src/registry/agent-registry.ts b/packages/coding-agent/src/registry/agent-registry.ts
index 84849bc9a..68580fbfc 100644
--- a/packages/coding-agent/src/registry/agent-registry.ts
+++ b/packages/coding-agent/src/registry/agent-registry.ts
@@ -3,7 +3,7 @@
  * every subagent), keyed by stable id.
  *
  * Tracks each agent's status and (when live) its AgentSession so peers can be
- * addressed by id (`irc`, `task resume`, `history://`). Sessions are
+ * addressed by id (`hub`, `task resume`, `history://`). Sessions are
  * registered explicitly at creation; finished agents stay registered as
  * `idle` (live) or `parked` (session disposed, ref + sessionFile retained for
  * revival) and are only removed on explicit release/teardown.
@@ -26,7 +26,7 @@ export type AgentStatus = "running" | "idle" | "parked" | "aborted";
  * - `main`/`sub`: the user-facing agent tree (driving agent + task subagents).
  * - `advisor`: a passive review transcript persisted like a subagent for usage
  *   attribution and Agent Hub observability, but never a peer — hidden from
- *   agent-facing rosters (`irc`, `history://`) and not messageable/revivable.
+ *   agent-facing rosters (`hub`, `history://`) and not messageable/revivable.
  */
 export type AgentKind = "main" | "sub" | "advisor";
 
diff --git a/packages/coding-agent/src/sdk.ts b/packages/coding-agent/src/sdk.ts
index c26ece940..788c51adc 100644
--- a/packages/coding-agent/src/sdk.ts
+++ b/packages/coding-agent/src/sdk.ts
@@ -148,40 +148,25 @@ import {
 	shouldDisableReasoning,
 	toReasoningEffort,
 } from "./thinking";
-import { countToolsForAutoDiscovery, resolveEffectiveToolDiscoveryMode } from "./tool-discovery/mode";
-import {
-	collectDiscoverableTools,
-	type DiscoverableTool,
-	filterBySource,
-	formatDiscoverableToolServerSummary,
-	isMCPToolName,
-	selectDiscoverableToolNamesByServer,
-	summarizeDiscoverableTools,
-} from "./tool-discovery/tool-index";
 import {
 	BashTool,
 	BUILTIN_TOOLS,
-	computeEssentialBuiltinNames,
 	createTools,
 	createVibeTools,
 	type DeferredDiagnosticsEntry,
 	discoverStartupLspServers,
 	EditTool,
 	EvalTool,
-	filterInitialToolsForDiscoveryAll,
 	GlobTool,
 	GrepTool,
 	getSearchTools,
 	HIDDEN_TOOLS,
 	isImageProviderPreference,
+	isMountableUnderXdev,
 	isSearchProviderId,
 	isSearchProviderPreference,
 	type LspStartupServerInfo,
-	loadSshTool,
 	ReadTool,
-	ResolveTool,
-	renderSearchToolBm25Description,
-	SearchToolBm25Tool,
 	setExcludedSearchProviders,
 	setPreferredImageProvider,
 	setPreferredSearchProvider,
@@ -191,11 +176,12 @@ import {
 	WriteTool,
 	warmupLspServers,
 } from "./tools";
-import { normalizeToolName, normalizeToolNames } from "./tools/builtin-names";
+import { isMCPToolName, normalizeToolNames } from "./tools/builtin-names";
 import { ToolContextStore } from "./tools/context";
+import { isIrcEnabled } from "./tools/hub";
 import { getImageGenTools } from "./tools/image-gen";
-import { isIrcEnabled } from "./tools/irc";
 import { wrapToolWithMetaNotice } from "./tools/output-meta";
+import { isAutoQaEnabled } from "./tools/report-tool-issue";
 import { queueResolveHandler } from "./tools/resolve";
 import { ttsTool } from "./tools/tts";
 import { resolveActiveRepoContext } from "./utils/active-repo-context";
@@ -316,12 +302,6 @@ function buildMcpNotificationBatchMessage(entries: McpNotificationEntry[]): Agen
 	};
 }
 
-type DeferredMCPActivation = {
-	mcpDiscoveryEnabled: boolean;
-	explicitlyRequestedMCPToolNames: string[];
-	activateAllMCPTools: boolean;
-};
-
 function createPendingMCPTool(name: string): Tool {
 	const parsed = parseMCPToolName(name);
 	const serverName = parsed?.serverName;
@@ -354,19 +334,12 @@ function createPendingMCPTool(name: string): Tool {
 	return tool;
 }
 
-function collectPendingMCPToolNames(
-	explicitToolNames: readonly string[] | undefined,
-	restoredSelectedToolNames: readonly string[],
-): string[] {
+function collectPendingMCPToolNames(explicitToolNames: readonly string[] | undefined): string[] {
 	const names = new Set<string>();
 	for (const name of explicitToolNames ?? []) {
 		const normalized = name.toLowerCase();
 		if (isMCPToolName(normalized)) names.add(normalized);
 	}
-	for (const name of restoredSelectedToolNames) {
-		const normalized = name.toLowerCase();
-		if (isMCPToolName(normalized)) names.add(normalized);
-	}
 	return [...names];
 }
 
@@ -641,9 +614,7 @@ export {
 	GlobTool,
 	GrepTool,
 	HIDDEN_TOOLS,
-	loadSshTool,
 	ReadTool,
-	ResolveTool,
 	type ToolSession,
 	WebSearchTool,
 	WriteTool,
@@ -919,6 +890,7 @@ function customToolToDefinition(tool: CustomTool): ToolDefinition {
 		description: tool.description,
 		parameters: tool.parameters,
 		hidden: tool.hidden,
+		loadMode: tool.loadMode ?? "discoverable",
 		deferrable: tool.deferrable,
 		approval: typeof tool.approval === "function" ? tool.approval.bind(tool) : tool.approval,
 		mcpServerName: tool.mcpServerName,
@@ -1628,15 +1600,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			getFileMutationVersion: path => fileMutationVersions.get(path) ?? 0,
 			getTodoPhases: () => session.getTodoPhases(),
 			setTodoPhases: phases => session.setTodoPhases(phases),
-			isMCPDiscoveryEnabled: () => session.isMCPDiscoveryEnabled(),
-			getSelectedMCPToolNames: () => session.getSelectedMCPToolNames(),
-			activateDiscoveredMCPTools: toolNames => session.activateDiscoveredMCPTools(toolNames),
-			// Generic tool discovery (unified — covers built-in + MCP + extension)
-			isToolDiscoveryEnabled: () => session.isToolDiscoveryEnabled(),
-			getDiscoverableTools: filter => session.getDiscoverableTools(filter),
-			getDiscoverableToolSearchIndex: () => session.getDiscoverableToolSearchIndex(),
-			getSelectedDiscoveredToolNames: () => session.getSelectedDiscoveredToolNames(),
-			activateDiscoveredTools: toolNames => session.activateDiscoveredTools(toolNames),
 			getCheckpointState: () => session.getCheckpointState(),
 			setCheckpointState: state => session.setCheckpointState(state ?? undefined),
 			getLastCompletedRewind: () => session.getLastCompletedRewind(),
@@ -1658,8 +1621,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			peekQueueInvoker: () => session.peekQueueInvoker(),
 			peekPendingInvoker: () => session.peekPendingInvoker(),
 			clearPendingInvokers: () => session.clearPendingInvokers(),
-			peekStandingResolveHandler: () => session.peekStandingResolveHandler(),
-			setStandingResolveHandler: handler => session.setStandingResolveHandler(handler),
+			peekPlanProposalHandler: () => session.peekPlanProposalHandler(),
+			setPlanProposalHandler: handler => session.setPlanProposalHandler(handler),
 			allocateOutputArtifact: async toolType => {
 				try {
 					return await sessionManager.allocateArtifactPath(toolType);
@@ -1720,9 +1683,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		const enableMCP = options.enableMCP ?? true;
 		const deferMCPDiscoveryForUI = enableMCP && !mcpManager && options.hasUI === true;
 		const customTools: CustomTool[] = [];
-		let startDeferredMCPDiscovery:
-			| ((liveSession: AgentSession, activation: DeferredMCPActivation) => void)
-			| undefined;
+		let startDeferredMCPDiscovery: ((liveSession: AgentSession) => void) | undefined;
 		const startupQuiet = settings.get("startup.quiet");
 		const onMCPStatus = (event: McpConnectionStatusEvent) => {
 			if (!options.hasUI || startupQuiet) return;
@@ -1749,7 +1710,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				}
 
 				const deferredMCPManager = mcpManager;
-				startDeferredMCPDiscovery = (liveSession, activation) => {
+				startDeferredMCPDiscovery = liveSession => {
 					void (async () => {
 						try {
 							const mcpResult = await logger.time("discoverAndLoadMCPTools", () =>
@@ -1764,31 +1725,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 							}
 							applyMCPEnvironment(mcpResult);
 							logMCPLoadErrors(mcpResult.errors);
-							// `tools.discoveryMode: "auto"` was resolved before deferred MCP
-							// tools existed. Reconcile again before refresh so a large toolset
-							// cannot bypass discovery by arriving after first paint.
-							let discoveryEnabled = activation.mcpDiscoveryEnabled;
-							let activateAll = activation.activateAllMCPTools;
-							if (
-								!discoveryEnabled &&
-								(await enableDeferredMCPDiscoveryForTools(liveSession, mcpResult.tools))
-							) {
-								discoveryEnabled = true;
-								activateAll = false;
-							}
-							await liveSession.refreshMCPTools(mcpResult.tools, { activateAll });
-							if (activation.explicitlyRequestedMCPToolNames.length > 0) {
-								if (discoveryEnabled && !activation.mcpDiscoveryEnabled) {
-									// Discovery flipped on mid-flight: route the explicit request
-									// through discovery-aware activation so selection persists.
-									await liveSession.activateDiscoveredMCPTools(activation.explicitlyRequestedMCPToolNames);
-								} else if (!discoveryEnabled && !activateAll) {
-									await liveSession.setActiveToolsByName([
-										...liveSession.getActiveToolNames(),
-										...activation.explicitlyRequestedMCPToolNames,
-									]);
-								}
-							}
+							// Connected MCP tools are enabled and mounted under xd:// devices.
+							await liveSession.refreshMCPTools(mcpResult.tools);
 						} catch (error) {
 							logger.error("MCP tool load failed", {
 								path: ".mcp.json",
@@ -1829,10 +1767,10 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		if (mcpManager && !options.parentTaskPrefix) MCPManager.setInstance(mcpManager);
 
 		// Add image tools when generation is enabled and either no explicit tool
-		// whitelist was given or it names `generate_image`. Unlike built-in tools
-		// (filtered in `createTools`), custom tools are force-activated via
-		// `alwaysInclude` below, so an explicit `--no-tools`/whitelist must be
-		// honored here or image-gen would leak past every filter (issue #5305).
+		// whitelist was given or it names `generate_image`. Image gen is a
+		// discoverable custom tool: once it enters the registry the common
+		// partition presents it under xd:// (or routes it to BM25 discovery), so no
+		// source-specific force-activation is needed — only this eligibility gate.
 		const imageGenRequested = !options.toolNames || options.toolNames.includes("generate_image");
 		if (settings.get("generate_image.enabled") && imageGenRequested) {
 			const imageGenTools = await logger.time("getImageGenTools", () => getImageGenTools(modelRegistry, model));
@@ -2288,7 +2226,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			builtInRegistryToolNames.delete(tool.name);
 		}
 		if (deferMCPDiscoveryForUI && mcpManager) {
-			for (const name of collectPendingMCPToolNames(options.toolNames, existingSession.selectedMCPToolNames)) {
+			for (const name of collectPendingMCPToolNames(options.toolNames)) {
 				if (!toolRegistry.has(name)) {
 					toolRegistry.set(name, createPendingMCPTool(name));
 				}
@@ -2306,81 +2244,27 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			builtInRegistryToolNames.delete("edit");
 		}
 
-		// `resolve` is hidden but must stay in the registry whenever any code path can invoke it:
-		// either a deferrable tool stages a preview action, or plan mode installs a standing handler
-		// that consumes `resolve { action: "apply" }` to submit the plan for approval (issue #1428).
-		// Dropping it on read-only sessions (e.g. plan-mode toolset `read`, `search`, `find`,
-		// `web_search`) leaves plan mode unable to exit through the intended path.
+		// Staged actions (tool previews, plan approval) resolve through `write`
+		// to the resolution devices (`xd://resolve`, `xd://reject`,
+		// `xd://propose`), so `write` must stay in the registry whenever any
+		// code path can stage one: a deferrable tool, or plan mode installing a
+		// plan-proposal handler (issue #1428). Dropping it on read-only sessions
+		// (e.g. plan-mode toolset `read`, `search`, `find`, `web_search`) leaves
+		// plan mode unable to exit through the intended path.
 		const hasDeferrableTools = Array.from(toolRegistry.values()).some(tool => tool.deferrable === true);
+		const hasXdevTools = (toolSession.xdevRegistry?.size ?? 0) > 0;
 		const planModeAvailable = settings.get("plan.enabled");
-		const needsResolveTool = hasDeferrableTools || planModeAvailable;
-		if (!needsResolveTool) {
-			toolRegistry.delete("resolve");
-			builtInRegistryToolNames.delete("resolve");
-		} else if (!toolRegistry.has("resolve")) {
-			const resolveTool = await logger.time("createTools:resolve:session", HIDDEN_TOOLS.resolve, toolSession);
-			if (resolveTool) {
-				toolRegistry.set(resolveTool.name, wrapToolWithMetaNotice(resolveTool));
-				builtInRegistryToolNames.add(resolveTool.name);
-			}
-		}
-
-		// `let`: the deferred MCP discovery closure upgrades these when the real
-		// MCP tool count pushes `auto` past its threshold; `rebuildSystemPrompt`
-		// below reads the live bindings.
-		let effectiveDiscoveryMode = resolveEffectiveToolDiscoveryMode(
-			settings,
-			countToolsForAutoDiscovery(toolRegistry.keys()),
-		);
-		if (effectiveDiscoveryMode !== "off" && !toolRegistry.has("search_tool_bm25")) {
-			const searchTool: Tool = new SearchToolBm25Tool(toolSession);
-			toolRegistry.set(
-				searchTool.name,
-				new ExtensionToolWrapper(wrapToolWithMetaNotice(searchTool), extensionRunner) as Tool,
-			);
-			builtInRegistryToolNames.add(searchTool.name);
-		}
-		let mcpDiscoveryEnabled = effectiveDiscoveryMode !== "off"; // back-compat: true when any discovery active
-
-		async function enableDeferredMCPDiscoveryForTools(
-			liveSession: AgentSession,
-			mcpTools: CustomTool[],
-		): Promise<boolean> {
-			if (mcpDiscoveryEnabled) return true;
-			const nonMCPToolNames = [...toolRegistry.keys()].filter(name => !isMCPToolName(name));
-			const projectedMode = resolveEffectiveToolDiscoveryMode(
-				settings,
-				countToolsForAutoDiscovery([...nonMCPToolNames, ...mcpTools.map(tool => tool.name)]),
-			);
-			if (projectedMode === "off") return false;
-
-			effectiveDiscoveryMode = projectedMode;
-			mcpDiscoveryEnabled = true;
-			liveSession.enableMCPDiscovery();
-			if (!toolRegistry.has("search_tool_bm25")) {
-				const searchTool: Tool = new SearchToolBm25Tool(toolSession);
+		if ((hasDeferrableTools || hasXdevTools || planModeAvailable) && !toolRegistry.has("write")) {
+			const writeTool = await logger.time("createTools:write:session", BUILTIN_TOOLS.write, toolSession);
+			if (writeTool) {
 				toolRegistry.set(
-					searchTool.name,
-					new ExtensionToolWrapper(wrapToolWithMetaNotice(searchTool), extensionRunner) as Tool,
+					writeTool.name,
+					new ExtensionToolWrapper(wrapToolWithMetaNotice(writeTool), extensionRunner) as Tool,
 				);
+				builtInRegistryToolNames.add(writeTool.name);
 			}
-			if (!liveSession.getActiveToolNames().includes("search_tool_bm25")) {
-				await liveSession.setActiveToolsByName([...liveSession.getActiveToolNames(), "search_tool_bm25"]);
-			}
-			return true;
 		}
 
-		const reloadSshTool = async (): Promise<AgentTool | null> => {
-			if (!requestedToolNameSet.has("ssh")) return null;
-			const sshTool = (await loadSshTool({
-				...toolSession,
-				cwd: sessionManager.getCwd(),
-			})) as unknown as AgentTool | null;
-			if (!sshTool) return null;
-			const wrapped = wrapToolWithMetaNotice(sshTool);
-			return new ExtensionToolWrapper(wrapped, extensionRunner) as AgentTool;
-		};
-
 		let cursorEventEmitter: ((event: AgentEvent) => void) | undefined;
 		const cursorExecHandlers = new CursorExecHandlers({
 			cwd,
@@ -2403,26 +2287,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			tools: Map<string, AgentTool>,
 		): Promise<BuildSystemPromptResult> => {
 			toolContextStore.setToolNames(toolNames);
-			const discoverableMCPTools: DiscoverableTool[] = mcpDiscoveryEnabled
-				? filterBySource(collectDiscoverableTools(tools.values()), "mcp")
-				: [];
-			const activeToolNames = new Set(toolNames);
-			const discoverableBuiltinTools: DiscoverableTool[] =
-				effectiveDiscoveryMode === "all"
-					? collectDiscoverableTools(
-							Array.from(tools.values()).filter(
-								tool => tool.loadMode === "discoverable" && !activeToolNames.has(tool.name),
-							),
-							{ source: "builtin" },
-						)
-					: [];
-			const discoverableToolsForDesc: DiscoverableTool[] = [...discoverableBuiltinTools, ...discoverableMCPTools];
-			const discoverableToolSummary = summarizeDiscoverableTools(discoverableToolsForDesc);
-			const hasDiscoverableTools =
-				mcpDiscoveryEnabled && toolNames.includes("search_tool_bm25") && discoverableToolsForDesc.length > 0;
-			const promptTools = buildSystemPromptToolMetadata(tools, {
-				search_tool_bm25: { description: renderSearchToolBm25Description(discoverableToolsForDesc) },
-			});
+			const promptTools = buildSystemPromptToolMetadata(tools);
 			const memoryBackend = await resolveMemoryBackend(settings);
 			const memoryInstructions = await memoryBackend.buildDeveloperInstructions(agentDir, settings, session);
 
@@ -2472,6 +2337,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			}
 			const defaultPrompt = await buildSystemPromptInternal({
 				cwd,
+				xdevTools: toolSession.xdevRegistry?.entries() ?? [],
+				xdevDocs: toolSession.xdevRegistry?.docsAll() ?? "",
+				autoQaEnabled: isAutoQaEnabled(settings),
 				resolvedCustomPrompt: options.customSystemPrompt,
 				skills,
 				contextFiles,
@@ -2484,8 +2352,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				inlineToolDescriptors,
 				nativeTools,
 				intentField,
-				mcpDiscoveryMode: hasDiscoverableTools,
-				mcpDiscoveryServerSummaries: discoverableToolSummary.servers.map(formatDiscoverableToolServerSummary),
 				eagerTasks,
 				eagerTasksAlways,
 				taskBatch: settings.get("task.batch"),
@@ -2545,7 +2411,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		const requestedToolNames = explicitlyRequestedToolNames ?? toolNamesFromRegistry;
 		const normalizedRequested = requestedToolNames.filter(name => toolRegistry.has(name));
 		const requestedToolNameSet = new Set(normalizedRequested);
-		// Effective discovery mode is resolved after the full registry exists so auto mode can count MCP/extension tools.
 		const defaultInactiveToolNames = new Set(
 			registeredTools.filter(tool => tool.definition.defaultInactive).map(tool => tool.definition.name),
 		);
@@ -2553,39 +2418,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		const initialRequestedActiveToolNames = options.toolNames
 			? requestedActiveToolNames
 			: requestedActiveToolNames.filter(name => !defaultInactiveToolNames.has(name));
-		const explicitlyRequestedMCPToolNames = options.toolNames
-			? requestedActiveToolNames.filter(name => name.startsWith("mcp__"))
-			: [];
-		const discoveryDefaultServers = new Set(
-			(settings.get("mcp.discoveryDefaultServers") ?? []).map(serverName => serverName.trim()).filter(Boolean),
-		);
-		const discoveryDefaultServerToolNames = mcpDiscoveryEnabled
-			? selectDiscoverableToolNamesByServer(
-					filterBySource(collectDiscoverableTools(toolRegistry.values()), "mcp"),
-					discoveryDefaultServers,
-				)
-			: [];
-		const normalizeRenamedBuiltinToolName = normalizeToolName;
-		let initialSelectedMCPToolNames: string[] = [];
-		let defaultSelectedMCPToolNames: string[] = [];
 		let initialToolNames = [...initialRequestedActiveToolNames];
-		if (mcpDiscoveryEnabled) {
-			const restoredSelectedMCPToolNames = existingSession.selectedMCPToolNames
-				.map(normalizeRenamedBuiltinToolName)
-				.filter(name => toolRegistry.has(name));
-			defaultSelectedMCPToolNames = [
-				...new Set([...discoveryDefaultServerToolNames, ...explicitlyRequestedMCPToolNames]),
-			];
-			initialSelectedMCPToolNames = existingSession.hasPersistedMCPToolSelection
-				? restoredSelectedMCPToolNames
-				: [...new Set([...restoredSelectedMCPToolNames, ...defaultSelectedMCPToolNames])];
-			initialToolNames = [
-				...new Set([
-					...initialRequestedActiveToolNames.filter(name => !name.startsWith("mcp__")),
-					...initialSelectedMCPToolNames,
-				]),
-			];
-		}
 
 		// Custom tools and extension-registered tools are always included regardless of toolNames filter
 		const alwaysInclude: string[] = [
@@ -2593,42 +2426,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			...registeredTools.filter(t => !t.definition.defaultInactive).map(t => t.definition.name),
 		];
 		for (const name of alwaysInclude) {
-			if (mcpDiscoveryEnabled && name.startsWith("mcp__")) {
-				continue;
-			}
 			if (toolRegistry.has(name) && !initialToolNames.includes(name)) {
 				initialToolNames.push(name);
 			}
 		}
 
-		// When tools.discoveryMode === "all", hide non-essential built-in discoverable tools
-		// from the initial set unless they were explicitly requested or restored from persistence.
-		// The model finds them via search_tool_bm25 and activates them on demand.
-		if (effectiveDiscoveryMode === "all") {
-			// Tools a forced tool_choice will target must stay active, or the named
-			// choice references a tool absent from the request (provider 400). Eager
-			// todos force a named `todo` choice on the first turn. `task` is also kept
-			// active under discovery-all when `task.eager` is not `default`, so eager delegation is
-			// possible and the Eager Tasks prompt section renders, even though nothing
-			// forces a `task` tool_choice.
-			const forceActive = new Set<string>();
-			if (settings.get("todo.eager") !== "default" && settings.get("todo.enabled") && toolRegistry.has("todo")) {
-				forceActive.add("todo");
-			}
-			if (settings.get("task.eager") !== "default" && toolRegistry.has("task")) {
-				forceActive.add("task");
-			}
-			initialToolNames = filterInitialToolsForDiscoveryAll(initialToolNames, {
-				loadModeOf: name => toolRegistry.get(name)?.loadMode,
-				essentialNames: new Set(computeEssentialBuiltinNames(settings)),
-				explicitlyRequested: new Set(options.toolNames ? normalizeToolNames(options.toolNames) : []),
-				// Back-compat: persisted activations live under selectedMCPToolNames today (built-in
-				// activation persistence is a follow-up). MCP names won't collide with built-in names.
-				restored: new Set(existingSession.selectedMCPToolNames.map(normalizeRenamedBuiltinToolName)),
-				forceActive,
-			});
-		}
-
 		// Pre-register in the global agent registry BEFORE building the system prompt,
 		// so that subagents launched in the same parallel batch can see each other in
 		// their initial `# IRC Peers` block (rendered inside `rebuildSystemPrompt`).
@@ -2644,6 +2446,26 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		});
 		hasRegistered = true;
 
+		// Partition the initial enabled set for the xd:// transport: discoverable
+		// tools become mounted devices; the rest stay top-level. The registry
+		// already holds the built-in devices (mounted in createTools); this
+		// reconciles the initial dynamic mounts (image-gen, TTS, startup MCP,
+		// active extension tools) and drops them from the top-level names so they
+		// never ship a schema. Presentation only — selection already happened.
+		let initialMountedXdevToolNames: string[] = [];
+		if (toolSession.xdevRegistry) {
+			const topLevelToolNames: string[] = [];
+			const mountedTools: Tool[] = [];
+			for (const name of initialToolNames) {
+				const tool = toolRegistry.get(name);
+				if (tool && isMountableUnderXdev(tool)) mountedTools.push(tool);
+				else topLevelToolNames.push(name);
+			}
+			toolSession.xdevRegistry.reconcile(mountedTools);
+			initialMountedXdevToolNames = mountedTools.map(tool => tool.name);
+			initialToolNames = topLevelToolNames;
+		}
+
 		setActiveToolNames(initialToolNames);
 		const { systemPrompt } = await logger.time(
 			"buildSystemPrompt",
@@ -2932,7 +2754,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			preferWebsockets: preferOpenAICodexWebsockets,
 			convertToLlm: convertToLlmFinal,
 			rebuildSystemPrompt,
-			reloadSshTool,
+			getXdevToolEntries: () => toolSession.xdevRegistry?.entries() ?? [],
+			xdevRegistry: toolSession.xdevRegistry,
+			initialMountedXdevToolNames,
 			requestedToolNames: requestedToolNameSet,
 			setActiveToolNames,
 			getMcpServerInstructions: mcpManager
@@ -2950,11 +2774,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 					}
 				: undefined,
 			disconnectOwnedMcpManager: ownedMcpManager ? () => ownedMcpManager.disconnectAll() : undefined,
-			mcpDiscoveryEnabled,
-			initialSelectedMCPToolNames,
-			defaultSelectedMCPToolNames,
-			persistInitialMCPToolSelection: !hasExistingSession,
-			defaultSelectedMCPServerNames: [...discoveryDefaultServers],
 			ttsrManager,
 			obfuscator,
 			agentId: resolvedAgentId,
@@ -3126,11 +2945,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			mcpManager.setOnToolsChanged(tools => {
 				void (async () => {
 					try {
-						let activateAll = deferMCPDiscoveryForUI && !mcpDiscoveryEnabled;
-						if (activateAll && (await enableDeferredMCPDiscoveryForTools(session, tools))) {
-							activateAll = false;
-						}
-						await session.refreshMCPTools(tools, activateAll ? { activateAll: true } : undefined);
+						await session.refreshMCPTools(tools);
 					} catch (error) {
 						logger.warn("MCP tool refresh failed", {
 							error: error instanceof Error ? error.message : String(error),
@@ -3169,11 +2984,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			});
 		}
 
-		startDeferredMCPDiscovery?.(session, {
-			mcpDiscoveryEnabled,
-			explicitlyRequestedMCPToolNames,
-			activateAllMCPTools: !mcpDiscoveryEnabled,
-		});
+		startDeferredMCPDiscovery?.(session);
 
 		return {
 			session,
diff --git a/packages/coding-agent/src/session/agent-session.ts b/packages/coding-agent/src/session/agent-session.ts
index d44123031..e6f6904cd 100644
--- a/packages/coding-agent/src/session/agent-session.ts
+++ b/packages/coding-agent/src/session/agent-session.ts
@@ -170,7 +170,6 @@ import {
 } from "../advisor";
 import { type AsyncJob, type AsyncJobDeliveryState, AsyncJobManager } from "../async";
 import { classifyDifficulty } from "../auto-thinking/classifier";
-import { reset as resetCapabilities } from "../capability";
 import type { Rule } from "../capability/rule";
 import { shouldEnableAppendOnlyContext } from "../config/append-only-context-mode";
 import type { ModelRegistry } from "../config/model-registry";
@@ -198,7 +197,6 @@ import {
 	validateProviderMaxInFlightRequests,
 } from "../config/settings";
 import { RawSseDebugBuffer } from "../debug/raw-sse-buffer";
-import { loadCapability } from "../discovery";
 import { expandApplyPatchToEntries, normalizeDiff, normalizeToLF, ParseError, previewPatch, stripBom } from "../edit";
 import { getFileSnapshotStore } from "../edit/file-snapshot-store";
 import { disposeJuliaKernelSessionsByOwner } from "../eval/jl/executor";
@@ -296,7 +294,6 @@ import {
 	obfuscateProviderContext,
 	type SecretObfuscator,
 } from "../secrets/obfuscator";
-import { invalidateHostMetadata } from "../ssh/connection-manager";
 import { usesCodexTaskPrompt } from "../task/prompt-policy";
 import {
 	AUTO_THINKING,
@@ -311,27 +308,24 @@ import {
 } from "../thinking";
 import { formatTitleConversationContext, type TitleConversationTurn } from "../tiny/message-preproc";
 import { shutdownTinyTitleClient } from "../tiny/title-client";
-import { countToolsForAutoDiscovery, resolveEffectiveToolDiscoveryMode } from "../tool-discovery/mode";
-import {
-	buildDiscoverableToolSearchIndex,
-	collectDiscoverableTools,
-	type DiscoverableTool,
-	type DiscoverableToolSearchIndex,
-	filterBySource,
-	isMCPToolName,
-	selectDiscoverableToolNamesByServer,
-} from "../tool-discovery/tool-index";
 import { assertEditableFile } from "../tools/auto-generated-guard";
 import { releaseTabsForOwner } from "../tools/browser/tab-supervisor";
-import { normalizeToolNames } from "../tools/builtin-names";
+import { isMCPToolName, normalizeToolNames } from "../tools/builtin-names";
 import type { CheckpointState, CompletedRewindState } from "../tools/checkpoint";
 import { outputMeta, wrapToolWithMetaNotice } from "../tools/output-meta";
 import { normalizeLocalScheme, resolveToCwd } from "../tools/path-utils";
-import { isAutoQaEnabled } from "../tools/report-tool-issue";
-import { buildResolveReminderMessage, type ResolveToolDetails, runResolveInvocation } from "../tools/resolve";
+import {
+	buildResolveReminderMessage,
+	isPreviewResolutionToolCall,
+	isProposeToolCall,
+	type PlanProposalHandler,
+	PROPOSE_DEVICE_NAME,
+	writeDeviceDispatch,
+} from "../tools/resolve";
 import { getLatestTodoPhasesFromEntries, type TodoItem, type TodoPhase } from "../tools/todo";
 import { ToolAbortError, ToolError } from "../tools/tool-errors";
 import { clampTimeout } from "../tools/tool-timeouts";
+import { isMountableUnderXdev, type XdevRegistry } from "../tools/xdev";
 import { parseCommandArgs } from "../utils/command-args";
 import { type EditMode, resolveEditMode } from "../utils/edit-mode";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
@@ -396,7 +390,6 @@ import { YieldQueue } from "./yield-queue";
 
 const SESSION_STOP_CONTINUATION_CAP = 8;
 const PLAN_MODE_REMINDER_MAX = 3;
-const PLAN_DECISION_TOOLS = new Set(["ask", "resolve"]);
 
 /**
  * Mutating tool results (`bash`/`eval`/`edit`/`write`/`ast_edit`) without the
@@ -815,7 +808,7 @@ export interface AgentSessionConfig {
 	/** Prewalk from the starting model to a fast/cheap target at the first edit/write once the todo list exists. */
 	prewalk?: Prewalk;
 	/** Force read-only plan mode at start, auto-approve on the model's first
-	 *  `resolve` call, then switch to the target to implement. */
+	 *  plan proposal (`write xd://propose`), then switch to the target to implement. */
 	planYolo?: PlanYolo;
 
 	/** Initial per-family service tiers (OpenAI / Anthropic / Google) for the live session. */
@@ -883,8 +876,12 @@ export interface AgentSessionConfig {
 	rebuildSystemPrompt?: (toolNames: string[], tools: Map<string, AgentTool>) => Promise<{ systemPrompt: string[] }>;
 	/** Local calendar date provider used by prompt-cache invalidation. Defaults to the host local date. */
 	getLocalCalendarDate?: () => string;
-	/** Rebuild the SSH tool from current capability discovery results. */
-	reloadSshTool?: () => Promise<AgentTool | null>;
+	/** Entries of tools mounted under `xd://` (name + one-line summary), for /tools display. */
+	getXdevToolEntries?: () => Array<{ name: string; summary: string }>;
+	/** Session-owned `xd://` device registry; reconciled as the active tool set changes. */
+	xdevRegistry?: XdevRegistry;
+	/** Discoverable tools mounted under `xd://` in the initial enabled set (startup partition in `sdk.ts`). */
+	initialMountedXdevToolNames?: string[];
 	requestedToolNames?: ReadonlySet<string>;
 	/**
 	 * Optional accessor for live MCP server instructions. Read by the session's
@@ -893,16 +890,6 @@ export interface AgentSessionConfig {
 	 * signature comparison and silently keep a stale prompt cached.
 	 */
 	getMcpServerInstructions?: () => Map<string, string> | undefined;
-	/** Enable hidden-by-default MCP tool discovery for this session. */
-	mcpDiscoveryEnabled?: boolean;
-	/** MCP tool names to activate for the current session when discovery mode is enabled. */
-	initialSelectedMCPToolNames?: string[];
-	/** Whether constructor-provided MCP defaults should be persisted immediately. */
-	persistInitialMCPToolSelection?: boolean;
-	/** MCP server names whose tools should seed discovery-mode sessions whenever those servers are connected. */
-	defaultSelectedMCPServerNames?: string[];
-	/** MCP tool names that should seed brand-new sessions created from this AgentSession. */
-	defaultSelectedMCPToolNames?: string[];
 	/** TTSR manager for time-traveling stream rules */
 	ttsrManager?: TtsrManager;
 	/** Secret obfuscator for deobfuscating streaming edit content */
@@ -1730,6 +1717,8 @@ export class AgentSession {
 	readonly agent: Agent;
 	readonly sessionManager: SessionManager;
 	readonly settings: Settings;
+	/** Entries of tools mounted under `xd://`; empty when virtual devices are unmounted. */
+	getXdevToolEntries: () => Array<{ name: string; summary: string }>;
 	readonly yieldQueue: YieldQueue;
 	fileSnapshotStore?: InMemorySnapshotStore;
 	#autoApprove: boolean;
@@ -1748,8 +1737,6 @@ export class AgentSession {
 	#prewalk: Prewalk | undefined;
 	/** True once the plan nudge has been queued; scrubbed from context at the switch. */
 	#prewalkPlanInjected = false;
-	/** Armed by plan/tool progress; consumed by one text-only continuation. */
-	#prewalkContinuePending = false;
 	/** True once any successful `todo` call landed — opens the prewalk
 	 *  trigger gate: the switch fires at the first edit/write AFTER the todo
 	 *  list exists (sessions without an ACTIVE todo tool skip the gate). */
@@ -1936,7 +1923,6 @@ export class AgentSession {
 		| undefined;
 	#getLocalCalendarDate: () => string;
 	#getMcpServerInstructions: (() => Map<string, string> | undefined) | undefined;
-	#reloadSshTool: (() => Promise<AgentTool | null>) | undefined;
 	#setActiveToolNames: ((names: Iterable<string>) => void) | undefined;
 	#disconnectOwnedMcpManager: (() => Promise<void>) | undefined;
 	#requestedToolNames: ReadonlySet<string> | undefined;
@@ -1956,17 +1942,12 @@ export class AgentSession {
 	 * to decide whether the cached prompt is stale.
 	 */
 	#promptModelKey: string | undefined;
-	#mcpDiscoveryEnabled = false;
-	#discoverableMCPTools = new Map<string, DiscoverableTool>();
-	#selectedMCPToolNames = new Set<string>();
-	// Generic tool discovery (covers built-in + MCP + extension when tools.discoveryMode === "all")
-	#discoverableToolSearchIndex: DiscoverableToolSearchIndex | null = null;
-	#selectedDiscoveredToolNames = new Set<string>();
 	#builtInToolNames = new Set<string>();
 	#rpcHostToolNames = new Set<string>();
-	#defaultSelectedMCPServerNames = new Set<string>();
-	#defaultSelectedMCPToolNames = new Set<string>();
-	#sessionDefaultSelectedMCPToolNames = new Map<string, string[]>();
+	/** Session-owned `xd://` device registry (built-ins + dynamic mounts); `undefined` when the transport is off. */
+	#xdevRegistry: XdevRegistry | undefined;
+	/** Names of discoverable tools currently mounted under `xd://` (dynamic mounts only, not built-in devices). */
+	#mountedXdevToolNames = new Set<string>();
 
 	// TTSR manager for time-traveling stream rules
 	#ttsrManager: TtsrManager | undefined = undefined;
@@ -1981,7 +1962,7 @@ export class AgentSession {
 	#ttsrResumeResolve: (() => void) | undefined = undefined;
 
 	/** One-shot flag for expected internal plan-mode aborts. Approval actions may
-	 *  abort the post-`resolve` continuation before compaction, execution, or
+	 *  abort the post-approval continuation before compaction, execution, or
 	 *  manual refinement. Consumed inside `#handleAgentEvent` for the matching
 	 *  `message_end` + `stopReason: "aborted"`; callers clear it in `finally` so
 	 *  it cannot leak into later unrelated aborts. */
@@ -2249,23 +2230,15 @@ export class AgentSession {
 		const prewalk = this.#prewalk;
 		if (!prewalk || context?.message.role !== "assistant") return;
 
-		const todoCalledThisTurn = context.toolResults.some(result => result.toolName === "todo");
-		if (todoCalledThisTurn) {
-			this.#prewalkTodoSeen = true;
-		}
-
-		// The plan nudge asks for a prose plan before implementation begins,
-		// but the agent loop treats each text-only reply as terminal. Tool
-		// progress re-arms one continuation, allowing split flows such as
-		// plan → todo → prose → read → prose → edit/write. Consuming the arm
-		// before steering also detects completion: two consecutive text-only
-		// replies have no intervening progress, so the second ends naturally
-		// instead of producing the #5551 loop.
-		const hasToolResults = context.toolResults.length > 0;
-		if (this.#prewalkPlanInjected && hasToolResults) {
-			this.#prewalkContinuePending = true;
-		} else if (this.#prewalkContinuePending) {
-			this.#prewalkContinuePending = false;
+		// Structural safety net: every branch below assumes the agent loop will
+		// run another turn. It won't if THIS turn had no tool calls — the loop
+		// treats a text-only turn as "the agent is done" and ends the session
+		// with no further prompting. The plan nudge explicitly asks for a prose
+		// reply, which makes a text-only turn common right after it — observed
+		// silently killing production SWE-bench runs before any code was ever
+		// written. Force one more turn only in that specific, self-created
+		// hazard window.
+		if (this.#prewalkPlanInjected && context.toolResults.length === 0) {
 			this.agent.steer({
 				role: "custom",
 				customType: PREWALK_CONTINUE_MESSAGE_TYPE,
@@ -2291,7 +2264,6 @@ export class AgentSession {
 		if (!action) {
 			if (!this.#prewalkPlanInjected) {
 				this.#prewalkPlanInjected = true;
-				this.#prewalkContinuePending = true;
 				this.agent.steer({
 					role: "custom",
 					customType: PREWALK_PLAN_MESSAGE_TYPE,
@@ -2352,7 +2324,6 @@ export class AgentSession {
 		}
 		this.#prewalk = { target, thinkingLevel };
 		this.#prewalkPlanInjected = true;
-		this.#prewalkContinuePending = true;
 		this.agent.steer({
 			role: "custom",
 			customType: PREWALK_PLAN_MESSAGE_TYPE,
@@ -2390,18 +2361,17 @@ export class AgentSession {
 
 	/**
 	 * Lazily arm PlanYolo before the first prompt is built: restricts tools to
-	 * the plan-mode read-only set (plus `resolve`/`write`, both normally
-	 * discovery-hidden), marks plan-mode state so `#buildPlanModeMessage`
-	 * injects the standard plan-mode-active instructions on this and every
-	 * following prompt, and registers the auto-approve resolve handler.
+	 * the plan-mode read-only set (plus `write`, which carries the resolution
+	 * devices including `xd://propose`), marks plan-mode state so
+	 * `#buildPlanModeMessage` injects the standard plan-mode-active instructions
+	 * on this and every following prompt, and registers the auto-approve plan-proposal handler.
 	 * Idempotent — a no-op once armed or when PlanYolo is not configured.
 	 */
 	async #armPlanYoloIfNeeded(): Promise<void> {
 		if (!this.#planYolo || this.#planYoloArmed) return;
 		this.#planYoloArmed = true;
-		const previousTools = this.getActiveToolNames();
-		const augmentations = ["resolve"];
-		if (this.hasBuiltInTool("write")) augmentations.push("write");
+		const previousTools = this.getEnabledToolNames();
+		const augmentations = this.hasBuiltInTool("write") ? ["write"] : [];
 		await this.setActiveToolsByName([...new Set([...previousTools, ...augmentations])]);
 		this.#planYoloPreviousTools = previousTools;
 		this.setPlanModeState({
@@ -2409,63 +2379,58 @@ export class AgentSession {
 			planFilePath: this.getPlanReferencePath() || "local://PLAN.md",
 			workflow: "parallel",
 		});
-		this.setStandingResolveHandler(input => this.#runPlanYoloApprovalResolve(input));
+		this.setPlanProposalHandler(title => this.#approvePlanYoloProposal(title));
 	}
 
 	/**
-	 * Standing resolve handler while PlanYolo's plan phase is active. Auto-
-	 * approves the instant the model calls `resolve { action: "apply" }` for
-	 * the plan — no interactive review, the headless counterpart to plan
-	 * mode's "Approve and execute" — then restores tools, exits plan-mode
-	 * state, switches to the configured `target`, and hands off the approved
-	 * plan for it to implement.
+	 * Plan-proposal handler while PlanYolo's plan phase is active. Auto-approves
+	 * the instant the model writes the plan slug/title to `xd://propose` — no
+	 * interactive review, the headless counterpart to plan mode's "Approve and
+	 * execute" — then restores tools, exits plan-mode state, switches to the
+	 * configured `target`, and hands off the approved plan for it to implement.
 	 */
-	#runPlanYoloApprovalResolve(input: unknown): Promise<AgentToolResult<ResolveToolDetails>> {
-		return runResolveInvocation(input as Parameters<typeof runResolveInvocation>[0], {
-			sourceToolName: "plan_approval",
-			label: "Plan ready for approval",
-			apply: async (_reason, extra) => {
-				const planYolo = this.#planYolo;
-				const state = this.getPlanModeState();
-				if (!planYolo || !state?.enabled) {
-					throw new ToolError("Plan mode is not active.");
-				}
-				const { planFilePath, title } = await resolveApprovedPlan({
-					suppliedTitle: extra?.title,
-					statePlanFilePath: state.planFilePath,
-					readPlan: url => this.#readPlanYoloFile(url),
-					listPlanFiles: () => this.#listPlanYoloFiles(),
-				});
-				const previousTools = this.#planYoloPreviousTools;
-				if (previousTools) {
-					await this.setActiveToolsByName(previousTools);
-				}
-				this.setStandingResolveHandler(null);
-				this.setPlanModeState(undefined);
-				this.#planYolo = undefined;
-				this.#planYoloPreviousTools = undefined;
-				await this.setModelTemporary(planYolo.target, planYolo.thinkingLevel, { ephemeral: true });
-				this.emitNotice(
-					"info",
-					`Plan-yolo: plan approved, switched to ${planYolo.target.provider}/${planYolo.target.id} to implement "${title}".`,
-					"plan-yolo",
-				);
-				this.agent.steer({
-					role: "custom",
-					customType: PLAN_YOLO_HANDOFF_MESSAGE_TYPE,
-					content: prompt.render(planYoloHandoffPrompt, { planFilePath, title }),
-					attribution: "agent",
-					display: false,
-					timestamp: Date.now(),
-				});
-				return {
-					content: [
-						{ type: "text" as const, text: `Plan approved. Implementing now with ${planYolo.target.id}.` },
-					],
-					details: { planFilePath, title, planExists: true },
-				};
-			},
+	#approvePlanYoloProposal(title: string): Promise<AgentToolResult<unknown>> {
+		return this.#finalizePlanYoloProposal(title);
+	}
+
+	async #finalizePlanYoloProposal(title: string): Promise<AgentToolResult<unknown>> {
+		const planYolo = this.#planYolo;
+		const state = this.getPlanModeState();
+		if (!planYolo || !state?.enabled) {
+			throw new ToolError("Plan mode is not active.");
+		}
+		const { planFilePath, title: resolvedTitle } = await resolveApprovedPlan({
+			suppliedTitle: title,
+			statePlanFilePath: state.planFilePath,
+			readPlan: url => this.#readPlanYoloFile(url),
+			listPlanFiles: () => this.#listPlanYoloFiles(),
 		});
+		const previousTools = this.#planYoloPreviousTools;
+		if (previousTools) {
+			await this.setActiveToolsByName(previousTools);
+		}
+		this.setPlanProposalHandler(null);
+		this.setPlanModeState(undefined);
+		this.#planYolo = undefined;
+		this.#planYoloPreviousTools = undefined;
+		await this.setModelTemporary(planYolo.target, planYolo.thinkingLevel, { ephemeral: true });
+		this.emitNotice(
+			"info",
+			`Plan-yolo: plan approved, switched to ${planYolo.target.provider}/${planYolo.target.id} to implement "${resolvedTitle}".`,
+			"plan-yolo",
+		);
+		this.agent.steer({
+			role: "custom",
+			customType: PLAN_YOLO_HANDOFF_MESSAGE_TYPE,
+			content: prompt.render(planYoloHandoffPrompt, { planFilePath, title: resolvedTitle }),
+			attribution: "agent",
+			display: false,
+			timestamp: Date.now(),
+		});
+		return {
+			content: [{ type: "text" as const, text: `Plan approved. Implementing now with ${planYolo.target.id}.` }],
+			details: { planFilePath, title: resolvedTitle, planExists: true },
+		};
 	}
 
 	async #readPlanYoloFile(planFilePath: string): Promise<string | null> {
@@ -2634,7 +2599,7 @@ export class AgentSession {
 		// Background-job completions / late diagnostics are pulled into the run at
 		// each step boundary as non-interrupting asides. Peer IRCs share the aside
 		// injection boundary, but also expose a non-consuming interrupt peek so
-		// `job poll` / `irc wait` can return early before the boundary drains them.
+		// `hub` waits can return early before the boundary drains them.
 		this.agent.hasIrcInterrupts = () => this.#pendingIrcInterrupts.length > 0;
 		this.agent.setAsideMessageProvider(() => {
 			const pendingIrc = [...this.#pendingIrcInterrupts, ...this.#pendingIrcAsides];
@@ -2651,32 +2616,13 @@ export class AgentSession {
 		this.#rebuildSystemPrompt = config.rebuildSystemPrompt;
 		this.#getLocalCalendarDate = config.getLocalCalendarDate ?? formatLocalCalendarDate;
 		this.#getMcpServerInstructions = config.getMcpServerInstructions;
-		this.#reloadSshTool = config.reloadSshTool;
+		this.getXdevToolEntries = config.getXdevToolEntries ?? (() => []);
+		this.#xdevRegistry = config.xdevRegistry;
+		this.#mountedXdevToolNames = new Set(config.initialMountedXdevToolNames ?? []);
 		this.#setActiveToolNames = config.setActiveToolNames;
 		this.#disconnectOwnedMcpManager = config.disconnectOwnedMcpManager;
 		this.#baseSystemPrompt = this.agent.state.systemPrompt;
 		this.#promptModelKey = this.#currentPromptModelKey();
-		this.#mcpDiscoveryEnabled = config.mcpDiscoveryEnabled ?? false;
-		this.#setDiscoverableMCPTools(this.#collectDiscoverableMCPToolsFromRegistry());
-		this.#selectedMCPToolNames = new Set(config.initialSelectedMCPToolNames ?? []);
-		this.#defaultSelectedMCPServerNames = new Set(config.defaultSelectedMCPServerNames ?? []);
-		this.#defaultSelectedMCPToolNames = new Set(config.defaultSelectedMCPToolNames ?? []);
-		this.#pruneSelectedMCPToolNames();
-		const persistedSelectedMCPToolNames = this.buildDisplaySessionContext().selectedMCPToolNames;
-		const currentSelectedMCPToolNames = this.getSelectedMCPToolNames();
-		const persistInitialMCPToolSelection =
-			config.persistInitialMCPToolSelection ?? this.sessionManager.getBranch().length === 0;
-		if (
-			this.#mcpDiscoveryEnabled &&
-			persistInitialMCPToolSelection &&
-			!this.#selectedMCPToolNamesMatch(persistedSelectedMCPToolNames, currentSelectedMCPToolNames)
-		) {
-			this.sessionManager.appendMCPToolSelection(currentSelectedMCPToolNames);
-		}
-		this.#rememberSessionDefaultSelectedMCPToolNames(
-			this.sessionManager.getSessionFile(),
-			this.#getConfiguredDefaultSelectedMCPToolNames(),
-		);
 		this.#ttsrManager = config.ttsrManager;
 		this.#obfuscator = config.obfuscator;
 		this.#agentId = config.agentId;
@@ -3479,7 +3425,8 @@ export class AgentSession {
 	 *      consuming (advances the queue generator);
 	 *   2. else, when a non-forcing preview is pending, a {@link SoftToolRequirement} — a
 	 *      PEEK (advances/pops nothing), so the agent-loop injects the reminder once per head
-	 *      and escalates to a forced `resolve` only if the model declines. A compliant turn
+	 *      and escalates to a forced `write` only if the model declines to
+	 *      resolve via `xd://resolve` or `xd://reject`. A compliant turn
 	 *      pays ZERO tool_choice change (no prompt-cache messages-cache invalidation);
 	 *   3. else undefined.
 	 */
@@ -3491,19 +3438,23 @@ export class AgentSession {
 			return {
 				soft: true,
 				id: head.id,
-				toolName: "resolve",
+				// Preview resolution is a `write` to xd://resolve or xd://reject;
+				// only those exact shapes satisfy the requirement — a plain write
+				// elsewhere is a detour.
+				toolName: "write",
+				satisfies: isPreviewResolutionToolCall,
 				reminder: [buildResolveReminderMessage(head.sourceToolName)],
 			};
 		}
 		return undefined;
 	}
 
-	/** Peek the head non-forcing pending preview invoker, for the `resolve` tool's dispatch. */
+	/** Peek the head non-forcing pending preview invoker, for the preview-resolution dispatch. */
 	peekPendingInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined {
 		return this.#toolChoiceQueue.peekPendingInvoker();
 	}
 
-	/** Clear stale non-forcing pending preview invokers after `resolve` proves none can run. */
+	/** Clear stale non-forcing pending preview invokers after a resolve dispatch proves none can run. */
 	clearPendingInvokers(): void {
 		this.#toolChoiceQueue.clearPendingInvokers();
 	}
@@ -3534,22 +3485,20 @@ export class AgentSession {
 		return this.#toolChoiceQueue;
 	}
 
-	/** Peek the in-flight directive's invocation handler for use by the resolve tool. */
+	/** Peek the in-flight directive's invocation handler for the preview-resolution dispatch. */
 	peekQueueInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined {
 		return this.#toolChoiceQueue.peekInFlightInvoker();
 	}
 
-	/** Standing (long-lived) handler the `resolve` tool falls back to when no
-	 *  queue invoker is in flight. Used by plan mode so the agent can submit
-	 *  approval via `resolve` without forcing the tool choice every turn. */
-	#standingResolveHandler: ((input: unknown) => Promise<unknown> | unknown) | undefined;
+	/** Plan-proposal handler consulted by `xd://propose` while plan mode is active. */
+	#planProposalHandler: PlanProposalHandler | undefined;
 
-	peekStandingResolveHandler(): ((input: unknown) => Promise<unknown> | unknown) | undefined {
-		return this.#standingResolveHandler;
+	peekPlanProposalHandler(): PlanProposalHandler | undefined {
+		return this.#planProposalHandler;
 	}
 
-	setStandingResolveHandler(handler: ((input: unknown) => Promise<unknown> | unknown) | null): void {
-		this.#standingResolveHandler = handler ?? undefined;
+	setPlanProposalHandler(handler: PlanProposalHandler | null): void {
+		this.#planProposalHandler = handler ?? undefined;
 	}
 
 	#sessionSwitchReconciler: (() => Promise<void>) | undefined;
@@ -3666,7 +3615,7 @@ export class AgentSession {
 	 * a settle observed now is a scheduling pause rather than a terminal stop:
 	 * stop-time passes (todo reminder, session_stop hooks) defer to the settle
 	 * reached once the session is fully idle. Suppressed deliveries
-	 * (acknowledged, or watched by an in-flight `job` poll) never wake the loop,
+	 * (acknowledged, or watched by an in-flight `hub` wait) never wake the loop,
 	 * so they don't count.
 	 */
 	#hasPendingAsyncWake(): boolean {
@@ -4198,7 +4147,10 @@ export class AgentSession {
 				await this.#goalRuntime.onToolCompleted(event.toolName);
 			}
 			this.#planModeReminderAwaitingProgress = false;
-			if (this.#isPlanDecisionTool(event.toolName)) {
+			if (
+				event.toolName === "ask" ||
+				writeDeviceDispatch(event.toolName, event.result)?.tool === PROPOSE_DEVICE_NAME
+			) {
 				this.#planModeReminderCount = 0;
 				this.#planModeReminderAwaitingProgress = false;
 			}
@@ -6522,72 +6474,8 @@ export class AgentSession {
 		return this.#retryAttempt;
 	}
 
-	#collectDiscoverableMCPToolsFromRegistry(): Map<string, DiscoverableTool> {
-		const mcpTools = filterBySource(collectDiscoverableTools(this.#toolRegistry.values()), "mcp");
-		return new Map(mcpTools.map(tool => [tool.name, tool] as const));
-	}
-
-	#setDiscoverableMCPTools(discoverableMCPTools: Map<string, DiscoverableTool>): void {
-		this.#discoverableMCPTools = discoverableMCPTools;
-		this.#invalidateDiscoveryCaches();
-	}
-
-	/** Single point for invalidating cached discovery indices. Call after any change that can
-	 *  affect which tools should be discoverable: registry mutations (refreshMCPTools,
-	 *  refreshRpcHostTools) or active-tool mutations (#applyActiveToolsByName). */
-	#invalidateDiscoveryCaches(): void {
-		this.#discoverableToolSearchIndex = null;
-	}
-
-	#filterSelectableMCPToolNames(toolNames: Iterable<string>): string[] {
-		return Array.from(toolNames).filter(name => this.#discoverableMCPTools.has(name) && this.#toolRegistry.has(name));
-	}
-
-	#getConfiguredDefaultSelectedMCPToolNames(): string[] {
-		return this.#filterSelectableMCPToolNames([
-			...this.#defaultSelectedMCPToolNames,
-			...selectDiscoverableToolNamesByServer(
-				this.#discoverableMCPTools.values(),
-				this.#defaultSelectedMCPServerNames,
-			),
-		]);
-	}
-
-	#pruneSelectedMCPToolNames(): void {
-		this.#selectedMCPToolNames = new Set(this.#filterSelectableMCPToolNames(this.#selectedMCPToolNames));
-	}
-
-	#selectedMCPToolNamesMatch(left: string[], right: string[]): boolean {
-		return left.length === right.length && left.every((name, index) => name === right[index]);
-	}
-
-	#rememberSessionDefaultSelectedMCPToolNames(
-		sessionFile: string | null | undefined,
-		toolNames: Iterable<string>,
-	): void {
-		if (!sessionFile) return;
-		this.#sessionDefaultSelectedMCPToolNames.set(
-			path.resolve(sessionFile),
-			this.#filterSelectableMCPToolNames(toolNames),
-		);
-	}
-
-	#getSessionDefaultSelectedMCPToolNames(sessionFile: string | null | undefined): string[] {
-		if (!sessionFile) return [];
-		return this.#sessionDefaultSelectedMCPToolNames.get(path.resolve(sessionFile)) ?? [];
-	}
-
-	#persistSelectedMCPToolNamesIfChanged(previousSelectedMCPToolNames: string[]): void {
-		if (!this.#mcpDiscoveryEnabled) return;
-		const nextSelectedMCPToolNames = this.getSelectedMCPToolNames();
-		if (this.#selectedMCPToolNamesMatch(previousSelectedMCPToolNames, nextSelectedMCPToolNames)) {
-			return;
-		}
-		this.sessionManager.appendMCPToolSelection(nextSelectedMCPToolNames);
-	}
-
 	#getActiveNonMCPToolNames(): string[] {
-		return this.getActiveToolNames().filter(name => !isMCPToolName(name) && this.#toolRegistry.has(name));
+		return this.getEnabledToolNames().filter(name => !isMCPToolName(name) && this.#toolRegistry.has(name));
 	}
 
 	/**
@@ -6598,6 +6486,22 @@ export class AgentSession {
 		return this.agent.state.tools.map(t => t.name);
 	}
 
+	/**
+	 * Enabled tool names: top-level active tools plus discoverable tools mounted
+	 * under `xd://`. Reconcile callers (MCP refresh, discovery, plan/goal mode)
+	 * build their next active set from this so a mount survives an active-set
+	 * change; {@link getActiveToolNames} stays the top-level-only view.
+	 */
+	getEnabledToolNames(): string[] {
+		if (this.#mountedXdevToolNames.size === 0) return this.getActiveToolNames();
+		return [...this.getActiveToolNames(), ...this.#mountedXdevToolNames];
+	}
+
+	/** Names of discoverable tools currently mounted under `xd://` (dynamic mounts). */
+	getMountedXdevToolNames(): string[] {
+		return [...this.#mountedXdevToolNames];
+	}
+
 	/** Whether the edit tool is registered in this session. */
 	get hasEditTool(): boolean {
 		return this.#toolRegistry.has("edit");
@@ -6659,7 +6563,6 @@ export class AgentSession {
 		for (const name of this.#installedVibeToolNames) {
 			this.#toolRegistry.delete(name);
 			this.#builtInToolNames.delete(name);
-			this.#selectedDiscoveredToolNames.delete(name);
 		}
 		this.#installedVibeToolNames.clear();
 		await this.#applyActiveToolsByName(nextToolNames);
@@ -6693,146 +6596,10 @@ export class AgentSession {
 		}
 	}
 
-	isMCPDiscoveryEnabled(): boolean {
-		return this.#mcpDiscoveryEnabled;
-	}
-
-	/**
-	 * Flip MCP discovery on after deferred discovery learns the real tool count.
-	 * UI sessions resolve `tools.discoveryMode: "auto"` before MCP servers
-	 * connect, so a large MCP toolset discovered later must be able to upgrade
-	 * the session from the force-activate path to the discovery path. One-way:
-	 * discovery is never downgraded mid-session.
-	 */
-	enableMCPDiscovery(): void {
-		this.#mcpDiscoveryEnabled = true;
-	}
-
 	getSelectedMCPToolNames(): string[] {
-		if (!this.#mcpDiscoveryEnabled) {
-			return this.getActiveToolNames().filter(name => isMCPToolName(name) && this.#toolRegistry.has(name));
-		}
-		return this.#filterSelectableMCPToolNames(this.#selectedMCPToolNames);
-	}
-
-	async activateDiscoveredMCPTools(toolNames: string[]): Promise<string[]> {
-		const nextSelectedMCPToolNames = new Set(this.#selectedMCPToolNames);
-		const activated: string[] = [];
-		for (const name of toolNames) {
-			if (!isMCPToolName(name) || !this.#discoverableMCPTools.has(name) || !this.#toolRegistry.has(name)) {
-				continue;
-			}
-			nextSelectedMCPToolNames.add(name);
-			activated.push(name);
-		}
-		if (activated.length === 0) {
-			return [];
-		}
-		const nextActive = [
-			...this.#getActiveNonMCPToolNames(),
-			...this.#filterSelectableMCPToolNames(nextSelectedMCPToolNames),
-		];
-		await this.setActiveToolsByName(nextActive);
-		return [...new Set(activated)];
-	}
-
-	// ── Generic tool discovery (covers built-in + MCP + extension) ────────────
-
-	/** Resolve effective discovery mode from the current registry size. */
-	#resolveEffectiveDiscoveryMode(): "off" | "mcp-only" | "all" {
-		const mode = resolveEffectiveToolDiscoveryMode(
-			this.settings,
-			countToolsForAutoDiscovery(this.#toolRegistry.keys()),
-		);
-		if (mode !== "off") return mode;
-		return this.#mcpDiscoveryEnabled ? "mcp-only" : "off";
-	}
-
-	isToolDiscoveryEnabled(): boolean {
-		return this.#resolveEffectiveDiscoveryMode() !== "off";
-	}
-
-	getDiscoverableTools(filter?: { source?: DiscoverableTool["source"] }): DiscoverableTool[] {
-		// For "all" mode we combine built-in registry entries + MCP tools.
-		// For "mcp-only" mode we only return MCP tools.
-		const mode = this.#resolveEffectiveDiscoveryMode();
-		const activeNames = new Set(this.getActiveToolNames());
-		const mcpTools = Array.from(this.#discoverableMCPTools.values()).filter(t => !activeNames.has(t.name));
-		const builtinTools: DiscoverableTool[] = mode === "all" ? this.#collectDiscoverableBuiltinTools() : [];
-		const allTools = [...builtinTools, ...mcpTools];
-		return filter?.source ? allTools.filter(t => t.source === filter.source) : allTools;
-	}
-
-	/** Collect built-in tools the model can discover via search_tool_bm25. Restricted to tool
-	 *  definitions whose `loadMode === "discoverable"`. This keeps hidden/internal tools
-	 *  (resolve, yield, report_finding, report_tool_issue) out of the index
-	 *  and avoids mislabeling extension/custom default-inactive tools as built-ins. */
-	#collectDiscoverableBuiltinTools(): DiscoverableTool[] {
-		const activeNames = new Set(this.getActiveToolNames());
-		const result: DiscoverableTool[] = [];
-		for (const tool of this.#toolRegistry.values()) {
-			if (tool.loadMode !== "discoverable") continue;
-			if (activeNames.has(tool.name)) continue;
-			const collected = collectDiscoverableTools([tool], { source: "builtin" });
-			result.push(...collected);
-		}
-		return result;
-	}
-
-	getDiscoverableToolSearchIndex(): DiscoverableToolSearchIndex {
-		if (!this.#discoverableToolSearchIndex) {
-			this.#discoverableToolSearchIndex = buildDiscoverableToolSearchIndex(this.getDiscoverableTools());
-		}
-		return this.#discoverableToolSearchIndex;
-	}
-
-	/** Invalidate the generic search index cache (call after tool set changes).
-	 *  Delegates to {@link #invalidateDiscoveryCaches} so all discovery-related caches stay in sync. */
-	#invalidateDiscoverableToolSearchIndex(): void {
-		this.#invalidateDiscoveryCaches();
-	}
-
-	getSelectedDiscoveredToolNames(): string[] {
-		// Union of MCP-selected and generic non-MCP selected. Non-MCP selections are only
-		// selected while they are still active; otherwise BM25 must be able to rediscover them.
-		const activeNames = new Set(this.getActiveToolNames());
-		const mcpSelected = this.getSelectedMCPToolNames();
-		const nonMcpSelected = Array.from(this.#selectedDiscoveredToolNames).filter(
-			name => activeNames.has(name) && this.#toolRegistry.has(name) && !isMCPToolName(name),
-		);
-		return [...new Set([...mcpSelected, ...nonMcpSelected])];
-	}
-
-	async activateDiscoveredTools(toolNames: string[]): Promise<string[]> {
-		const mcpNames = toolNames.filter(isMCPToolName);
-		const nonMcpNames = toolNames.filter(name => !isMCPToolName(name));
-		const activated: string[] = [];
-
-		// Activate MCP tools via existing path
-		if (mcpNames.length > 0) {
-			const activatedMcp = await this.activateDiscoveredMCPTools(mcpNames);
-			activated.push(...activatedMcp);
-		}
-
-		// Activate non-MCP tools (built-ins that are in the registry but not currently active)
-		if (nonMcpNames.length > 0) {
-			const currentActiveNames = new Set(this.getActiveToolNames());
-			const newlyAdded: string[] = [];
-			for (const name of nonMcpNames) {
-				if (this.#toolRegistry.has(name) && !currentActiveNames.has(name)) {
-					newlyAdded.push(name);
-					this.#selectedDiscoveredToolNames.add(name);
-					activated.push(name);
-				}
-			}
-			if (newlyAdded.length > 0) {
-				const nextActive = [...this.getActiveToolNames(), ...newlyAdded];
-				await this.setActiveToolsByName(nextActive);
-				this.#invalidateDiscoverableToolSearchIndex();
-			}
-		}
-
-		return [...new Set(activated)];
+		// Every connected MCP tool is enabled; presentation (top-level vs xd://) is
+		// decided by loadMode. Return the enabled MCP tools in the current set.
+		return this.getEnabledToolNames().filter(name => isMCPToolName(name) && this.#toolRegistry.has(name));
 	}
 
 	/**
@@ -6953,49 +6720,32 @@ export class AgentSession {
 		);
 	}
 
-	async #applyActiveToolsByName(
-		toolNames: string[],
-		options?: { persistMCPSelection?: boolean; previousSelectedMCPToolNames?: string[] },
-	): Promise<void> {
+	async #applyActiveToolsByName(toolNames: string[]): Promise<void> {
 		toolNames = normalizeToolNames(toolNames);
-		const previousSelectedMCPToolNames = options?.previousSelectedMCPToolNames ?? this.getSelectedMCPToolNames();
 		const tools: AgentTool[] = [];
 		const validToolNames: string[] = [];
+		const mountedTools: AgentTool[] = [];
 		for (const name of toolNames) {
 			const tool = this.#toolRegistry.get(name);
-			if (tool) {
+			if (!tool) continue;
+			// Discoverable tools are presented as `xd://` devices (kept out of the
+			// top-level schema) when the transport is active; everything else stays
+			// top-level. `loadMode` decides presentation only — selection is upstream.
+			if (this.#xdevRegistry && isMountableUnderXdev(tool)) {
+				mountedTools.push(tool);
+			} else {
 				tools.push(this.#wrapToolForAcpPermission(tool));
 				validToolNames.push(name);
 			}
 		}
-		// Auto-QA tool must survive any runtime tool-set mutation.
-		if (isAutoQaEnabled(this.settings) && !validToolNames.includes("report_tool_issue")) {
-			const qaTool = this.#toolRegistry.get("report_tool_issue");
-			if (qaTool) {
-				tools.push(this.#wrapToolForAcpPermission(qaTool));
-				validToolNames.push("report_tool_issue");
-			}
-		}
-		if (this.#mcpDiscoveryEnabled) {
-			this.#selectedMCPToolNames = new Set(
-				validToolNames.filter(
-					name => isMCPToolName(name) && this.#discoverableMCPTools.has(name) && this.#toolRegistry.has(name),
-				),
-			);
-		}
+		// Reconcile the dynamic `xd://` mounts: newly-active discoverable tools are
+		// mounted, deactivated ones dropped (built-in devices are preserved). A
+		// removed or disconnected tool must not stay callable through a stale device.
+		this.#mountedXdevToolNames = new Set(mountedTools.map(tool => tool.name));
+		this.#xdevRegistry?.reconcile(mountedTools);
 		this.#setActiveToolNames?.(validToolNames);
-		const activeNameSet = new Set(validToolNames);
-		for (const name of Array.from(this.#selectedDiscoveredToolNames)) {
-			if (!activeNameSet.has(name) || isMCPToolName(name) || !this.#toolRegistry.has(name)) {
-				this.#selectedDiscoveredToolNames.delete(name);
-			}
-		}
 		this.agent.setTools(tools);
 
-		// Active tool set changed → discoverable tool list (which excludes already-active tools)
-		// is now stale. Invalidate before any prompt-template hook reads the discovery list.
-		this.#invalidateDiscoveryCaches();
-
 		// Rebuild base system prompt with new tool set, but only when the tool set
 		// actually changed. MCP servers can reconnect at arbitrary times and call
 		// `refreshMCPTools` -> `#applyActiveToolsByName` even though the resulting
@@ -7015,48 +6765,6 @@ export class AgentSession {
 				this.#promptModelKey = this.#currentPromptModelKey();
 			}
 		}
-		if (options?.persistMCPSelection !== false) {
-			this.#persistSelectedMCPToolNamesIfChanged(previousSelectedMCPToolNames);
-		}
-	}
-
-	/**
-	 * Reload the SSH tool from disk-backed capability discovery and make the
-	 * refreshed definition visible to the next model call without restarting.
-	 */
-	async refreshSshTool(options?: { activateIfAvailable?: boolean }): Promise<void> {
-		resetCapabilities();
-		if (!this.#reloadSshTool) return;
-		const previousSshTool = this.#toolRegistry.get("ssh");
-		const previousActiveToolNames = this.getActiveToolNames();
-		const hadSshTool = previousSshTool !== undefined;
-		const wasActive = previousActiveToolNames.includes("ssh");
-		const previousHostNames =
-			previousSshTool && "hostNames" in previousSshTool && Array.isArray(previousSshTool.hostNames)
-				? [...previousSshTool.hostNames]
-				: [];
-		const candidateHostNames = new Set(previousHostNames);
-		const capability = await loadCapability<{ name: string }>("ssh", { cwd: this.sessionManager.getCwd() });
-		for (const host of capability.items) {
-			if (typeof host?.name === "string") {
-				candidateHostNames.add(host.name);
-			}
-		}
-		await invalidateHostMetadata(candidateHostNames);
-		const sshAllowed = this.#requestedToolNames === undefined || this.#requestedToolNames.has("ssh");
-		const refreshedTool = await this.#reloadSshTool();
-		if (refreshedTool) {
-			this.#toolRegistry.set(refreshedTool.name, refreshedTool);
-		} else {
-			this.#toolRegistry.delete("ssh");
-			this.#selectedDiscoveredToolNames.delete("ssh");
-		}
-
-		const nextActive = previousActiveToolNames.filter(name => name !== "ssh" && this.#toolRegistry.has(name));
-		if (refreshedTool && sshAllowed && (wasActive || (options?.activateIfAvailable && !hadSshTool))) {
-			nextActive.push(refreshedTool.name);
-		}
-		await this.#applyActiveToolsByName(nextActive);
 	}
 
 	/**
@@ -7069,25 +6777,6 @@ export class AgentSession {
 		await this.#applyActiveToolsByName(toolNames);
 	}
 
-	async #restoreMCPSelectionsForSessionContext(
-		sessionContext: SessionContext,
-		options?: { fallbackSelectedMCPToolNames?: Iterable<string> },
-	): Promise<void> {
-		if (!this.#mcpDiscoveryEnabled) return;
-		const nextActiveNonMCPToolNames = this.#getActiveNonMCPToolNames();
-		const fallbackSelectedMCPToolNames =
-			options?.fallbackSelectedMCPToolNames ?? this.#getConfiguredDefaultSelectedMCPToolNames();
-		const restoredMCPToolNames = sessionContext.hasPersistedMCPToolSelection
-			? this.#filterSelectableMCPToolNames(sessionContext.selectedMCPToolNames)
-			: this.#filterSelectableMCPToolNames(fallbackSelectedMCPToolNames);
-		this.#rememberSessionDefaultSelectedMCPToolNames(
-			this.sessionFile,
-			this.#getConfiguredDefaultSelectedMCPToolNames(),
-		);
-		await this.#applyActiveToolsByName([...nextActiveNonMCPToolNames, ...restoredMCPToolNames], {
-			persistMCPSelection: false,
-		});
-	}
 	/** Rebuild the base system prompt using the current active tool set. */
 	async refreshBaseSystemPrompt(): Promise<void> {
 		if (!this.#rebuildSystemPrompt) return;
@@ -7200,17 +6889,6 @@ export class AgentSession {
 		const describeTool = (tool: AgentTool): string =>
 			`${tool.name}=${tool.label ?? ""}|${tool.description ?? ""}|${tool.customWireName ?? ""}`;
 		const descriptionSegment = tools.map(describeTool).join("\u0002");
-		let registrySegment = "";
-		if (this.#mcpDiscoveryEnabled) {
-			// Registry iteration order is not load-bearing for the prompt content, so we
-			// sort to keep the signature insensitive to incidental insertion order.
-			const entries: string[] = [];
-			for (const tool of this.#toolRegistry.values()) {
-				entries.push(describeTool(tool));
-			}
-			entries.sort();
-			registrySegment = entries.join("\u0004");
-		}
 		let instructionsSegment = "";
 		const serverInstructions = this.#getMcpServerInstructions?.();
 		if (serverInstructions && serverInstructions.size > 0) {
@@ -7222,21 +6900,20 @@ export class AgentSession {
 			entries.sort();
 			instructionsSegment = entries.join("\u0006");
 		}
+		// The xd:// device inventory (built-in + dynamic mounts) is rendered into the
+		// prompt, so a mount/unmount must differ the signature and trigger a rebuild.
+		const mountedSegment = this.#xdevRegistry ? this.#xdevRegistry.list().map(describeTool).join("\u0008") : "";
 		const date = this.#getLocalCalendarDate();
-		return `${nameSegment}\u0003${descriptionSegment}\u0005${registrySegment}\u0007${instructionsSegment}|${date}`;
+		return `${nameSegment}\u0003${descriptionSegment}\u0007${instructionsSegment}\u0009${mountedSegment}|${date}`;
 	}
 
 	/**
-	 * Replace MCP tools in the registry and recompute the visible MCP tool set immediately.
-	 * This allows /mcp add/remove/reauth to take effect without restarting the session.
-	 *
-	 * @param mcpTools The new MCP tools to register.
-	 * @param options.activateAll When true, force-activates every newly registered MCP tool
-	 *   regardless of prior selection state. Used when MCP discovery is disabled and tools
-	 *   arrive after initial session activation.
+	 * Replace MCP tools in the registry and enable them immediately. Every
+	 * connected MCP tool becomes available (mounted under `xd://` when that
+	 * transport is active, else top-level). Lets `/mcp add/remove/reauth` take
+	 * effect without restarting the session.
 	 */
-	async refreshMCPTools(mcpTools: CustomTool[], options?: { activateAll?: boolean }): Promise<void> {
-		const previousSelectedMCPToolNames = this.getSelectedMCPToolNames();
+	async refreshMCPTools(mcpTools: CustomTool[]): Promise<void> {
 		const existingNames = Array.from(this.#toolRegistry.keys());
 		for (const name of existingNames) {
 			if (isMCPToolName(name)) {
@@ -7265,33 +6942,10 @@ export class AgentSession {
 			this.#toolRegistry.set(finalTool.name, finalTool);
 		}
 
-		this.#setDiscoverableMCPTools(this.#collectDiscoverableMCPToolsFromRegistry());
-		this.#pruneSelectedMCPToolNames();
-		if (!this.buildDisplaySessionContext().hasPersistedMCPToolSelection) {
-			this.#selectedMCPToolNames = new Set([
-				...this.#selectedMCPToolNames,
-				...this.#getConfiguredDefaultSelectedMCPToolNames(),
-			]);
-		}
-		this.#rememberSessionDefaultSelectedMCPToolNames(
-			this.sessionFile,
-			this.#getConfiguredDefaultSelectedMCPToolNames(),
-		);
-
-		if (options?.activateAll) {
-			// Force-activate every newly registered MCP tool. This path is used
-			// when MCP discovery is disabled and tools arrive after initial
-			// activation — without it, getSelectedMCPToolNames() returns only
-			// already-active tools (circular deadlock: tools can only become
-			// active if they're already active).
-			const newMcpNames = mcpTools.map(t => t.name);
-			const nextActive = [...new Set([...this.#getActiveNonMCPToolNames(), ...newMcpNames])];
-			await this.#applyActiveToolsByName(nextActive, { previousSelectedMCPToolNames });
-			return;
-		}
-
-		const nextActive = [...this.#getActiveNonMCPToolNames(), ...this.getSelectedMCPToolNames()];
-		await this.#applyActiveToolsByName(nextActive, { previousSelectedMCPToolNames });
+		// Every connected MCP tool is enabled; re-derive the active set from the
+		// current non-MCP tools plus all freshly registered MCP tools.
+		const nextActive = [...new Set([...this.#getActiveNonMCPToolNames(), ...mcpTools.map(tool => tool.name)])];
+		await this.#applyActiveToolsByName(nextActive);
 	}
 
 	/**
@@ -7311,7 +6965,7 @@ export class AgentSession {
 		}
 
 		const previousRpcHostToolNames = new Set(this.#rpcHostToolNames);
-		const previousActiveToolNames = this.getActiveToolNames();
+		const previousActiveToolNames = this.getEnabledToolNames();
 		for (const name of previousRpcHostToolNames) {
 			this.#toolRegistry.delete(name);
 		}
@@ -7326,11 +6980,6 @@ export class AgentSession {
 			this.#rpcHostToolNames.add(finalTool.name);
 		}
 
-		// Registry contents changed — invalidate discovery caches so the next BM25 lookup sees
-		// the new RPC-host tool set. (#applyActiveToolsByName below also invalidates, but doing
-		// it here too keeps the contract local to "registry mutated".)
-		this.#invalidateDiscoveryCaches();
-
 		const activeNonRpcToolNames = previousActiveToolNames.filter(name => !previousRpcHostToolNames.has(name));
 		const preservedRpcToolNames = previousActiveToolNames.filter(
 			name => previousRpcHostToolNames.has(name) && this.#rpcHostToolNames.has(name),
@@ -7961,12 +7610,8 @@ export class AgentSession {
 
 	#buildGoalTodoContext(): string | undefined {
 		if (!this.settings.get("todo.enabled")) return undefined;
-		const activeToolNames = this.getActiveToolNames();
-		const canCallTodoTool = activeToolNames.includes("todo");
-		const canDiscoverTodoTool =
-			!canCallTodoTool && this.getDiscoverableTools({ source: "builtin" }).some(tool => tool.name === "todo");
-		const canActivateTodoTool = canDiscoverTodoTool && activeToolNames.includes("search_tool_bm25");
-		if (!canCallTodoTool && !canDiscoverTodoTool) return undefined;
+		const canCallTodoTool = this.getActiveToolNames().includes("todo");
+		if (!canCallTodoTool) return undefined;
 		const phases = this.getTodoPhases().filter(phase => phase.tasks.length > 0);
 		if (phases.length === 0) return undefined;
 
@@ -7988,7 +7633,6 @@ export class AgentSession {
 
 		return prompt.render(goalTodoContextPrompt, {
 			canCallTodoTool,
-			canActivateTodoTool,
 			closed: String(closed),
 			open: String(open),
 			phases: promptPhases,
@@ -9381,12 +9025,6 @@ export class AgentSession {
 	 */
 	async newSession(options?: NewSessionOptions): Promise<boolean> {
 		const previousSessionFile = this.sessionFile;
-		const nextDiscoverySessionToolNames = this.#mcpDiscoveryEnabled
-			? [
-					...this.#getActiveNonMCPToolNames(),
-					...this.#filterSelectableMCPToolNames(this.#defaultSelectedMCPToolNames),
-				]
-			: undefined;
 
 		// Emit session_before_switch event with reason "new" (can be cancelled)
 		if (this.#extensionRunner?.hasHandlers("session_before_switch")) {
@@ -9439,16 +9077,6 @@ export class AgentSession {
 
 		this.sessionManager.appendThinkingLevelChange(this.thinkingLevel, this.configuredThinkingLevel());
 		this.sessionManager.appendServiceTierChange(this.#serviceTierEntry());
-		if (nextDiscoverySessionToolNames) {
-			await this.#applyActiveToolsByName(nextDiscoverySessionToolNames, { persistMCPSelection: false });
-			if (this.getSelectedMCPToolNames().length > 0) {
-				this.sessionManager.appendMCPToolSelection(this.getSelectedMCPToolNames());
-			}
-		}
-		this.#rememberSessionDefaultSelectedMCPToolNames(
-			this.sessionFile,
-			this.#getConfiguredDefaultSelectedMCPToolNames(),
-		);
 
 		this.#todoReminderCount = 0;
 		this.#todoReminderAwaitingProgress = false;
@@ -11901,7 +11529,6 @@ export class AgentSession {
 		if (activeMessages) {
 			activeMessages.splice(0, activeMessages.length, ...sessionContext.messages);
 		}
-		await this.#restoreMCPSelectionsForSessionContext(sessionContext);
 		this.agent.replaceMessages(activeMessages ?? sessionContext.messages);
 		this.#resetAdvisorSessionState();
 		this.#syncTodoPhasesFromBranch();
@@ -11909,8 +11536,9 @@ export class AgentSession {
 		this.#checkpointState = undefined;
 		this.#pendingRewindReport = undefined;
 	}
-	#isPlanDecisionTool(name: string): boolean {
-		return PLAN_DECISION_TOOLS.has(name);
+	/** Plan-mode decision affordances: `ask`, or plan approval via `write xd://propose`. */
+	#isPlanDecisionTool(toolCall: { name: string; arguments?: Record<string, unknown> }): boolean {
+		return toolCall.name === "ask" || isProposeToolCall(toolCall);
 	}
 
 	async #enforcePlanModeDecisionAtSettle(): Promise<boolean> {
@@ -11926,7 +11554,7 @@ export class AgentSession {
 		}
 
 		const calledDecisionTool = assistantMessage.content.some(
-			content => content.type === "toolCall" && this.#isPlanDecisionTool(content.name),
+			content => content.type === "toolCall" && this.#isPlanDecisionTool(content),
 		);
 		if (calledDecisionTool) {
 			this.#planModeReminderCount = 0;
@@ -11945,9 +11573,9 @@ export class AgentSession {
 			logger.debug("Plan mode convergence: reminder cap reached; yielding to user");
 			return false;
 		}
-		const hasRequiredTools = this.#toolRegistry.has("ask") && this.#toolRegistry.has("resolve");
+		const hasRequiredTools = this.#toolRegistry.has("ask") && this.#toolRegistry.has("write");
 		if (!hasRequiredTools) {
-			logger.warn("Plan mode enforcement skipped because ask/resolve tools are unavailable", {
+			logger.warn("Plan mode enforcement skipped because ask/write tools are unavailable", {
 				activeToolNames: this.agent.state.tools.map(tool => tool.name),
 			});
 			return false;
@@ -15722,16 +15350,12 @@ export class AgentSession {
 		const previousAutoThinking = this.#autoThinking;
 		const previousAutoResolvedLevel = this.#autoResolvedLevel;
 		const previousServiceTierByFamily = this.#serviceTierByFamily;
-		const previousSelectedMCPToolNames = new Set(this.#selectedMCPToolNames);
 		const previousTools = [...this.agent.state.tools];
 		const previousBaseSystemPrompt = this.#baseSystemPrompt;
 		const previousSystemPrompt = this.agent.state.systemPrompt;
 		const previousBaseSystemPromptBeforeMemoryPromotion = this.#baseSystemPromptBeforeMemoryPromotion;
 		const previousFreshProviderSessionId = this.#freshProviderSessionId;
 		const previousInheritedProviderPromptCacheKey = this.#inheritedProviderPromptCacheKey;
-		const previousFallbackSelectedMCPToolNames = previousSessionFile
-			? this.#getSessionDefaultSelectedMCPToolNames(previousSessionFile)
-			: undefined;
 
 		// Snapshot the full checkpoint runtime state: the success path calls
 		// #rehydrateCheckpointRewindState(), which clears and rebuilds all four
@@ -15761,8 +15385,6 @@ export class AgentSession {
 			const didReloadConversationChange =
 				previousSessionContext !== undefined &&
 				this.#didSessionMessagesChange(previousSessionContext.messages, sessionContext.messages);
-			const fallbackSelectedMCPToolNames = this.#getSessionDefaultSelectedMCPToolNames(sessionPath);
-			await this.#restoreMCPSelectionsForSessionContext(sessionContext, { fallbackSelectedMCPToolNames });
 			this.#rehydrateCheckpointRewindState();
 
 			// Emit session_switch event to hooks
@@ -15890,28 +15512,7 @@ export class AgentSession {
 			this.#syncAgentSessionId(previousSessionState.sessionId);
 			this.#rekeyHindsightMemoryForCurrentSessionId();
 			this.#rekeyMnemopiMemoryForCurrentSessionId();
-			let restoreMcpError: unknown;
-			try {
-				// `previousSessionContext` was skipped on different-session switches to
-				// avoid materializing the previous session's heavy compaction payload
-				// in the success path; rebuild it here on demand from the restored
-				// state so MCP selection restoration still has its inputs.
-				const mcpRestoreContext = previousSessionContext ?? this.buildDisplaySessionContext();
-				await this.#restoreMCPSelectionsForSessionContext(mcpRestoreContext, {
-					fallbackSelectedMCPToolNames: previousFallbackSelectedMCPToolNames,
-				});
-			} catch (mcpError) {
-				restoreMcpError = mcpError;
-				logger.warn("Failed to restore MCP selections after switch error", {
-					previousSessionFile,
-					targetSessionFile: sessionPath,
-					error: String(mcpError),
-				});
-				this.#selectedMCPToolNames = new Set(previousSelectedMCPToolNames);
-				this.agent.setTools(previousTools);
-				this.#baseSystemPrompt = previousBaseSystemPrompt;
-				this.agent.setSystemPrompt(previousSystemPrompt);
-			}
+			this.agent.setTools(previousTools);
 			this.#baseSystemPrompt = previousBaseSystemPrompt;
 			this.#baseSystemPromptBeforeMemoryPromotion = previousBaseSystemPromptBeforeMemoryPromotion;
 			this.agent.setSystemPrompt(previousSystemPrompt);
@@ -15935,9 +15536,6 @@ export class AgentSession {
 			this.#syncTodoPhasesFromBranch();
 			this.#resetAllAdvisorRuntimes();
 			this.#reconnectToAgent();
-			if (restoreMcpError) {
-				throw restoreMcpError;
-			}
 			throw error;
 		}
 	}
@@ -16004,8 +15602,6 @@ export class AgentSession {
 		// Reload messages from entries (works for both file and in-memory mode)
 		const sessionContext = this.buildDisplaySessionContext();
 
-		await this.#restoreMCPSelectionsForSessionContext(sessionContext);
-
 		// Emit session_branch event to hooks (after branch completes)
 		if (this.#extensionRunner) {
 			await this.#extensionRunner.emit({
@@ -16096,7 +15692,6 @@ export class AgentSession {
 		await this.#resetMemoryContextForNewTranscript();
 
 		const sessionContext = this.buildDisplaySessionContext();
-		await this.#restoreMCPSelectionsForSessionContext(sessionContext);
 
 		if (this.#extensionRunner) {
 			await this.#extensionRunner.emit({
@@ -16280,7 +15875,6 @@ export class AgentSession {
 		// Update agent state — build display context to populate agent messages.
 		const stateContext = this.sessionManager.buildSessionContext();
 		const displayContext = deobfuscateSessionContext(stateContext, this.#obfuscator);
-		await this.#restoreMCPSelectionsForSessionContext(displayContext);
 		this.agent.replaceMessages(displayContext.messages);
 		this.#rehydrateCheckpointRewindState();
 		this.#resetAdvisorSessionState();
diff --git a/packages/coding-agent/src/session/session-context.ts b/packages/coding-agent/src/session/session-context.ts
index eee08d6dc..599963055 100644
--- a/packages/coding-agent/src/session/session-context.ts
+++ b/packages/coding-agent/src/session/session-context.ts
@@ -64,10 +64,6 @@ export interface SessionContext {
 	models: Record<string, string>;
 	/** Names of TTSR rules that have been injected this session */
 	injectedTtsrRules: string[];
-	/** MCP tool names selected through discovery for this session branch. */
-	selectedMCPToolNames: string[];
-	/** Whether this branch contains an explicit persisted MCP selection entry. */
-	hasPersistedMCPToolSelection: boolean;
 	/** Active mode (e.g. "plan") or "none" if no special mode is active */
 	mode: string;
 	/** Mode-specific data from the last mode_change entry */
@@ -179,8 +175,6 @@ export function buildSessionContext(
 			serviceTier: undefined,
 			models: {},
 			injectedTtsrRules: [],
-			selectedMCPToolNames: [],
-			hasPersistedMCPToolSelection: false,
 			mode: "none",
 		};
 	}
@@ -199,8 +193,6 @@ export function buildSessionContext(
 			serviceTier: undefined,
 			models: {},
 			injectedTtsrRules: [],
-			selectedMCPToolNames: [],
-			hasPersistedMCPToolSelection: false,
 			mode: "none",
 		};
 	}
@@ -221,8 +213,6 @@ export function buildSessionContext(
 	const models: Record<string, string> = {};
 	let compaction: CompactionEntry | null = null;
 	const injectedTtsrRulesSet = new Set<string>();
-	let selectedMCPToolNames: string[] = [];
-	let hasPersistedMCPToolSelection = false;
 	let mode = "none";
 	let modeData: Record<string, unknown> | undefined;
 	// Track whether an explicit `model_change` with role="default" has been
@@ -265,9 +255,6 @@ export function buildSessionContext(
 			for (const ruleName of entry.injectedRules) {
 				injectedTtsrRulesSet.add(ruleName);
 			}
-		} else if (entry.type === "mcp_tool_selection") {
-			selectedMCPToolNames = [...entry.selectedToolNames];
-			hasPersistedMCPToolSelection = true;
 		} else if (entry.type === "mode_change") {
 			mode = entry.mode;
 			modeData = entry.data;
@@ -519,8 +506,6 @@ export function buildSessionContext(
 		serviceTier,
 		models,
 		injectedTtsrRules,
-		selectedMCPToolNames,
-		hasPersistedMCPToolSelection,
 		mode,
 		modeData,
 	};
diff --git a/packages/coding-agent/src/session/session-entries.ts b/packages/coding-agent/src/session/session-entries.ts
index 7dc763a95..a6b6ee3cd 100644
--- a/packages/coding-agent/src/session/session-entries.ts
+++ b/packages/coding-agent/src/session/session-entries.ts
@@ -155,13 +155,6 @@ export interface TtsrInjectionEntry extends SessionEntryBase {
 	injectedRules: string[];
 }
 
-/** Persisted MCP discovery selection state for a session branch. */
-export interface MCPToolSelectionEntry extends SessionEntryBase {
-	type: "mcp_tool_selection";
-	/** MCP tool names selected for visibility in discovery mode. */
-	selectedToolNames: string[];
-}
-
 /** Session init entry - captures initial context for subagent sessions (debugging/replay). */
 export interface SessionInitEntry extends SessionEntryBase {
 	type: "session_init";
@@ -223,7 +216,6 @@ export type SessionEntry =
 	| LabelEntry
 	| TitleChangeEntry
 	| TtsrInjectionEntry
-	| MCPToolSelectionEntry
 	| SessionInitEntry
 	| ModeChangeEntry;
 
diff --git a/packages/coding-agent/src/session/session-manager.ts b/packages/coding-agent/src/session/session-manager.ts
index be61be344..b259dd8c9 100644
--- a/packages/coding-agent/src/session/session-manager.ts
+++ b/packages/coding-agent/src/session/session-manager.ts
@@ -39,7 +39,6 @@ import {
 	type CustomMessageEntry,
 	type FileEntry,
 	type LabelEntry,
-	type MCPToolSelectionEntry,
 	type ModeChangeEntry,
 	type ModelChangeEntry,
 	type NewSessionOptions,
@@ -1592,19 +1591,6 @@ export class SessionManager {
 		return entry.id;
 	}
 
-	/**
-	 * Append an MCP tool selection entry recording the discovery-selected MCP tools.
-	 */
-	appendMCPToolSelection(selectedToolNames: string[]): string {
-		const entry: MCPToolSelectionEntry = {
-			type: "mcp_tool_selection",
-			...this.#freshEntryFields(),
-			selectedToolNames: [...selectedToolNames],
-		};
-		this.#recordEntry(entry);
-		return entry.id;
-	}
-
 	/** Append a TTSR injection entry recording which rules were injected. */
 	appendTtsrInjection(ruleNames: string[]): string {
 		const entry: TtsrInjectionEntry = {
diff --git a/packages/coding-agent/src/session/tool-choice-queue.ts b/packages/coding-agent/src/session/tool-choice-queue.ts
index 5ee616a9a..89344325b 100644
--- a/packages/coding-agent/src/session/tool-choice-queue.ts
+++ b/packages/coding-agent/src/session/tool-choice-queue.ts
@@ -67,8 +67,8 @@ interface InFlight {
 
 /**
  * A non-forcing pending preview invoker. Registered by `queueResolveHandler`
- * (resolve previews) so the `resolve` tool can dispatch to a staged action
- * WITHOUT this queue forcing `tool_choice`. The agent-loop's
+ * (resolve previews) so a `write` to `xd://resolve` or `xd://reject` can
+ * dispatch to a staged action WITHOUT this queue forcing `tool_choice`. The agent-loop's
  * SoftToolRequirement lifecycle (remind-then-escalate) owns any forcing.
  */
 interface PendingInvoker {
@@ -90,9 +90,9 @@ export class ToolChoiceQueue {
 	 */
 	#lastResolvedLabel: string | undefined;
 	/**
-	 * Non-forcing pending preview invokers, stacked by UNIQUE id. The `resolve`
-	 * tool dispatches to the head; the agent-loop's soft-tool-requirement
-	 * lifecycle drives resolution without this queue forcing `tool_choice`.
+	 * Non-forcing pending preview invokers, stacked by UNIQUE id. The
+	 * `xd://resolve` or `xd://reject` dispatch runs the head; the agent-loop's
+	 * soft-tool-requirement lifecycle drives resolution without this queue forcing `tool_choice`.
 	 */
 	#pendingInvokers: PendingInvoker[] = [];
 
@@ -211,9 +211,9 @@ export class ToolChoiceQueue {
 	}
 
 	// ── Non-forcing pending invokers ──────────────────────────────────────
-	// Preview producers (queueResolveHandler) register here so `resolve` can
-	// dispatch to a staged action WITHOUT a forced tool_choice (no messages-cache
-	// bust). Stacked by UNIQUE id: a re-register replaces only the same id, so
+	// Preview producers (queueResolveHandler) register here so a resolve-device
+	// write can dispatch to a staged action WITHOUT a forced tool_choice (no
+	// messages-cache bust). Stacked by UNIQUE id: a re-register replaces only the same id, so
 	// concurrent/sequential previews each survive and resolve independently.
 
 	/** Register (or replace by exact id) a non-forcing pending preview invoker. */
diff --git a/packages/coding-agent/src/slash-commands/builtin-registry.ts b/packages/coding-agent/src/slash-commands/builtin-registry.ts
index 14843a6ee..feca888b5 100644
--- a/packages/coding-agent/src/slash-commands/builtin-registry.ts
+++ b/packages/coding-agent/src/slash-commands/builtin-registry.ts
@@ -4,6 +4,7 @@ import * as path from "node:path";
 import { getOAuthProviders } from "@oh-my-pi/pi-ai/oauth";
 import { type AutocompleteItem, Spacer } from "@oh-my-pi/pi-tui";
 import { APP_NAME, getProjectDir, setProjectDir } from "@oh-my-pi/pi-utils";
+import { reset as resetCapabilities } from "../capability";
 import { COLLAB_GUEST_ALLOWED_COMMANDS, CollabGuestLink } from "../collab/guest";
 import { CollabHost } from "../collab/host";
 import { expandRoleAlias, getModelMatchPreferences, resolveCliModel } from "../config/model-resolver";
@@ -1176,7 +1177,11 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 				await runtime.output("No tools are available.");
 				return commandConsumed();
 			}
-			await runtime.output(all.map(name => `${active.includes(name) ? "*" : "-"} ${name}`).join("\n"));
+			const lines = all.map(name => `${active.includes(name) ? "*" : "-"} ${name}`);
+			for (const mounted of runtime.session.getXdevToolEntries()) {
+				lines.push(`~ xd://${mounted.name}`);
+			}
+			await runtime.output(lines.join("\n"));
 			return commandConsumed();
 		},
 		handleTui: (_command, runtime) => {
@@ -2250,7 +2255,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			const projectPath = await resolveActiveProjectRegistryPath(runtime.ctx.sessionManager.getCwd());
 			clearPluginRootsAndCaches(projectPath ? [projectPath] : undefined);
 			await runtime.ctx.refreshSlashCommandState();
-			await runtime.ctx.session.refreshSshTool({ activateIfAvailable: true });
+			resetCapabilities();
 			runtime.ctx.showStatus("Plugins reloaded.");
 			runtime.ctx.editor.setText("");
 		},
@@ -2597,7 +2602,7 @@ export async function executeBuiltinSlashCommand(
 				const projectPath = await resolveActiveProjectRegistryPath(ctx.sessionManager.getCwd());
 				clearPluginRootsAndCaches(projectPath ? [projectPath] : undefined);
 				await ctx.refreshSlashCommandState();
-				await ctx.session.refreshSshTool({ activateIfAvailable: true });
+				resetCapabilities();
 			},
 		};
 		const result = await command.handle(parsed, adapted);
diff --git a/packages/coding-agent/src/slash-commands/helpers/ssh.ts b/packages/coding-agent/src/slash-commands/helpers/ssh.ts
index eaaea1702..d181c1708 100644
--- a/packages/coding-agent/src/slash-commands/helpers/ssh.ts
+++ b/packages/coding-agent/src/slash-commands/helpers/ssh.ts
@@ -1,4 +1,5 @@
 import { getSSHConfigPath } from "@oh-my-pi/pi-utils";
+import { reset as resetCapabilities } from "../../capability";
 import { addSSHHost, readSSHConfigFile, removeSSHHost, type SSHHostConfig } from "../../ssh/config-writer";
 import { parseCommandArgs } from "../../utils/command-args";
 import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
@@ -142,7 +143,7 @@ async function handleRemoveCommand(rest: string, runtime: SlashCommandRuntime):
 	try {
 		const filePath = getSSHConfigPath(parsed.scope, runtime.cwd);
 		await removeSSHHost(filePath, parsed.name);
-		await runtime.session.refreshSshTool();
+		resetCapabilities();
 		await runtime.output(`Removed SSH host "${parsed.name}" from ${parsed.scope} config.`);
 		return commandConsumed();
 	} catch (err) {
@@ -163,7 +164,7 @@ async function handleAddCommand(rest: string, runtime: SlashCommandRuntime): Pro
 	try {
 		const filePath = getSSHConfigPath(parsed.scope, runtime.cwd);
 		await addSSHHost(filePath, parsed.name, hostConfig);
-		await runtime.session.refreshSshTool({ activateIfAvailable: true });
+		resetCapabilities();
 		await runtime.output(`Added SSH host "${parsed.name}" (${parsed.scope}).`);
 		return commandConsumed();
 	} catch (err) {
diff --git a/packages/coding-agent/src/ssh/ssh-executor.ts b/packages/coding-agent/src/ssh/ssh-executor.ts
deleted file mode 100644
index a8b92842c..000000000
--- a/packages/coding-agent/src/ssh/ssh-executor.ts
+++ /dev/null
@@ -1,178 +0,0 @@
-import { logger, ptree } from "@oh-my-pi/pi-utils";
-import { Settings } from "../config/settings";
-import { OutputSink } from "../session/streaming-output";
-import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../tools/output-meta";
-import { buildRemoteCommand, ensureConnection, ensureHostInfo, type SSHConnectionTarget } from "./connection-manager";
-import { hasSshfs, mountRemote } from "./sshfs-mount";
-import { wrapInPosixShell } from "./utils";
-
-export interface SSHExecutorOptions {
-	/** Timeout in milliseconds */
-	timeout?: number;
-	/** Callback for streaming output chunks (already sanitized) */
-	onChunk?: (chunk: string) => void;
-	/** AbortSignal for cancellation */
-	signal?: AbortSignal;
-	/** Remote path to mount when sshfs is available */
-	remotePath?: string;
-	/** Wrap commands in a POSIX shell for compat mode */
-	compatEnabled?: boolean;
-	/** Artifact path/id for full output storage */
-	artifactPath?: string;
-	artifactId?: string;
-}
-
-export interface SSHResult {
-	/** Combined stdout + stderr output (sanitized, possibly truncated) */
-	output: string;
-	/** Process exit code (undefined if killed/cancelled) */
-	exitCode: number | undefined;
-	/** Whether the command was cancelled via signal */
-	cancelled: boolean;
-	/** Whether the output was truncated */
-	truncated: boolean;
-	/** Total number of lines in the output stream */
-	totalLines: number;
-	/** Total number of bytes in the output stream */
-	totalBytes: number;
-	/** Number of lines included in the output text */
-	outputLines: number;
-	/** Number of bytes included in the output text */
-	outputBytes: number;
-	/** Artifact ID if full output was saved to artifact storage */
-	artifactId?: string;
-}
-
-type SSHExitEvent = { kind: "exit"; exitCode: number } | { kind: "error"; error: unknown };
-
-function sshExitEvent(exitCode: number): SSHExitEvent {
-	return { kind: "exit", exitCode };
-}
-
-function sshErrorEvent(error: unknown): SSHExitEvent {
-	return { kind: "error", error };
-}
-
-function createAbortWaiter(
-	signal: AbortSignal | undefined,
-	streamAbort: AbortController,
-): { promise: Promise<ptree.AbortError> | undefined; cleanup: () => void } {
-	if (!signal) {
-		return { promise: undefined, cleanup: () => {} };
-	}
-
-	const { promise, resolve } = Promise.withResolvers<ptree.AbortError>();
-	const onAbort = () => {
-		const error = new ptree.AbortError(signal.reason, "<cancelled>");
-		if (!streamAbort.signal.aborted) {
-			streamAbort.abort(error);
-		}
-		resolve(error);
-	};
-
-	if (signal.aborted) {
-		onAbort();
-		return { promise, cleanup: () => {} };
-	}
-
-	signal.addEventListener("abort", onAbort, { once: true });
-	return { promise, cleanup: () => signal.removeEventListener("abort", onAbort) };
-}
-
-export async function executeSSH(
-	host: SSHConnectionTarget,
-	command: string,
-	options?: SSHExecutorOptions,
-): Promise<SSHResult> {
-	await ensureConnection(host);
-	if (hasSshfs()) {
-		try {
-			await mountRemote(host, options?.remotePath ?? "/");
-		} catch (err) {
-			logger.warn("SSHFS mount failed", { host: host.name, error: String(err) });
-		}
-	}
-
-	let resolvedCommand = command;
-	if (options?.compatEnabled) {
-		const info = await ensureHostInfo(host);
-		if (info.compatShell) {
-			resolvedCommand = wrapInPosixShell(info.compatShell, command);
-		} else {
-			logger.warn("SSH compat enabled without detected compat shell", { host: host.name });
-		}
-	}
-
-	using child = ptree.spawn(["ssh", ...(await buildRemoteCommand(host, resolvedCommand))], {
-		signal: options?.signal,
-		timeout: options?.timeout,
-		stdin: "pipe",
-		stderr: "full",
-	});
-
-	const settings = await Settings.init();
-	const sink = new OutputSink({
-		onChunk: options?.onChunk,
-		artifactPath: options?.artifactPath,
-		artifactId: options?.artifactId,
-		headBytes: resolveOutputSinkHeadBytes(settings),
-		maxColumns: resolveOutputMaxColumns(settings),
-	});
-
-	const streamAbort = new AbortController();
-	const abortWaiter = createAbortWaiter(options?.signal, streamAbort);
-	const streamOptions = { signal: streamAbort.signal };
-	const streams = [child.stdout.pipeTo(sink.createInput(), streamOptions)];
-	if (child.stderr) {
-		streams.push(child.stderr.pipeTo(sink.createInput(), streamOptions));
-	}
-	const streamsSettled = Promise.allSettled(streams).then(() => {});
-
-	try {
-		const exitEvent = child.exited.then(sshExitEvent, sshErrorEvent);
-		const abortEvent = abortWaiter.promise?.then(sshErrorEvent);
-		const event = await (abortEvent ? Promise.race([exitEvent, abortEvent]) : exitEvent);
-		if (event.kind === "error") {
-			throw event.error;
-		}
-
-		const streamEvent = await (abortEvent ? Promise.race([streamsSettled, abortEvent]) : streamsSettled);
-		if (streamEvent?.kind === "error") {
-			throw streamEvent.error;
-		}
-		return {
-			exitCode: event.exitCode,
-			cancelled: false,
-			...(await sink.dump()),
-		};
-	} catch (err) {
-		if (!streamAbort.signal.aborted) {
-			streamAbort.abort(err);
-		}
-		void streamsSettled;
-		if (err instanceof ptree.Exception) {
-			if (err instanceof ptree.TimeoutError) {
-				return {
-					exitCode: undefined,
-					cancelled: true,
-					...(await sink.dump(`SSH: ${err.message}`)),
-				};
-			}
-			if (err.aborted) {
-				return {
-					exitCode: undefined,
-					cancelled: true,
-					...(await sink.dump(`Command aborted: ${err.message}`)),
-				};
-			}
-			return {
-				exitCode: err.exitCode,
-				cancelled: false,
-				...(await sink.dump(`Unexpected error: ${err.message}`)),
-			};
-		}
-		throw err;
-	} finally {
-		abortWaiter.cleanup();
-	}
-}
diff --git a/packages/coding-agent/src/system-prompt.ts b/packages/coding-agent/src/system-prompt.ts
index aaa969842..8b442719e 100644
--- a/packages/coding-agent/src/system-prompt.ts
+++ b/packages/coding-agent/src/system-prompt.ts
@@ -475,10 +475,6 @@ export interface BuildSystemPromptOptions {
 	rules?: Array<{ name: string; description?: string; path: string; globs?: string[] }>;
 	/** Intent field name injected into every tool schema. If set, explains the field in the prompt. */
 	intentField?: string;
-	/** Whether MCP tool discovery is active for this prompt build. */
-	mcpDiscoveryMode?: boolean;
-	/** Discoverable MCP server summaries to advertise when discovery mode is active. */
-	mcpDiscoveryServerSummaries?: string[];
 	/** Encourage the agent to delegate via tasks unless changes are trivial. */
 	eagerTasks?: boolean;
 	/** When true, the Eager Tasks section uses the hard MUST/ONLY wording (`task.eager: always`) rather than the softer `preferred` nudge. */
@@ -509,6 +505,12 @@ export interface BuildSystemPromptOptions {
 	renderMermaid?: boolean;
 	/** Pre-resolved nested active repo context. Undefined resolves from cwd. */
 	activeRepoContext?: ActiveRepoContext | null;
+	/** Tools mounted under `xd://`; renders the protocol section when non-empty. */
+	xdevTools?: Array<{ name: string; summary: string }>;
+	/** Full docs + JSON schema for every `xd://`-mounted tool, inlined into the protocol section so no discovery `read` is needed. */
+	xdevDocs?: string;
+	/** Whether Auto-QA grievance reporting is enabled; renders the `xd://report_issue` note. */
+	autoQaEnabled?: boolean;
 }
 
 /** Result of building provider-facing system prompt messages. */
@@ -539,8 +541,6 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		rules,
 		alwaysApplyRules,
 		intentField,
-		mcpDiscoveryMode = false,
-		mcpDiscoveryServerSummaries = [],
 		eagerTasks = false,
 		eagerTasksAlways = false,
 		taskBatch = true,
@@ -554,6 +554,9 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		personality = "default",
 		includeWorkspaceTree = false,
 		renderMermaid = true,
+		xdevTools = [],
+		xdevDocs = "",
+		autoQaEnabled = false,
 		activeRepoContext: providedActiveRepoContext,
 	} = options;
 	const inlineToolDescriptors = providedInlineToolDescriptors ?? false;
@@ -719,6 +722,12 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 
 	// Build tool descriptions for system prompt rendering.
 	const toolPromptNames = new Map<string, string>(toolNames.map(name => [name, tools?.get(name)?.wireName ?? name]));
+	// xd://-mounted tools count as present for prompt gates ({{#has tools "lsp"}})
+	// and resolve their own name as the reference — the xd:// section explains
+	// the access path. The Tool Inventory list stays limited to real defs.
+	for (const mounted of xdevTools) {
+		if (!toolPromptNames.has(mounted.name)) toolPromptNames.set(mounted.name, mounted.name);
+	}
 	const toolRefs = Object.fromEntries(toolPromptNames.entries());
 	const toolInfo = toolNames.map(name => ({
 		name: toolPromptNames.get(name) ?? name,
@@ -765,7 +774,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		systemPromptCustomization: effectiveSystemPromptCustomization,
 		customPrompt: resolvedCustomPrompt,
 		appendPrompt: resolvedAppendPrompt ?? "",
-		tools: toolNames,
+		tools: [...new Set([...toolNames, ...xdevTools.map(mounted => mounted.name)])],
 		toolInfo,
 		toolInventory,
 		inlineToolDescriptors,
@@ -786,9 +795,6 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		personality: personality === "none" ? "" : PERSONALITY_SPECS[personality].trim(),
 		intentTracing: !!intentField,
 		intentField: intentField ?? "",
-		mcpDiscoveryMode,
-		hasMCPDiscoveryServers: mcpDiscoveryServerSummaries.length > 0,
-		mcpDiscoveryServerSummaries,
 		eagerTasks,
 		eagerTasksAlways,
 		taskBatch,
@@ -799,6 +805,9 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		hasObsidian: hasObsidian(),
 		includeWorkspaceTree,
 		renderMermaid,
+		xdevTools,
+		xdevDocs,
+		autoQaEnabled,
 	};
 	const rendered = prompt.render(resolvedCustomPrompt ? customSystemPromptTemplate : systemPromptTemplate, data);
 	const systemPrompt = [rendered];
diff --git a/packages/coding-agent/src/task/executor.ts b/packages/coding-agent/src/task/executor.ts
index c91a2f277..1df404352 100644
--- a/packages/coding-agent/src/task/executor.ts
+++ b/packages/coding-agent/src/task/executor.ts
@@ -46,14 +46,9 @@ import { truncateTail } from "../session/streaming-output";
 import type { ConfiguredThinkingLevel } from "../thinking";
 import type { ContextFileEntry, ToolSession } from "../tools";
 import { resolveEvalBackends } from "../tools/eval-backends";
-import { isIrcEnabled } from "../tools/irc";
+import { isIrcEnabled } from "../tools/hub";
 import { normalizeSchema } from "../tools/jtd-to-json-schema";
-import {
-	buildOutputValidator,
-	type OutputValidator,
-	summarizeValidationFailure,
-} from "../tools/output-schema-validator";
-import { type ReportFindingDetails, toReviewFinding } from "../tools/review";
+import { buildOutputValidator, summarizeValidationFailure } from "../tools/output-schema-validator";
 import { ToolAbortError } from "../tools/tool-errors";
 import type { EventBus } from "../utils/event-bus";
 import { buildNamedToolChoice } from "../utils/tool-choice";
@@ -65,7 +60,6 @@ import {
 	type AgentProgress,
 	MAX_OUTPUT_BYTES,
 	MAX_OUTPUT_LINES,
-	type ReviewFinding,
 	type SingleResult,
 	TASK_SUBAGENT_EVENT_CHANNEL,
 	TASK_SUBAGENT_LIFECYCLE_CHANNEL,
@@ -264,19 +258,6 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return !Array.isArray(value);
 }
 
-function getReportFindingKey(value: unknown): string | null {
-	if (!isRecord(value)) return null;
-	const title = typeof value.title === "string" ? value.title : null;
-	const filePath = typeof value.file_path === "string" ? value.file_path : null;
-	const lineStart = typeof value.line_start === "number" ? value.line_start : null;
-	const lineEnd = typeof value.line_end === "number" ? value.line_end : null;
-	const priority = typeof value.priority === "string" ? value.priority : null;
-	if (!title || !filePath || lineStart === null || lineEnd === null) {
-		return null;
-	}
-	return `${filePath}:${lineStart}:${lineEnd}:${priority ?? ""}:${title}`;
-}
-
 /** Options for subagent execution */
 export interface ExecutorOptions {
 	cwd: string;
@@ -450,42 +431,6 @@ function extractCompletionData(parsed: unknown): unknown {
 	return parsed;
 }
 
-/**
- * Resolve the final yielded payload, optionally splicing collected
- * `report_finding` entries into a top-level `findings` array.
- *
- * Injection is suppressed when an active validator would reject the augmented
- * payload (e.g. a caller-supplied schema with `additionalProperties: false`
- * that does not declare `findings`). That keeps the in-tool yield validator
- * (which only sees the raw, pre-injection data) in lockstep with this
- * post-mortem validator — honoring the "accepted in-tool ⇒ accepted
- * post-mortem" guarantee documented in `output-schema-validator.ts`. The
- * dropped findings are still preserved verbatim in the agent's progress
- * stream and JSONL artifact, so no information is lost when injection is
- * suppressed.
- */
-function normalizeCompleteData(
-	data: unknown,
-	reportFindings: ReviewFinding[] | undefined,
-	validator: OutputValidator | undefined,
-): unknown {
-	const normalized = parseStringifiedJson(data ?? null);
-	if (
-		!Array.isArray(reportFindings) ||
-		reportFindings.length === 0 ||
-		!normalized ||
-		typeof normalized !== "object" ||
-		Array.isArray(normalized)
-	) {
-		return normalized;
-	}
-	const record = normalized as Record<string, unknown>;
-	if ("findings" in record) return normalized;
-	const injected = { ...record, findings: reportFindings };
-	if (validator && !validator.validate(injected).success) return normalized;
-	return injected;
-}
-
 function resolveFallbackCompletion(rawOutput: string, outputSchema: unknown): { data: unknown } | null {
 	const parsed = tryParseJsonOutput(rawOutput);
 	if (parsed === undefined) return null;
@@ -504,7 +449,6 @@ interface FinalizeSubprocessOutputArgs {
 	doneAborted: boolean;
 	signalAborted: boolean;
 	yieldItems?: YieldItem[];
-	reportFindings?: ReviewFinding[];
 	outputSchema: unknown;
 	lastAssistantText?: string;
 }
@@ -549,7 +493,7 @@ function buildSchemaViolationOutcome(
 
 export function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): FinalizeSubprocessOutputResult {
 	let { rawOutput, exitCode, stderr } = args;
-	const { yieldItems, reportFindings, doneAborted, signalAborted, outputSchema, lastAssistantText } = args;
+	const { yieldItems, doneAborted, signalAborted, outputSchema, lastAssistantText } = args;
 	let abortedViaYield = false;
 	const hasYield = Array.isArray(yieldItems) && yieldItems.length > 0;
 	const hadFailureBeforeYield = exitCode !== 0 && stderr.trim().length > 0;
@@ -571,9 +515,7 @@ export function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): Fi
 				rawOutput = rawOutput ? `${SUBAGENT_WARNING_NULL_YIELD}\n\n${rawOutput}` : SUBAGENT_WARNING_NULL_YIELD;
 			} else {
 				const { validator, error: schemaError } = buildOutputValidator(outputSchema);
-				const completeData = assembled.rawText
-					? assembled.data
-					: normalizeCompleteData(assembled.data, reportFindings, validator);
+				const completeData = assembled.rawText ? assembled.data : parseStringifiedJson(assembled.data ?? null);
 				const result =
 					schemaError || assembled.schemaOverridden
 						? { success: true as const }
@@ -614,7 +556,7 @@ export function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): Fi
 		const fallback = allowFallback ? resolveFallbackCompletion(rawOutput, outputSchema) : null;
 		if (fallback) {
 			const { validator } = buildOutputValidator(outputSchema);
-			const completeData = normalizeCompleteData(fallback.data, reportFindings, validator);
+			const completeData = parseStringifiedJson(fallback.data ?? null);
 			const result = validator?.validate(completeData) ?? { success: true as const };
 			if (!result.success) {
 				const summary = summarizeValidationFailure(result, completeData, validator?.requiredFields ?? []);
@@ -1202,17 +1144,7 @@ function createSubagentRunMonitor(args: RunMonitorArgs): SubagentRunMonitor {
 	const recordExtractedToolData = (toolName: string, data: unknown): void => {
 		progress.extractedToolData = progress.extractedToolData || {};
 		const existing = progress.extractedToolData[toolName] || [];
-		const findingKey = toolName === "report_finding" ? getReportFindingKey(data) : null;
-		if (findingKey) {
-			const existingIndex = existing.findIndex(item => getReportFindingKey(item) === findingKey);
-			if (existingIndex >= 0) {
-				existing[existingIndex] = data;
-			} else {
-				existing.push(data);
-			}
-		} else {
-			existing.push(data);
-		}
+		existing.push(data);
 		progress.extractedToolData[toolName] = existing;
 		if (toolName === "yield") {
 			yieldCalled = true;
@@ -1802,8 +1734,6 @@ async function finalizeRunResult(args: FinalizeRunArgs): Promise<SingleResult> {
 	// Use final output if available, otherwise accumulated output
 	let rawOutput = monitor.rawOutput();
 	const yieldItems = progress.extractedToolData?.yield as YieldItem[] | undefined;
-	const reportFindingDetails = progress.extractedToolData?.report_finding as ReportFindingDetails[] | undefined;
-	const reportFindings: ReviewFinding[] | undefined = reportFindingDetails?.map(toReviewFinding);
 	// Breadcrumb the synchronous yield-payload shaping (O(rawOutput)) so a block
 	// here is attributed to this subagent rather than logged as "unknown".
 	pushLoopPhase(`subagent:${id}`);
@@ -1816,7 +1746,6 @@ async function finalizeRunResult(args: FinalizeRunArgs): Promise<SingleResult> {
 			doneAborted: Boolean(done.aborted),
 			signalAborted: Boolean(signal?.aborted),
 			yieldItems,
-			reportFindings,
 			outputSchema: args.outputSchema,
 			lastAssistantText: monitor.lastAssistantSalvageText(),
 		});
@@ -2192,10 +2121,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	if (atMaxDepth && toolNames?.includes("task")) {
 		toolNames = toolNames.filter(name => name !== "task");
 	}
-	// IRC is always available; the COOP prompt section advertises it, so a restricted
-	// whitelist must still carry `irc` for the subagent to actually use it.
-	if (toolNames && !toolNames.includes("irc")) {
-		toolNames = [...toolNames, "irc"];
+	// The hub is always available; the COOP prompt section advertises messaging,
+	// so a restricted whitelist must still carry `hub` for the subagent to use it.
+	if (toolNames && !toolNames.includes("hub")) {
+		toolNames = [...toolNames, "hub"];
 	}
 	if (toolNames?.includes("exec")) {
 		const backends = resolveEvalBackends({ settings } as ToolSession);
@@ -2579,7 +2508,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			// except under prewalk, whose plan nudge + todo gate require the
 			// subagent to commit its own todo list before the hand-off.
 			const isParentOwnedTool = (name: string): boolean => !prewalk && name === "todo";
-			const subagentToolNames = session.getActiveToolNames();
+			const subagentToolNames = session.getEnabledToolNames();
 			const filteredSubagentTools = subagentToolNames.filter(name => !isParentOwnedTool(name));
 			if (filteredSubagentTools.length !== subagentToolNames.length) {
 				await awaitAbortable(session.setActiveToolsByName(filteredSubagentTools));
@@ -2635,7 +2564,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						setLabel: (targetId, label) => {
 							session.sessionManager.appendLabelChange(targetId, label);
 						},
-						getActiveTools: () => session.getActiveToolNames(),
+						getActiveTools: () => session.getEnabledToolNames(),
 						getAllTools: () => session.getAllToolNames(),
 						setActiveTools: (toolNames: string[]) =>
 							session.setActiveToolsByName(toolNames.filter(name => !isParentOwnedTool(name))),
diff --git a/packages/coding-agent/src/task/index.ts b/packages/coding-agent/src/task/index.ts
index 3f8276137..2e787c297 100644
--- a/packages/coding-agent/src/task/index.ts
+++ b/packages/coding-agent/src/task/index.ts
@@ -28,7 +28,7 @@ import subagentUserPromptTemplate from "../prompts/system/subagent-user-prompt.m
 import taskDescriptionTemplate from "../prompts/tools/task.md" with { type: "text" };
 import taskSummaryTemplate from "../prompts/tools/task-summary.md" with { type: "text" };
 import { truncateForPrompt } from "../tools/approval";
-import { isIrcEnabled } from "../tools/irc";
+import { isIrcEnabled } from "../tools/hub";
 import { formatBytes, formatDuration } from "../tools/render-utils";
 import { resolveSpawnPolicy } from "./spawn-policy";
 import {
@@ -142,9 +142,8 @@ export const READ_ONLY_TOOL_NAMES: ReadonlySet<string> = new Set([
 	"web_search",
 	"ast_grep",
 	"yield",
-	"irc",
+	"hub",
 	"ask",
-	"job",
 	"todo",
 	"recall",
 	"reflect",
@@ -153,12 +152,9 @@ export const READ_ONLY_TOOL_NAMES: ReadonlySet<string> = new Set([
 	"inspect_image",
 	"checkpoint",
 	"rewind",
-	"resolve",
-	"report_finding",
-	"search_tool_bm25",
 ]);
 
-const PLAN_MODE_AGENT_TOOL_ALLOWLIST: ReadonlySet<string> = new Set(["ast_grep", "report_finding"]);
+const PLAN_MODE_AGENT_TOOL_ALLOWLIST: ReadonlySet<string> = new Set(["ast_grep"]);
 
 export function isReadOnlyAgent(agent: AgentDefinition): boolean {
 	return !!agent.tools?.length && agent.tools.every(tool => READ_ONLY_TOOL_NAMES.has(tool));
@@ -408,9 +404,10 @@ export function buildSpecializationAdvisory(agentNames: string[], depthCapacity:
 }
 
 /**
- * Suggestion — never a rejection — nudging the spawner to coordinate via `irc`
- * when one call creates ≥2 live siblings and it still holds spawn capacity.
- * Returns undefined when there is nothing to coordinate or IRC is unavailable.
+ * Suggestion — never a rejection — nudging the spawner to coordinate via the
+ * hub when one call creates ≥2 live siblings and it still holds spawn
+ * capacity. Returns undefined when there is nothing to coordinate or peer
+ * messaging is unavailable.
  */
 export function buildCoordinationAdvisory(
 	items: TaskItem[],
@@ -420,8 +417,8 @@ export function buildCoordinationAdvisory(
 	if (!depthCapacity || !ircEnabled || items.length < 2) return undefined;
 	return (
 		`Coordinate: ${items.length} siblings are running together. If their work overlaps, have them ` +
-		`message each other via \`irc\` (by id, or "all" to broadcast) before editing shared files — ` +
-		`live coordination beats a serial handoff. Check \`irc\` op:"list" to see who is doing what.`
+		`message each other via \`hub\` (by id, or "all" to broadcast) before editing shared files — ` +
+		`live coordination beats a serial handoff. Check \`hub\` op:"list" to see who is doing what.`
 	);
 }
 
@@ -535,7 +532,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 	readonly label = "Task";
 	readonly summary = "Spawn subagents to complete delegated tasks";
 	readonly strict = true;
-	readonly loadMode = "discoverable";
+	readonly loadMode = "essential";
 	readonly renderResult = renderResult;
 	// Suppress the streaming call preview once a (partial or final) result exists
 	// so the task renders as ONE block that transitions in place — not a pending
@@ -804,11 +801,11 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		const coordinationHint =
 			started.length === 1
 				? ircEnabled
-					? `DM \`${started[0].agentId}\` via \`irc\` to coordinate while it runs; use \`job\` only to inspect (\`list\`), wait (\`poll\`), or cancel a stuck task.`
-					: `Use \`job\` to inspect (\`list\`), wait (\`poll\`), or cancel a stuck task.`
+					? `DM \`${started[0].agentId}\` via \`hub\` send to coordinate while it runs; use \`hub\` only to inspect (\`jobs\`), wait, or cancel a stuck task.`
+					: `Use \`hub\` to inspect (\`jobs\`), wait, or cancel a stuck task.`
 				: ircEnabled
-					? `DM these ids via \`irc\` to coordinate while they run; use \`job\` only to inspect (\`list\`), wait (\`poll\`), or cancel a stuck task.`
-					: `Use \`job\` to inspect (\`list\`), wait (\`poll\`), or cancel a stuck task by id.`;
+					? `DM these ids via \`hub\` send to coordinate while they run; use \`hub\` only to inspect (\`jobs\`), wait, or cancel a stuck task.`
+					: `Use \`hub\` to inspect (\`jobs\`), wait, or cancel a stuck task by id.`;
 
 		if (syncSpawns.length === 0) {
 			if (spawns.length === 1) {
@@ -934,12 +931,12 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			if (aborted) {
 				const status = AgentRegistry.global().get(agentId)?.status;
 				if (status === "idle" || status === "parked") {
-					const followUp = ircEnabled ? "message it via `irc` to resume; " : "";
+					const followUp = ircEnabled ? "message it via `hub` to resume; " : "";
 					return `\n\n${agentId} was stopped but is still resumable — ${followUp}transcript at history://${agentId}`;
 				}
 				return `\n\n${agentId} was aborted — transcript at history://${agentId}`;
 			}
-			const followUp = ircEnabled ? "message it via `irc` to follow up; " : "";
+			const followUp = ircEnabled ? "message it via `hub` to follow up; " : "";
 			return `\n\n${agentId} is now idle — ${followUp}transcript at history://${agentId}`;
 		};
 		return manager.register(
diff --git a/packages/coding-agent/src/task/persisted-revive.ts b/packages/coding-agent/src/task/persisted-revive.ts
index 16f2edf23..9813b707e 100644
--- a/packages/coding-agent/src/task/persisted-revive.ts
+++ b/packages/coding-agent/src/task/persisted-revive.ts
@@ -113,7 +113,7 @@ export function createPersistedSubagentReviverFactory(
 			// Clamp the active set to the persisted list: createAgentSession's
 			// `alwaysInclude` can re-add non-defaultInactive extension/custom tools
 			// the original run didn't carry. Unknown/missing names are ignored.
-			await session.setActiveToolsByName(init.tools);
+			await session.setActiveToolsByName([...init.tools, ...session.getMountedXdevToolNames()]);
 			// Cold revives must drive registry status themselves — createAgentSession
 			// doesn't wire this generically (the live path does it in the executor).
 			// Without it the idle-TTL timer never clears on a turn and the lifecycle
diff --git a/packages/coding-agent/src/task/render.ts b/packages/coding-agent/src/task/render.ts
index 763095174..2045a2174 100644
--- a/packages/coding-agent/src/task/render.ts
+++ b/packages/coding-agent/src/task/render.ts
@@ -27,11 +27,11 @@ import {
 	truncateToWidth,
 } from "../tools/render-utils";
 import {
+	type FindingDetails,
 	type FindingPriority,
 	getPriorityInfo,
 	PRIORITY_LABELS,
-	parseReportFindingDetails,
-	type ReportFindingDetails,
+	parseFindingDetails,
 	type SubmitReviewDetails,
 } from "../tools/review";
 import { framedBlock, renderStatusLine } from "../tui";
@@ -118,7 +118,7 @@ function appendAgentStats(
 	return line;
 }
 
-function formatFindingSummary(findings: ReportFindingDetails[], theme: Theme): string {
+function formatFindingSummary(findings: FindingDetails[], theme: Theme): string {
 	if (findings.length === 0) return theme.fg("dim", "Findings: none");
 
 	const counts: { [P in FindingPriority]?: number } = {};
@@ -137,11 +137,11 @@ function formatFindingSummary(findings: ReportFindingDetails[], theme: Theme): s
 	return `${theme.fg("dim", "Findings:")} ${parts.join(theme.sep.dot)}`;
 }
 
-function normalizeReportFindings(value: unknown): ReportFindingDetails[] {
+function normalizeFindings(value: unknown): FindingDetails[] {
 	if (!Array.isArray(value)) return [];
-	const findings: ReportFindingDetails[] = [];
+	const findings: FindingDetails[] = [];
 	for (const item of value) {
-		const finding = parseReportFindingDetails(item);
+		const finding = parseFindingDetails(item);
 		if (finding) findings.push(finding);
 	}
 	return findings;
@@ -152,7 +152,7 @@ const REVIEWER_ARRAY_LABELS: ReadonlySet<string> = new Set(["findings"]);
 
 function extractIncrementalReviewResult(
 	items: RenderYieldItem[],
-): { summary: SubmitReviewDetails; findings: ReportFindingDetails[] } | undefined {
+): { summary: SubmitReviewDetails; findings: FindingDetails[] } | undefined {
 	const yieldItems: YieldItem[] = items.map(item => ({
 		data: item.data,
 		type: item.type,
@@ -179,7 +179,7 @@ function extractIncrementalReviewResult(
 			explanation,
 			confidence,
 		},
-		findings: normalizeReportFindings(record.findings),
+		findings: normalizeFindings(record.findings),
 	};
 }
 
@@ -1001,12 +1001,11 @@ function renderAgentProgress(
 
 	// Render extracted tool data inline (e.g., review findings)
 	if (progress.extractedToolData) {
-		// For completed tasks, prefer review verdicts assembled from incremental
-		// yield sections. Fall back to the legacy `report_finding` side-channel.
+		// For completed tasks, render review verdicts assembled from incremental
+		// yield sections.
 		if (progress.status === "completed") {
 			const completeData = normalizeYieldData(progress.extractedToolData.yield);
 			const incrementalReview = extractIncrementalReviewResult(completeData);
-			const reportFindingData = normalizeReportFindings(progress.extractedToolData.report_finding);
 			if (incrementalReview) {
 				lines.push(
 					...renderReviewResult(
@@ -1024,7 +1023,7 @@ function renderAgentProgress(
 				.filter(d => d && typeof d === "object" && "overall_correctness" in d);
 			if (reviewData.length > 0) {
 				const summary = reviewData[reviewData.length - 1];
-				const findings = reportFindingData;
+				const findings: FindingDetails[] = [];
 				lines.push(...renderReviewResult(summary, findings, continuePrefix, expanded, theme));
 				return lines; // Review result handles its own rendering
 			}
@@ -1037,15 +1036,6 @@ function renderAgentProgress(
 				continue;
 			}
 
-			// Handle report_finding with tree formatting
-			if (toolName === "report_finding") {
-				const findings = normalizeReportFindings(dataArray);
-				if (findings.length === 0) continue;
-				lines.push(`${continuePrefix}${formatFindingSummary(findings, theme)}`);
-				lines.push(...renderFindings(findings, continuePrefix, expanded, theme));
-				continue;
-			}
-
 			// Nested `task` data has its own dedicated tree renderer below that
 			// also merges in the in-flight snapshot — skip the generic inline
 			// path so we don't render twice.
@@ -1117,7 +1107,7 @@ function renderAgentProgress(
  */
 function renderReviewResult(
 	summary: SubmitReviewDetails,
-	findings: ReportFindingDetails[],
+	findings: FindingDetails[],
 	continuePrefix: string,
 	expanded: boolean,
 	theme: Theme,
@@ -1167,12 +1157,7 @@ function renderReviewResult(
 /**
  * Render review findings list.
  */
-function renderFindings(
-	findings: ReportFindingDetails[],
-	continuePrefix: string,
-	expanded: boolean,
-	theme: Theme,
-): string[] {
+function renderFindings(findings: FindingDetails[], continuePrefix: string, expanded: boolean, theme: Theme): string[] {
 	const lines: string[] = [];
 
 	// Sort by priority (lower = more severe) when collapsed to show most important first
@@ -1291,14 +1276,12 @@ function renderAgentResult(
 			)}`,
 		);
 	}
-	// Check for review result, preferring incremental yield sections and falling
-	// back to the legacy `report_finding` side-channel.
+	// Check for review result from incremental yield sections.
 	// `normalizeYieldData` guards against a stray non-array `yield` slot —
 	// optional chaining on `.map` only short-circuits on null/undefined and
 	// would otherwise crash the renderer with `TypeError: completeData?.map
 	// is not a function` when the slot is a plain object (see issue #1987).
 	const completeData = normalizeYieldData(result.extractedToolData?.yield);
-	const reportFindingData = normalizeReportFindings(result.extractedToolData?.report_finding);
 	const incrementalReview = extractIncrementalReviewResult(completeData);
 
 	if (incrementalReview) {
@@ -1316,20 +1299,10 @@ function renderAgentResult(
 
 	if (submitReviewData) {
 		const summary = submitReviewData[submitReviewData.length - 1];
-		const findings = reportFindingData;
+		const findings: FindingDetails[] = [];
 		lines.push(...renderReviewResult(summary, findings, continuePrefix, expanded, theme));
 		return lines;
 	}
-	if (reportFindingData.length > 0) {
-		const hasCompleteData = completeData.length > 0;
-		const message = hasCompleteData
-			? "Review verdict missing expected fields"
-			: "Review incomplete (yield not called)";
-		lines.push(`${continuePrefix}${theme.fg("warning", theme.status.warning)} ${theme.fg("dim", message)}`);
-		lines.push(`${continuePrefix}${formatFindingSummary(reportFindingData, theme)}`);
-		lines.push(...renderFindings(reportFindingData, continuePrefix, expanded, theme));
-		return lines;
-	}
 
 	// Check for extracted tool data with custom renderers (skip review tools)
 	let hasCustomRendering = false;
@@ -1345,8 +1318,6 @@ function renderAgentResult(
 				}
 				continue;
 			}
-			// Skip review tools - handled above
-			if (toolName === "report_finding") continue;
 
 			const isTaskTool = toolName === "task";
 			if (isTaskTool && (dataArray as unknown[]).length > 0) {
diff --git a/packages/coding-agent/src/tool-discovery/mode.ts b/packages/coding-agent/src/tool-discovery/mode.ts
deleted file mode 100644
index 21d4a613d..000000000
--- a/packages/coding-agent/src/tool-discovery/mode.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import type { Settings } from "../config/settings";
-import type { SettingValue } from "../config/settings-schema";
-
-export const TOOL_DISCOVERY_AUTO_THRESHOLD = 40;
-export const TOOL_DISCOVERY_SEARCH_TOOL_NAME = "search_tool_bm25";
-
-export type ToolDiscoveryModeSetting = SettingValue<"tools.discoveryMode">;
-export type EffectiveToolDiscoveryMode = Exclude<ToolDiscoveryModeSetting, "auto">;
-
-export function countToolsForAutoDiscovery(toolNames: Iterable<string>): number {
-	let count = 0;
-	for (const name of toolNames) {
-		if (name !== TOOL_DISCOVERY_SEARCH_TOOL_NAME) count++;
-	}
-	return count;
-}
-
-export function resolveEffectiveToolDiscoveryMode(settings: Settings, toolCount: number): EffectiveToolDiscoveryMode {
-	const configuredMode = settings.get("tools.discoveryMode");
-	if (configuredMode === "all" || configuredMode === "mcp-only") return configuredMode;
-	if (settings.get("mcp.discoveryMode")) return "mcp-only";
-	if (configuredMode === "auto" && toolCount > TOOL_DISCOVERY_AUTO_THRESHOLD) return "mcp-only";
-	return "off";
-}
diff --git a/packages/coding-agent/src/tool-discovery/tool-index.ts b/packages/coding-agent/src/tool-discovery/tool-index.ts
deleted file mode 100644
index a3f4e7526..000000000
--- a/packages/coding-agent/src/tool-discovery/tool-index.ts
+++ /dev/null
@@ -1,271 +0,0 @@
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { Tool as AiTool } from "@oh-my-pi/pi-ai";
-import { toolWireSchema } from "@oh-my-pi/pi-ai/utils/schema";
-
-// ─── Generic Tool Discovery Types ────────────────────────────────────────────
-
-export type DiscoverableToolSource = "builtin" | "mcp" | "extension" | "custom";
-
-export interface DiscoverableTool {
-	name: string;
-	label: string;
-	/** Short BM25 corpus entry; falls back to description first 200 chars */
-	summary: string;
-	source: DiscoverableToolSource;
-	/** MCP only */
-	serverName?: string;
-	/** MCP only */
-	mcpToolName?: string;
-	schemaKeys: string[];
-}
-
-export interface DiscoverableToolServerSummary {
-	name: string;
-	toolCount: number;
-}
-
-export interface DiscoverableToolSummary {
-	servers: DiscoverableToolServerSummary[];
-	toolCount: number;
-}
-
-export interface DiscoverableToolSearchDocument {
-	tool: DiscoverableTool;
-	termFrequencies: Map<string, number>;
-	length: number;
-}
-
-export interface DiscoverableToolSearchIndex {
-	documents: DiscoverableToolSearchDocument[];
-	averageLength: number;
-	documentFrequencies: Map<string, number>;
-}
-
-export interface DiscoverableToolSearchResult {
-	tool: DiscoverableTool;
-	score: number;
-}
-
-// ─── BM25 Constants ───────────────────────────────────────────────────────────
-
-const BM25_K1 = 1.2;
-const BM25_B = 0.75;
-const BM25_DELTA = 1.0;
-const FIELD_WEIGHTS = {
-	name: 6,
-	label: 4,
-	serverName: 2,
-	mcpToolName: 4,
-	summary: 2,
-	schemaKey: 1,
-} as const;
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-export function isMCPToolName(name: string): boolean {
-	return name.startsWith("mcp__");
-}
-
-function getSchemaPropertyKeys(tool: Pick<AiTool, "name" | "description" | "parameters">): string[] {
-	let parameters: unknown = tool.parameters;
-	try {
-		parameters = toolWireSchema(tool as AiTool);
-	} catch {
-		// Schema may contain functions or cycles; fall back to the raw shape.
-	}
-	if (!parameters || typeof parameters !== "object" || Array.isArray(parameters)) return [];
-	const properties = (parameters as { properties?: unknown }).properties;
-	if (!properties || typeof properties !== "object" || Array.isArray(properties)) return [];
-	return Object.keys(properties as Record<string, unknown>).sort();
-}
-
-function tokenize(value: string): string[] {
-	return (
-		value
-			.normalize("NFKD")
-			// Drop combining marks (accents) so "café" → "cafe".
-			.replace(/\p{M}+/gu, "")
-			// Split ACRONYMBoundary: "MCPTool" → "MCP Tool".
-			.replace(/(\p{Lu}+)(\p{Lu}\p{Ll})/gu, "$1 $2")
-			// Split camelCase / digit→letter: "fooBar" → "foo Bar", "v2Beta" → "v2 Beta".
-			.replace(/(\p{Ll}|\p{N})(\p{Lu})/gu, "$1 $2")
-			// Everything that isn't a letter or digit becomes a separator. This subsumes markdown
-			// punctuation (`|*_`#-~>[]()`), box-drawing glyphs (─│┌), em/en dashes, smart quotes,
-			// zero-width spaces, NBSPs, etc.
-			.replace(/[^\p{L}\p{N}]+/gu, " ")
-			.toLowerCase()
-			.trim()
-			.split(/\s+/)
-			.filter(token => token.length > 0)
-	);
-}
-
-function addWeightedTokens(termFrequencies: Map<string, number>, value: string | undefined, weight: number): void {
-	if (!value) return;
-	for (const token of tokenize(value)) {
-		termFrequencies.set(token, (termFrequencies.get(token) ?? 0) + weight);
-	}
-}
-
-function buildSearchDocument(tool: DiscoverableTool): DiscoverableToolSearchDocument {
-	const termFrequencies = new Map<string, number>();
-	addWeightedTokens(termFrequencies, tool.name, FIELD_WEIGHTS.name);
-	addWeightedTokens(termFrequencies, tool.label, FIELD_WEIGHTS.label);
-	addWeightedTokens(termFrequencies, tool.serverName, FIELD_WEIGHTS.serverName);
-	addWeightedTokens(termFrequencies, tool.mcpToolName, FIELD_WEIGHTS.mcpToolName);
-	addWeightedTokens(termFrequencies, tool.summary, FIELD_WEIGHTS.summary);
-	for (const schemaKey of tool.schemaKeys) {
-		addWeightedTokens(termFrequencies, schemaKey, FIELD_WEIGHTS.schemaKey);
-	}
-	const length = Array.from(termFrequencies.values()).reduce((sum, value) => sum + value, 0);
-	return { tool, termFrequencies, length };
-}
-
-// ─── Generic Tool Discovery Functions ────────────────────────────────────────
-
-/**
- * Convert a raw AgentTool into a DiscoverableTool generic descriptor.
- * source: "mcp" if name starts with "mcp__", else "builtin" (caller may override).
- */
-export function getDiscoverableTool(
-	tool: AgentTool,
-	overrides?: { source?: DiscoverableToolSource; summary?: string },
-): DiscoverableTool | null {
-	const toolRecord = tool as AgentTool & {
-		label?: string;
-		description?: string;
-		mcpServerName?: string;
-		summary?: string;
-		mcpToolName?: string;
-		parameters?: unknown;
-	};
-	const source: DiscoverableToolSource = overrides?.source ?? (isMCPToolName(tool.name) ? "mcp" : "builtin");
-	const rawSummary =
-		typeof overrides?.summary === "string"
-			? overrides.summary
-			: typeof toolRecord.summary === "string"
-				? toolRecord.summary
-				: undefined;
-	const rawDescription = typeof toolRecord.description === "string" ? toolRecord.description : "";
-	const summary = rawSummary ?? rawDescription.slice(0, 200);
-	return {
-		name: tool.name,
-		label: typeof toolRecord.label === "string" ? toolRecord.label : tool.name,
-		summary,
-		source,
-		serverName: typeof toolRecord.mcpServerName === "string" ? toolRecord.mcpServerName : undefined,
-		mcpToolName: typeof toolRecord.mcpToolName === "string" ? toolRecord.mcpToolName : undefined,
-		schemaKeys:
-			toolRecord.parameters === undefined
-				? []
-				: getSchemaPropertyKeys({
-						name: tool.name,
-						description: rawDescription,
-						parameters: toolRecord.parameters as AiTool["parameters"],
-					}),
-	};
-}
-
-/** Collect all DiscoverableTools from a tool iterable. Skips tools that return null. */
-export function collectDiscoverableTools(
-	tools: Iterable<AgentTool>,
-	options?: { source?: DiscoverableToolSource; summaryMap?: Map<string, string> },
-): DiscoverableTool[] {
-	const discoverable: DiscoverableTool[] = [];
-	for (const tool of tools) {
-		const summary = options?.summaryMap?.get(tool.name);
-		const meta = getDiscoverableTool(tool, { source: options?.source, summary });
-		if (meta) {
-			discoverable.push(meta);
-		}
-	}
-	return discoverable;
-}
-
-/** Filter discoverable tools by source */
-export function filterBySource(tools: DiscoverableTool[], source: DiscoverableToolSource): DiscoverableTool[] {
-	return tools.filter(t => t.source === source);
-}
-
-export function formatDiscoverableToolServerSummary(server: DiscoverableToolServerSummary): string {
-	const toolLabel = server.toolCount === 1 ? "tool" : "tools";
-	return `${server.name} (${server.toolCount} ${toolLabel})`;
-}
-
-export function selectDiscoverableToolNamesByServer(
-	tools: Iterable<DiscoverableTool>,
-	serverNames: ReadonlySet<string>,
-): string[] {
-	if (serverNames.size === 0) return [];
-	return Array.from(tools)
-		.filter(tool => tool.serverName !== undefined && serverNames.has(tool.serverName))
-		.map(tool => tool.name);
-}
-
-export function summarizeDiscoverableTools(tools: DiscoverableTool[]): DiscoverableToolSummary {
-	const serverToolCounts = new Map<string, number>();
-	for (const tool of tools) {
-		if (!tool.serverName) continue;
-		serverToolCounts.set(tool.serverName, (serverToolCounts.get(tool.serverName) ?? 0) + 1);
-	}
-	const servers = Array.from(serverToolCounts.entries())
-		.sort(([left], [right]) => left.localeCompare(right))
-		.map(([name, toolCount]) => ({ name, toolCount }));
-	return {
-		servers,
-		toolCount: tools.length,
-	};
-}
-
-export function buildDiscoverableToolSearchIndex(tools: Iterable<DiscoverableTool>): DiscoverableToolSearchIndex {
-	const documents = Array.from(tools, buildSearchDocument);
-	const averageLength = documents.reduce((sum, document) => sum + document.length, 0) / documents.length || 1;
-	const documentFrequencies = new Map<string, number>();
-	for (const document of documents) {
-		for (const token of new Set(document.termFrequencies.keys())) {
-			documentFrequencies.set(token, (documentFrequencies.get(token) ?? 0) + 1);
-		}
-	}
-	return {
-		documents,
-		averageLength,
-		documentFrequencies,
-	};
-}
-
-export function searchDiscoverableTools(
-	index: DiscoverableToolSearchIndex,
-	query: string,
-	limit: number,
-): DiscoverableToolSearchResult[] {
-	const queryTokens = tokenize(query);
-	if (queryTokens.length === 0) {
-		throw new Error("Query must contain at least one letter or number.");
-	}
-	if (index.documents.length === 0) {
-		return [];
-	}
-
-	const queryTermCounts = new Map<string, number>();
-	for (const token of queryTokens) {
-		queryTermCounts.set(token, (queryTermCounts.get(token) ?? 0) + 1);
-	}
-
-	return index.documents
-		.map(document => {
-			let score = 0;
-			for (const [token, queryTermCount] of queryTermCounts) {
-				const termFrequency = document.termFrequencies.get(token) ?? 0;
-				if (termFrequency === 0) continue;
-				const documentFrequency = index.documentFrequencies.get(token) ?? 0;
-				const idf = Math.log(1 + (index.documents.length - documentFrequency + 0.5) / (documentFrequency + 0.5));
-				const normalization = BM25_K1 * (1 - BM25_B + BM25_B * (document.length / index.averageLength));
-				score +=
-					queryTermCount * idf * ((termFrequency * (BM25_K1 + 1)) / (termFrequency + normalization) + BM25_DELTA);
-			}
-			return { tool: document.tool, score };
-		})
-		.filter(result => result.score > 0)
-		.sort((left, right) => right.score - left.score || left.tool.name.localeCompare(right.tool.name))
-		.slice(0, limit);
-}
diff --git a/packages/coding-agent/src/tools/bash.ts b/packages/coding-agent/src/tools/bash.ts
index 0499e86d3..b4a3126e3 100644
--- a/packages/coding-agent/src/tools/bash.ts
+++ b/packages/coding-agent/src/tools/bash.ts
@@ -403,7 +403,7 @@ export class BashTool implements AgentTool<typeof bashSchemaBase | typeof bashSc
 			hasGrep: isToolActive("grep", this.session.settings.get("grep.enabled")),
 			hasGlob: isToolActive("glob", this.session.settings.get("glob.enabled")),
 			hasRead: isToolActive("read", true),
-			hasLaunch: isToolActive("launch", this.session.settings.get("launch.enabled")),
+			hasLaunch: isToolActive("hub", this.session.settings.get("launch.enabled")),
 			hasEval: isToolActive(
 				"eval",
 				evalBackends.python || evalBackends.js || evalBackends.ruby || evalBackends.julia,
diff --git a/packages/coding-agent/src/tools/builtin-names.ts b/packages/coding-agent/src/tools/builtin-names.ts
index fbd2ba98a..2ae33c70c 100644
--- a/packages/coding-agent/src/tools/builtin-names.ts
+++ b/packages/coding-agent/src/tools/builtin-names.ts
@@ -1,14 +1,12 @@
 export const BUILTIN_TOOL_NAMES = [
 	"read",
 	"bash",
-	"launch",
 	"edit",
 	"ast_grep",
 	"ast_edit",
 	"ask",
 	"debug",
 	"eval",
-	"ssh",
 	"github",
 	"glob",
 	"grep",
@@ -18,11 +16,9 @@ export const BUILTIN_TOOL_NAMES = [
 	"checkpoint",
 	"rewind",
 	"task",
-	"job",
-	"irc",
+	"hub",
 	"todo",
 	"web_search",
-	"search_tool_bm25",
 	"write",
 	"memory_edit",
 	"retain",
@@ -34,6 +30,11 @@ export const BUILTIN_TOOL_NAMES = [
 
 export type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
 
+/** Hidden built-ins: constructible and `--tools`-addressable, but never part of the default active set. */
+export const HIDDEN_TOOL_NAMES = ["yield", "goal"] as const;
+
+export type HiddenToolName = (typeof HIDDEN_TOOL_NAMES)[number];
+
 const LEGACY_BUILTIN_TOOL_NAME_ALIASES: ReadonlyMap<string, BuiltinToolName> = new Map([
 	["search", "grep"],
 	["find", "glob"],
@@ -57,3 +58,8 @@ export function normalizeToolNames(names: Iterable<string>): string[] {
 	}
 	return out;
 }
+
+/** MCP tool names carry the `mcp__<server>_<tool>` prefix minted by `createMCPToolName`. */
+export function isMCPToolName(name: string): boolean {
+	return name.startsWith("mcp__");
+}
diff --git a/packages/coding-agent/src/tools/grep.ts b/packages/coding-agent/src/tools/grep.ts
index d31cf0568..e28756a14 100644
--- a/packages/coding-agent/src/tools/grep.ts
+++ b/packages/coding-agent/src/tools/grep.ts
@@ -1432,17 +1432,6 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 					}, 0);
 					let lastEmittedLine: number | undefined;
 					const gutterPad = " ".repeat(lineNumberWidth + 1);
-					// Track match/context lines whose displayed text was
-					// column-truncated by the native (see `crates/pi-natives/src/grep.rs`
-					// `truncate_line`, marker `...` at max_columns). Excluded from
-					// seenLines so a follow-up edit anchored at that line still
-					// requires a full-width re-read — the model saw only the
-					// prefix. The native currently propagates `truncated` only on
-					// the match line; context lines fall back to a length check
-					// against `DEFAULT_MAX_COLUMN` as a conservative heuristic.
-					const clippedLines = new Set<number>();
-					const isNativeTruncated = (line: string): boolean =>
-						line.length >= DEFAULT_MAX_COLUMN && line.endsWith("...");
 					for (const match of fileMatches) {
 						const pushLine = (lineNumber: number, line: string, isMatch: boolean) => {
 							if (lastEmittedLine !== undefined && lineNumber > lastEmittedLine + 1) {
@@ -1456,31 +1445,20 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 						if (match.contextBefore) {
 							for (const ctx of match.contextBefore) {
 								pushLine(ctx.lineNumber, ctx.line, false);
-								if (isNativeTruncated(ctx.line)) clippedLines.add(ctx.lineNumber);
 							}
 						}
 						pushLine(match.lineNumber, match.line, true);
-						if (match.truncated) {
-							linesTruncated = true;
-							clippedLines.add(match.lineNumber);
-						}
+						if (match.truncated) linesTruncated = true;
 						if (match.contextAfter) {
 							for (const ctx of match.contextAfter) {
 								pushLine(ctx.lineNumber, ctx.line, false);
-								if (isNativeTruncated(ctx.line)) clippedLines.add(ctx.lineNumber);
 							}
 						}
 						fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
 					}
 					if (hashContext?.tag) {
 						const absoluteFilePath = path.resolve(this.session.cwd, relativePath);
-						recordSeenLinesFromBody(
-							this.session,
-							absoluteFilePath,
-							hashContext.tag,
-							modelOut.join("\n"),
-							clippedLines,
-						);
+						recordSeenLinesFromBody(this.session, absoluteFilePath, hashContext.tag, modelOut.join("\n"));
 					}
 					return { model: modelOut, display: displayOut };
 				};
diff --git a/packages/coding-agent/src/tools/hub/index.ts b/packages/coding-agent/src/tools/hub/index.ts
new file mode 100644
index 000000000..9ce14e534
--- /dev/null
+++ b/packages/coding-agent/src/tools/hub/index.ts
@@ -0,0 +1,576 @@
+/**
+ * Hub tool — the single agent-coordination surface: peer messaging over the
+ * IrcBus, lifecycle control for async background jobs, and supervision of
+ * project-scoped long-running processes (launch).
+ *
+ * Op families:
+ * - messaging: `send` (with `to`), `inbox`, `list`, `wait` (with `from`);
+ * - jobs: `wait` (bare or with `ids`), `cancel`, `jobs`;
+ * - processes: `start`, `ps`, `logs`, `stop`, `restart`, `describe`, plus
+ *   `send`/`wait` when they carry a process `name`.
+ *
+ * The unified `wait` blocks until the FIRST of: a matching peer message, a
+ * watched job settling, the wait window elapsing, or a steering interrupt.
+ * Job results always deliver themselves when they finish — `wait` exists for
+ * when the agent has nothing else to do.
+ */
+
+import type {
+	AgentTool,
+	AgentToolContext,
+	AgentToolResult,
+	AgentToolUpdateCallback,
+	ToolApprovalDecision,
+} from "@oh-my-pi/pi-agent-core";
+import type { ToolExample } from "@oh-my-pi/pi-ai";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { prompt } from "@oh-my-pi/pi-utils";
+import { type } from "arktype";
+import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
+import { IrcBus } from "../../irc/bus";
+import type { Theme } from "../../modes/theme/theme";
+import hubDescription from "../../prompts/tools/hub.md" with { type: "text" };
+import type { AgentRegistry } from "../../registry/agent-registry";
+import type { ToolSession } from "..";
+import {
+	buildJobResult,
+	executeCancel,
+	executeJobsSnapshot,
+	jobsRenderCall,
+	jobsRenderResult,
+	noMatchingJobsResult,
+	nothingToWaitForResult,
+	resolvePollWindow,
+	snapshotJobs,
+	visibleJobs,
+} from "./jobs";
+import {
+	executeLaunch,
+	type LaunchParams,
+	type LaunchRenderArgs,
+	type LaunchToolDetails,
+	launchRenderCall,
+	launchRenderResult,
+} from "./launch";
+import {
+	drainPendingInbox,
+	executeInbox,
+	executeList,
+	executeMessageWait,
+	executeSend,
+	messageResult,
+	messagingRenderCall,
+	messagingRenderResult,
+	normalizeIrcTimeoutMs,
+} from "./messaging";
+import { type HubDetails, type HubRenderArgs, hubErrorResult } from "./types";
+
+export { isWaitingPollDetails } from "./jobs";
+export type { LaunchParams, LaunchToolDetails } from "./launch";
+export { createIrcMessageCard, isIrcEnabled } from "./messaging";
+export * from "./types";
+
+const hubSchema = type({
+	op: type(
+		"'send' | 'wait' | 'inbox' | 'list' | 'jobs' | 'cancel' | 'start' | 'ps' | 'logs' | 'stop' | 'restart' | 'describe'",
+	).describe("hub operation"),
+	"to?": type("string").describe('send: recipient agent id or "all"'),
+	"message?": type("string").describe("send: message body"),
+	"replyTo?": type("string").describe("send: message id being answered"),
+	"await?": type("boolean").describe('send: wait for the recipient\'s reply (invalid with to:"all")'),
+	"from?": type("string").describe("wait: only accept a message from this agent id"),
+	"ids?": type("string[]").describe("wait: job ids to watch (omit = all running jobs); cancel: job ids to kill"),
+	"timeoutMs?": type("number").describe("wait (messages/jobs): timeout in milliseconds (0 waits indefinitely)"),
+	"peek?": type("boolean").describe("inbox: list messages without consuming them"),
+	"name?": type("string <= 48").describe("process ops: stable project-scoped launch name"),
+	"application?": type("string > 0").describe("start: executable or application path"),
+	"args?": type("string[]").describe("start: argv passed directly to the application"),
+	"env?": type({ "[string]": "string" }).describe("start: extra environment variables"),
+	"cwd?": type("string").describe("start: working directory; defaults to the session directory"),
+	"pty?": type("boolean").describe("start: allocate an interactive PTY; default true"),
+	"ready?": type({
+		"log?": type("string > 0").describe("regex matched against output"),
+		"port?": type("number").describe("TCP port that must accept connections"),
+		"host?": type("string > 0").describe("TCP readiness host; default 127.0.0.1"),
+		"timeout?": type("number > 0").describe("seconds to wait; default 30"),
+	}).describe("start: readiness conditions; all supplied conditions must pass"),
+	"restart?": type("'no' | 'on-failure' | 'always'").describe("start: restart policy; default no"),
+	"persist?": type("boolean").describe("start: survive the last omp client exiting; default false"),
+	"detached?": type("boolean").describe(
+		"start: survive every omp and broker exit; implies persist and disables PTY input",
+	),
+	"lines?": type("number > 0").describe("logs: output lines; default 100, max 1000"),
+	"head?": type("boolean").describe("logs: read from the beginning instead of the tail"),
+	"grep?": type("string > 0").describe("logs: regex filter"),
+	"follow?": type("boolean").describe("logs: wait for output newer than cursor"),
+	"cursor?": type("number >= 0").describe("logs: output cursor returned by an earlier call"),
+	"for?": type("'ready' | 'exit'").describe("wait with name: lifecycle condition; default exit"),
+	"pattern?": type("string > 0").describe("wait with name: output regex; takes precedence over for"),
+	"text?": type("string > 0").describe("send with name: stdin text"),
+	"enter?": type("boolean").describe("send with name: append Enter after text; default true"),
+	"keys?": type("string[]").describe("send with name: terminal keys after text"),
+	"signal?": type("'SIGINT' | 'SIGTERM' | 'SIGHUP' | 'SIGQUIT' | 'SIGKILL'").describe(
+		"send with name: process-tree signal",
+	),
+	"timeout?": type("number > 0").describe("logs/stop/wait with name: max seconds; default 30 (stop: 5)"),
+});
+
+type HubParams = typeof hubSchema.infer;
+
+interface MessagingDeps {
+	registry: AgentRegistry;
+	senderId: string;
+	settings: ToolSession["settings"];
+}
+
+const PROGRESS_INTERVAL_MS = 500;
+
+/** Mutating process ops require exec approval; messaging, jobs, and inspection are read-only. */
+function hubApproval(params: unknown): ToolApprovalDecision {
+	if (typeof params !== "object" || params === null || !("op" in params)) return "exec";
+	const op = params.op;
+	switch (op) {
+		case "wait":
+		case "inbox":
+		case "list":
+		case "jobs":
+		case "cancel":
+		case "ps":
+		case "logs":
+		case "describe":
+			return "read";
+		case "send": {
+			// Peer DMs are read-tier; writing to a process stdin is exec-tier.
+			const name = "name" in params ? params.name : undefined;
+			const to = "to" in params ? params.to : undefined;
+			return typeof name === "string" && name.length > 0 && !to ? "exec" : "read";
+		}
+		default:
+			// start / stop / restart and anything unrecognized.
+			return "exec";
+	}
+}
+
+export class HubTool implements AgentTool<typeof hubSchema, HubDetails> {
+	readonly name = "hub";
+	readonly approval = hubApproval;
+	readonly label = "Hub";
+	readonly summary = "Message peer agents, control background jobs, and supervise long-running processes";
+	readonly description: string;
+	readonly parameters = hubSchema;
+	readonly strict = true;
+	readonly interruptible = true;
+	readonly loadMode = "essential";
+
+	readonly examples: readonly ToolExample<typeof hubSchema.infer>[] = [
+		{
+			caption: "List peers",
+			call: { op: "list" },
+		},
+		{
+			caption: "Fire-and-forget DM — same send wakes idle/parked peers",
+			call: {
+				op: "send",
+				to: "AuthLoader",
+				message: "Still touching src/server/auth.ts? I need to add a 401 path.",
+			},
+		},
+		{
+			caption: "Round-trip when you cannot proceed without the answer",
+			call: {
+				op: "send",
+				to: "Main",
+				message: "JWT or session cookies for the auth flow?",
+				await: true,
+			},
+		},
+		{
+			caption: "Completely blocked: wait for the first finished job or incoming message",
+			call: { op: "wait" },
+		},
+		{
+			caption: "Block until a specific peer answers",
+			call: { op: "wait", from: "AuthLoader", timeoutMs: 60000 },
+		},
+		{
+			caption: "Kill a hung background job",
+			call: { op: "cancel", ids: ["bash_a1b2c3"] },
+		},
+		{
+			caption: "Snapshot every background job without waiting",
+			call: { op: "jobs" },
+		},
+		{
+			caption: "Start a dev server and wait for its log banner and port",
+			call: {
+				op: "start",
+				name: "web",
+				application: "bun",
+				args: ["run", "dev"],
+				ready: { log: "Local:.*http", port: 5173, timeout: 30 },
+			},
+		},
+		{
+			caption: "Follow process output after a cursor",
+			call: { op: "logs", name: "web", follow: true, cursor: 1842, timeout: 30 },
+		},
+		{
+			caption: "Drive a REPL/debugger over stdin",
+			call: { op: "send", name: "debugger", text: "breakpoint set --name main" },
+		},
+		{
+			caption: "Interrupt a process",
+			call: { op: "send", name: "debugger", keys: ["CTRL_C"] },
+		},
+		{
+			caption: "Block until a process is ready",
+			call: { op: "wait", name: "web", for: "ready", timeout: 30 },
+		},
+	];
+
+	constructor(private readonly session: ToolSession) {
+		this.description = prompt.render(hubDescription);
+	}
+
+	/** Messaging deps when this session can address peers; null otherwise. */
+	#messaging(): MessagingDeps | null {
+		const registry = this.session.agentRegistry;
+		const senderId = this.session.getAgentId?.() ?? null;
+		if (!registry || !senderId) return null;
+		return { registry, senderId, settings: this.session.settings };
+	}
+
+	async execute(
+		_toolCallId: string,
+		params: HubParams,
+		signal?: AbortSignal,
+		onUpdate?: AgentToolUpdateCallback<HubDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<HubDetails>> {
+		switch (params.op) {
+			case "list": {
+				const messaging = this.#messaging();
+				if (!messaging) return hubErrorResult("Peer messaging is unavailable in this session.", { op: "list" });
+				return executeList(messaging.registry, messaging.senderId);
+			}
+			case "send": {
+				const toPeer = params.to?.trim();
+				const toProcess = params.name?.trim();
+				if (toPeer && toProcess) {
+					return hubErrorResult('`to` (peer) and `name` (process) are mutually exclusive for op="send".', {
+						op: "send",
+					});
+				}
+				if (toProcess) return this.#launch(params, "send", signal);
+				const messaging = this.#messaging();
+				if (!messaging) return hubErrorResult("Peer messaging is unavailable in this session.", { op: "send" });
+				return executeSend(messaging, params, signal);
+			}
+			case "inbox": {
+				const messaging = this.#messaging();
+				if (!messaging) return hubErrorResult("Peer messaging is unavailable in this session.", { op: "inbox" });
+				return executeInbox(messaging.registry, messaging.senderId, params.peek);
+			}
+			case "wait":
+				if (params.name?.trim()) return this.#launch(params, "wait", signal);
+				return this.#executeWait(params, signal, onUpdate);
+			case "cancel": {
+				const manager = this.session.asyncJobManager;
+				if (!manager) return this.#asyncDisabled("cancel");
+				if (!params.ids?.length) {
+					return hubErrorResult('`ids` is required for op="cancel".', { op: "cancel", jobs: [] });
+				}
+				return executeCancel(this.session, manager, this.#ownerId(), params.ids);
+			}
+			case "jobs": {
+				const manager = this.session.asyncJobManager;
+				if (!manager) return this.#asyncDisabled("jobs");
+				return executeJobsSnapshot(this.session, manager, this.#ownerId());
+			}
+			case "start":
+			case "ps":
+			case "logs":
+			case "stop":
+			case "restart":
+			case "describe":
+				return this.#launch(params, params.op === "ps" ? "list" : params.op, signal);
+			default:
+				return hubErrorResult("Unknown hub op.", { op: params.op });
+		}
+	}
+
+	/** Job visibility scope: everything the calling agent owns (tests/SDK without an agent id see all). */
+	#ownerId(): string | undefined {
+		return this.session.getAgentId?.() ?? undefined;
+	}
+
+	#asyncDisabled(op: "cancel" | "jobs"): AgentToolResult<HubDetails> {
+		return {
+			content: [{ type: "text", text: "Async execution is disabled; no background jobs are available." }],
+			details: { op, jobs: [] },
+		};
+	}
+
+	/** Route a process-supervision op to the launch broker, honoring `launch.enabled`. */
+	async #launch(
+		params: HubParams,
+		op: LaunchParams["op"],
+		signal?: AbortSignal,
+	): Promise<AgentToolResult<HubDetails>> {
+		if (!this.session.settings.get("launch.enabled")) {
+			return hubErrorResult("Process supervision is disabled (launch.enabled=false).", { op: params.op });
+		}
+		const { op: _hubOp, ...rest } = params;
+		return executeLaunch(this.session, { ...rest, op }, signal);
+	}
+
+	/**
+	 * Unified wait: race the caller's running jobs against incoming peer
+	 * messages. Returns on the FIRST settled job, the first matching message,
+	 * window expiry, or abort — never "when everything finishes"; the model
+	 * re-issues to keep waiting. With no job legs it degrades to a pure
+	 * message wait; with no messaging it is exactly the old job poll.
+	 */
+	async #executeWait(
+		params: HubParams,
+		signal?: AbortSignal,
+		onUpdate?: AgentToolUpdateCallback<HubDetails>,
+	): Promise<AgentToolResult<HubDetails>> {
+		const messaging = this.#messaging();
+		const manager = this.session.asyncJobManager;
+		const ownerId = this.#ownerId();
+		const from = params.from?.trim() || undefined;
+
+		// A message already buffered on the session satisfies the wait first.
+		if (messaging) {
+			const pending = drainPendingInbox(messaging.registry, messaging.senderId, from);
+			if (pending) return messageResult(messaging.senderId, pending);
+		}
+
+		// Resolve which jobs to watch:
+		// - explicit `ids` → exactly those (owner-scoped; missing ids corrected);
+		// - omitted → every running job the caller owns.
+		const ids = params.ids;
+		const jobsToWatch = manager
+			? ids?.length
+				? visibleJobs(manager, ids, ownerId)
+				: manager.getRunningJobs(ownerId ? { ownerId } : undefined)
+			: [];
+		if (manager && ids?.length && jobsToWatch.length === 0) {
+			return noMatchingJobsResult(this.session, ids);
+		}
+		const runningJobs = jobsToWatch.filter(j => j.status === "running");
+		if (manager && jobsToWatch.length > 0 && runningJobs.length === 0) {
+			// Every explicitly watched job already settled — immediate snapshot.
+			return buildJobResult(this.session, manager, "wait", jobsToWatch, []);
+		}
+
+		if (!manager || runningJobs.length === 0) {
+			// No job legs: pure message wait — or nothing to block on at all.
+			if (!messaging) return nothingToWaitForResult(this.session);
+			if (!from) {
+				// A bare wait can only be satisfied by a running peer eventually
+				// sending something; with none, return the snapshot immediately
+				// instead of blocking a full message-timeout window.
+				const hasRunningPeer = messaging.registry
+					.listVisibleTo(messaging.senderId)
+					.some(ref => ref.status === "running");
+				if (!hasRunningPeer) return nothingToWaitForResult(this.session);
+			}
+			return executeMessageWait(messaging, { from, timeoutMs: params.timeoutMs }, signal);
+		}
+
+		// Wait window: explicit timeout wins (0 = no window); otherwise the
+		// `async.pollWaitDuration` fixed value or smart ladder. The ladder
+		// starts at the floor and climbs as the agent waits in a tight loop,
+		// then resets once it steps away (see AsyncJobManager.nextPollWaitMs).
+		const window = resolvePollWindow(this.session, manager, ownerId);
+		const windowMs = params.timeoutMs !== undefined ? normalizeIrcTimeoutMs(params.timeoutMs) : window.waitMs;
+		const usedSmartWindow = window.smart && params.timeoutMs === undefined;
+
+		const racePromises: Promise<unknown>[] = runningJobs.map(j => j.promise);
+
+		// Message leg: park a bus waiter with no timeout of its own — the race
+		// window governs. Cancelled via sentinel so late losers do not reject.
+		const busAbort = messaging ? new AbortController() : undefined;
+		const busCancelled = new Error("hub wait settled");
+		let removeBusAbortListener: (() => void) | undefined;
+		const busLeg =
+			messaging && busAbort
+				? IrcBus.global()
+						.wait(messaging.senderId, { from }, 0, busAbort.signal)
+						.then(
+							message => ({ message, error: null as Error | null }),
+							error => ({
+								message: null,
+								error:
+									error === busCancelled ? null : error instanceof Error ? error : new Error(String(error)),
+							}),
+						)
+				: undefined;
+		if (busLeg) racePromises.push(busLeg);
+		if (busAbort && signal) {
+			if (signal.aborted) {
+				busAbort.abort(signal.reason instanceof Error ? signal.reason : new Error("hub wait aborted"));
+			} else {
+				const onAbort = (): void => {
+					busAbort.abort(signal.reason instanceof Error ? signal.reason : new Error("hub wait aborted"));
+				};
+				signal.addEventListener("abort", onAbort, { once: true });
+				removeBusAbortListener = () => signal.removeEventListener("abort", onAbort);
+			}
+		}
+
+		const { promise: timeoutPromise, resolve: timeoutResolve } = Promise.withResolvers<void>();
+		const timeoutHandle = windowMs > 0 ? setTimeout(() => timeoutResolve(), windowMs) : undefined;
+		if (timeoutHandle) racePromises.push(timeoutPromise);
+
+		const watchedJobIds = runningJobs.map(job => job.id);
+		manager.watchJobs(watchedJobIds);
+
+		const emitProgress = () => {
+			if (!onUpdate) return;
+			onUpdate({
+				content: [{ type: "text", text: "" }],
+				details: { op: "wait", jobs: snapshotJobs(this.session, jobsToWatch) },
+			});
+		};
+		const progressTimer = onUpdate ? setInterval(emitProgress, PROGRESS_INTERVAL_MS) : undefined;
+		emitProgress();
+
+		try {
+			if (signal) {
+				const { promise: abortPromise, resolve: abortResolve } = Promise.withResolvers<void>();
+				const onAbort = () => abortResolve();
+				signal.addEventListener("abort", onAbort, { once: true });
+				racePromises.push(abortPromise);
+				try {
+					await Promise.race(racePromises);
+				} finally {
+					signal.removeEventListener("abort", onAbort);
+				}
+			} else {
+				await Promise.race(racePromises);
+			}
+		} finally {
+			manager.unwatchJobs(watchedJobIds);
+			if (timeoutHandle) clearTimeout(timeoutHandle);
+			if (progressTimer) clearInterval(progressTimer);
+			busAbort?.abort(busCancelled);
+			removeBusAbortListener?.();
+			if (usedSmartWindow) {
+				// Reset the idle-gap clock: escalate if the agent waits again soon,
+				// drop back to the floor once it goes quiet for a while.
+				manager.recordPollWaitEnd(ownerId);
+			}
+		}
+
+		// A message consumed by the bus waiter must never be dropped — it wins
+		// even a photo-finish race (job results re-deliver themselves; a
+		// dequeued message would otherwise be lost).
+		if (busLeg && messaging) {
+			const settled = await busLeg;
+			if (settled.message) return messageResult(messaging.senderId, settled.message);
+		}
+
+		return buildJobResult(this.session, manager, "wait", jobsToWatch, []);
+	}
+}
+
+// =============================================================================
+// TUI Renderer — dispatches to the preserved messaging/job/launch renderings.
+// =============================================================================
+
+const LAUNCH_OPS: Record<string, true> = {
+	start: true,
+	ps: true,
+	logs: true,
+	stop: true,
+	restart: true,
+	describe: true,
+};
+
+/** Launch-style call: an explicit process op, or `send`/`wait` targeting a process `name`. */
+function isLaunchStyleArgs(args: HubRenderArgs | undefined): boolean {
+	if (!args?.op) return false;
+	if (LAUNCH_OPS[args.op]) return true;
+	return (args.op === "send" || args.op === "wait") && !!args.name && !args.to && !args.from;
+}
+
+/** Job-style call: job ops, or a `wait` that does not target a peer or process. */
+function isJobStyleArgs(args: HubRenderArgs | undefined): boolean {
+	switch (args?.op) {
+		case "jobs":
+		case "cancel":
+			return true;
+		case "wait":
+			return !!args.ids?.length || (!args.from && !args.name);
+		default:
+			return false;
+	}
+}
+
+/** Launch details carry process/broker state; coordination details never define these keys. */
+function isLaunchDetails(details: HubDetails): details is LaunchToolDetails {
+	// `state`/`cursor` cover logs results, which may carry neither a daemon
+	// snapshot nor terminal rows; coordination details never define these keys.
+	return (
+		"daemon" in details ||
+		"daemons" in details ||
+		"terminalRows" in details ||
+		"spec" in details ||
+		"state" in details ||
+		"cursor" in details
+	);
+}
+
+/** Hub args → launch renderer args: `ps` is the broker's `list`; everything else is verbatim. */
+function toLaunchArgs(args: HubRenderArgs | undefined): LaunchRenderArgs {
+	if (!args) return {};
+	const { op, ...rest } = args;
+	return { ...rest, op: op === "ps" ? "list" : op };
+}
+
+export const hubToolRenderer = {
+	inline: true,
+	mergeCallAndResult: true,
+	// Only launch pending frames consume the spinner (broker RPC in flight);
+	// messaging/job pending frames are static, exactly as before the merge.
+	animatedPendingPreview: (args: unknown): boolean => isLaunchStyleArgs(args as HubRenderArgs | undefined),
+
+	renderCall(args: HubRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
+		if (isLaunchStyleArgs(args)) return launchRenderCall(toLaunchArgs(args), options, uiTheme);
+		return isJobStyleArgs(args)
+			? jobsRenderCall(args, options, uiTheme)
+			: messagingRenderCall(args, options, uiTheme);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: HubDetails; isError?: boolean },
+		options: RenderResultOptions,
+		uiTheme: Theme,
+		args?: HubRenderArgs,
+	): Component {
+		// Results dispatch on what actually happened, falling back to the call
+		// shape when details are absent (framework-generated errors).
+		const details = result.details;
+		if (details && isLaunchDetails(details)) {
+			return launchRenderResult({ ...result, details }, options, uiTheme, toLaunchArgs(args));
+		}
+		const coordination = details;
+		if (coordination && (Array.isArray(coordination.jobs) || Array.isArray(coordination.agents))) {
+			return jobsRenderResult({ ...result, details: coordination }, options, uiTheme, args);
+		}
+		if (
+			coordination &&
+			("receipts" in coordination || "waited" in coordination || "inbox" in coordination || "peers" in coordination)
+		) {
+			return messagingRenderResult({ ...result, details: coordination }, options, uiTheme, args);
+		}
+		// Detail-less or op-only results (validation errors, disabled gates).
+		if (isLaunchStyleArgs(args))
+			return launchRenderResult({ ...result, details: undefined }, options, uiTheme, toLaunchArgs(args));
+		if (isJobStyleArgs(args)) return jobsRenderResult({ ...result, details: coordination }, options, uiTheme, args);
+		return messagingRenderResult({ ...result, details: coordination }, options, uiTheme, args);
+	},
+};
diff --git a/packages/coding-agent/src/tools/hub/jobs.ts b/packages/coding-agent/src/tools/hub/jobs.ts
new file mode 100644
index 000000000..a8414efea
--- /dev/null
+++ b/packages/coding-agent/src/tools/hub/jobs.ts
@@ -0,0 +1,614 @@
+/**
+ * Hub jobs half — lifecycle control for async background jobs (bash scripts,
+ * subagents) owned by the calling agent: wait/cancel/snapshot plus the
+ * running-agents roster for activity with no job entry.
+ */
+
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
+import type { AsyncJob, AsyncJobManager } from "../../async";
+import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
+import { shimmerEnabled, shimmerText } from "../../modes/theme/shimmer";
+import type { Theme } from "../../modes/theme/theme";
+import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../../tui";
+import type { ToolSession } from "..";
+import {
+	formatBadge,
+	formatDuration,
+	formatEmptyMessage,
+	formatStatusIcon,
+	getPreviewLines,
+	PREVIEW_LIMITS,
+	replaceTabs,
+	type ToolUIColor,
+	type ToolUIStatus,
+} from "../render-utils";
+import type { AgentActivitySnapshot, CancelOutcome, CoordinationDetails, HubRenderArgs, JobSnapshot } from "./types";
+
+const WAIT_DURATION_MS: Record<string, number> = {
+	"5s": 5_000,
+	"10s": 10_000,
+	"30s": 30_000,
+	"1m": 60_000,
+	"5m": 5 * 60_000,
+};
+
+/**
+ * A wait snapshot where every watched job is still running and nothing was
+ * cancelled — pure "still waiting" noise once a newer wait exists. The TUI
+ * keeps such a block un-finalized (displaceable) so a follow-up `hub` call
+ * replaces it instead of stacking another waiting frame in the transcript.
+ */
+export function isWaitingPollDetails(details: unknown): boolean {
+	const d = details as CoordinationDetails | undefined;
+	if (!d || !Array.isArray(d.jobs) || d.jobs.length === 0) return false;
+	if (d.cancelled?.length) return false;
+	return d.jobs.every(job => job?.status === "running");
+}
+
+/** Poll window for a job-watching wait: `async.pollWaitDuration` fixed value or smart ladder. */
+export function resolvePollWindow(
+	session: ToolSession,
+	manager: AsyncJobManager,
+	ownerId: string | undefined,
+): { waitMs: number; smart: boolean } {
+	const pollSetting = session.settings.get("async.pollWaitDuration");
+	const smart = pollSetting === "smart";
+	const waitMs = smart
+		? manager.nextPollWaitMs(ownerId)
+		: ((pollSetting ? WAIT_DURATION_MS[pollSetting] : undefined) ?? WAIT_DURATION_MS["30s"]);
+	return { waitMs, smart };
+}
+
+/**
+ * Resolve a list of job ids to job records visible to the calling agent.
+ * Drops missing ids and ids owned by other agents, so cross-agent inspection
+ * via the hub is impossible.
+ */
+export function visibleJobs(manager: AsyncJobManager, ids: string[], ownerId: string | undefined): AsyncJob[] {
+	const out: AsyncJob[] = [];
+	for (const id of ids) {
+		const job = manager.getJob(id);
+		if (!job) continue;
+		if (ownerId && job.ownerId !== ownerId) continue;
+		out.push(job);
+	}
+	return out;
+}
+
+/**
+ * Running subagents from the registry that are not covered by one of the
+ * caller's running jobs. Agents woken via hub messaging (idle wake / park
+ * revival) and spawns owned by another agent run with no AsyncJobManager
+ * entry, yet the UI's agent badge counts them — a snapshot must account for
+ * that activity instead of implying the system is quiet. Existence is
+ * already public via the peer roster, so listing ids here leaks nothing new;
+ * job *control* stays owner-scoped.
+ */
+export function runningAgentsOutsideJobs(session: ToolSession): AgentActivitySnapshot[] {
+	const registry = session.agentRegistry;
+	if (!registry) return [];
+	const selfId = session.getAgentId?.() ?? undefined;
+	// Cover = the caller's RUNNING jobs only. A settled job still sitting in
+	// delivery retention must not hide its agent if that agent was re-woken
+	// (e.g. via a hub message) and is running again without a job.
+	const covered = new Set<string>();
+	const manager = session.asyncJobManager;
+	if (manager) {
+		for (const job of manager.getRunningJobs(selfId ? { ownerId: selfId } : undefined)) {
+			covered.add(job.id);
+			if (job.agentId) covered.add(job.agentId);
+		}
+	}
+	const now = Date.now();
+	const out: AgentActivitySnapshot[] = [];
+	for (const ref of registry.list()) {
+		if (ref.kind !== "sub" || ref.status !== "running") continue;
+		if (ref.id === selfId || covered.has(ref.id)) continue;
+		out.push({
+			id: ref.id,
+			...(ref.parentId ? { parentId: ref.parentId } : {}),
+			...(ref.activity ? { activity: ref.activity } : {}),
+			ageMs: Math.max(0, now - ref.createdAt),
+		});
+	}
+	return out;
+}
+
+/** Model-facing lines for the running-agents section shared by `jobs` and empty-wait results. */
+function describeAgents(agents: AgentActivitySnapshot[]): string[] {
+	const lines = [`## Running Agents (${agents.length}) — not job-backed\n`];
+	for (const agent of agents) {
+		const parent = agent.parentId ? ` (spawned by \`${agent.parentId}\`)` : "";
+		const activity = agent.activity ? ` — ${agent.activity}` : "";
+		lines.push(`- \`${agent.id}\`${parent} — up ${formatDuration(agent.ageMs)}${activity}`);
+	}
+	lines.push("", "These agents have no job entry; message them via `hub` send, transcripts at `history://<id>`.");
+	return lines;
+}
+
+interface TrackedJobLike {
+	id: string;
+	type: "bash" | "task";
+	status: string;
+	label: string;
+	startTime: number;
+	resultText?: string;
+	errorText?: string;
+}
+
+export function snapshotJobs(session: ToolSession, jobs: TrackedJobLike[]): JobSnapshot[] {
+	const now = Date.now();
+	return jobs.map(j => {
+		const current = session.asyncJobManager?.getJob(j.id);
+		const latest = current ?? j;
+		return {
+			id: latest.id,
+			type: latest.type,
+			status: latest.status as JobSnapshot["status"],
+			label: latest.label,
+			durationMs: Math.max(0, now - latest.startTime),
+			...(latest.resultText ? { resultText: latest.resultText } : {}),
+			...(latest.errorText ? { errorText: latest.errorText } : {}),
+		};
+	});
+}
+
+export function buildJobResult(
+	session: ToolSession,
+	manager: AsyncJobManager,
+	op: "wait" | "cancel" | "jobs",
+	jobs: TrackedJobLike[],
+	cancelOutcomes: CancelOutcome[],
+	agents: AgentActivitySnapshot[] = [],
+): AgentToolResult<CoordinationDetails> {
+	// Deduplicate by id (cancelled jobs may also appear in the watched set).
+	const seen = new Set<string>();
+	const uniqueJobs = jobs.filter(j => {
+		if (seen.has(j.id)) return false;
+		seen.add(j.id);
+		return true;
+	});
+	const jobResults = snapshotJobs(session, uniqueJobs);
+
+	manager.acknowledgeDeliveries(jobResults.filter(j => j.status !== "running").map(j => j.id));
+
+	const completed = jobResults.filter(j => j.status !== "running");
+	const running = jobResults.filter(j => j.status === "running");
+
+	const lines: string[] = [];
+
+	if (cancelOutcomes.length > 0) {
+		lines.push(`## Cancelled (${cancelOutcomes.length})\n`);
+		for (const o of cancelOutcomes) lines.push(`- ${o.message}`);
+		lines.push("");
+	}
+
+	if (completed.length > 0) {
+		lines.push(`## Completed (${completed.length})\n`);
+		for (const j of completed) {
+			lines.push(`### ${j.id} [${j.type}] — ${j.status}`);
+			lines.push(`Label: ${j.label}`);
+			if (j.resultText) {
+				lines.push("```", j.resultText, "```");
+			}
+			if (j.errorText) {
+				lines.push(`Error: ${j.errorText}`);
+			}
+			lines.push("");
+		}
+	}
+
+	if (running.length > 0) {
+		lines.push(`## Still Running (${running.length})\n`);
+		for (const j of running) {
+			lines.push(`- \`${j.id}\` [${j.type}] — ${j.label}`);
+		}
+	}
+
+	if (agents.length > 0) {
+		if (lines.length > 0) lines.push("");
+		lines.push(...describeAgents(agents));
+	}
+
+	// A tool result must never be empty text — the model cannot tell "no
+	// jobs" from a malfunction (reported exactly that way in QA).
+	if (lines.length === 0) {
+		lines.push("No background jobs.");
+	}
+
+	const details: CoordinationDetails = {
+		op,
+		jobs: jobResults,
+		...(cancelOutcomes.length ? { cancelled: cancelOutcomes.map(({ id, status }) => ({ id, status })) } : {}),
+		...(agents.length ? { agents } : {}),
+	};
+	return {
+		content: [{ type: "text", text: lines.join("\n").trimEnd() }],
+		details,
+		// A wait where everything is still running carries no new information
+		// once a later wait exists — same predicate the TUI uses to displace
+		// stale waiting frames.
+		...(isWaitingPollDetails(details) ? { useless: true } : {}),
+	};
+}
+
+/** `wait` with explicit ids that matched nothing visible: correct the caller, surface live agents. */
+export function noMatchingJobsResult(session: ToolSession, ids: string[]): AgentToolResult<CoordinationDetails> {
+	// Zero pollable jobs is not necessarily "nothing running": agents woken
+	// via hub messages or owned by another agent run with no job entry.
+	// Report them so the snapshot matches the UI's running-agent count
+	// (task job ids are agent ids, so a stale id often names one).
+	const agents = runningAgentsOutsideJobs(session);
+	const lines: string[] = [`No matching jobs found for IDs: ${ids.join(", ")}`];
+	const registry = session.agentRegistry;
+	for (const id of ids) {
+		const ref = registry?.get(id);
+		if (!ref) continue;
+		lines.push(
+			ref.status === "running"
+				? `- \`${id}\` is a running agent with no job entry — message it via \`hub\` send; transcript at history://${id}`
+				: `- \`${id}\` is a ${ref.status} agent (its job is gone) — transcript at history://${id}`,
+		);
+	}
+	if (agents.length > 0) {
+		lines.push("", ...describeAgents(agents));
+	}
+	return {
+		content: [{ type: "text", text: lines.join("\n") }],
+		details: { op: "wait", jobs: [], ...(agents.length ? { agents } : {}) },
+		// Nothing found is noise once consumed — the follow-up call has already
+		// corrected course. Running agents are real state the model may act on,
+		// so keep those results.
+		...(agents.length === 0 ? { useless: true } : {}),
+	};
+}
+
+/** Bare `wait` with no running jobs and nobody who could message: nothing to block on. */
+export function nothingToWaitForResult(session: ToolSession): AgentToolResult<CoordinationDetails> {
+	const agents = runningAgentsOutsideJobs(session);
+	const lines: string[] = ["No running background jobs to wait for."];
+	if (agents.length > 0) {
+		lines.push("", ...describeAgents(agents));
+	}
+	return {
+		content: [{ type: "text", text: lines.join("\n") }],
+		details: { op: "wait", jobs: [], ...(agents.length ? { agents } : {}) },
+		...(agents.length === 0 ? { useless: true } : {}),
+	};
+}
+
+/** `cancel`: kill the named jobs; returns immediately with outcomes + snapshots. */
+export function executeCancel(
+	session: ToolSession,
+	manager: AsyncJobManager,
+	ownerId: string | undefined,
+	ids: string[],
+): AgentToolResult<CoordinationDetails> {
+	const ownerFilter = ownerId ? { ownerId } : undefined;
+	const cancelOutcomes: CancelOutcome[] = [];
+	for (const id of ids) {
+		const existing = manager.getJob(id);
+		if (!existing || (ownerId && existing.ownerId !== ownerId)) {
+			cancelOutcomes.push({ id, status: "not_found", message: `Background job not found: ${id}` });
+			continue;
+		}
+		if (existing.status !== "running") {
+			cancelOutcomes.push({
+				id,
+				status: "already_completed",
+				message: `Background job ${id} is already ${existing.status}.`,
+			});
+			continue;
+		}
+		const cancelled = manager.cancel(id, ownerFilter);
+		cancelOutcomes.push(
+			cancelled
+				? { id, status: "cancelled", message: `Cancelled background job ${id}.` }
+				: { id, status: "already_completed", message: `Background job ${id} is already completed.` },
+		);
+	}
+	return buildJobResult(session, manager, "cancel", visibleJobs(manager, ids, ownerId), cancelOutcomes);
+}
+
+/** `jobs`: read-only snapshot of every job plus the jobless running-agent roster. */
+export function executeJobsSnapshot(
+	session: ToolSession,
+	manager: AsyncJobManager,
+	ownerId: string | undefined,
+): AgentToolResult<CoordinationDetails> {
+	const jobs = manager.getAllJobs(ownerId ? { ownerId } : undefined);
+	return buildJobResult(session, manager, "jobs", jobs, [], runningAgentsOutsideJobs(session));
+}
+
+// =============================================================================
+// TUI Renderer (jobs half)
+// =============================================================================
+
+interface JobRenderArgs {
+	poll?: string[];
+	cancel?: string[];
+	list?: boolean;
+}
+
+/** Hub args → legacy job-renderer arg shape, preserving the exact frame titles. */
+function toJobRenderArgs(args: HubRenderArgs | undefined): JobRenderArgs | undefined {
+	if (!args) return undefined;
+	switch (args.op) {
+		case "wait":
+			return { poll: args.ids };
+		case "cancel":
+			return { cancel: args.ids ?? [] };
+		case "jobs":
+			return { list: true };
+		default:
+			return {};
+	}
+}
+
+const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
+const LABEL_MAX_WIDTH = 60;
+const PREVIEW_LINES_COLLAPSED = 1;
+const PREVIEW_LINES_EXPANDED = 4;
+const LABEL_LINES_COLLAPSED = 1;
+const LABEL_LINES_EXPANDED = 3;
+const PREVIEW_LINE_WIDTH = 80;
+
+function statusToIcon(status: JobSnapshot["status"]): ToolUIStatus {
+	switch (status) {
+		case "completed":
+			return "done";
+		case "failed":
+			return "error";
+		case "cancelled":
+			return "aborted";
+		case "running":
+			return "running";
+	}
+}
+
+function statusToColor(status: JobSnapshot["status"]): ToolUIColor {
+	switch (status) {
+		case "completed":
+			return "success";
+		case "failed":
+			return "error";
+		case "cancelled":
+			return "warning";
+		case "running":
+			return "accent";
+	}
+}
+
+/**
+ * Task job results are delivered in the model-facing `<task-result>` envelope
+ * (prompts/tools/task-summary.md) so the parent agent can parse status and the
+ * `agent://` pointer. The wrapper markup is noise to a human — preview the
+ * inner <output>/<preview> body instead.
+ */
+function stripTaskResultEnvelope(text: string): string {
+	if (!text.startsWith("<task-result")) return text;
+	const body = /<(output|preview)(?:\s[^>]*)?>\n?([\s\S]*?)\n?<\/\1>/.exec(text)?.[2];
+	return body?.trim() || text;
+}
+
+/**
+ * Pretty-printed JSON output wastes the collapsed one-line preview on a lone
+ * "{" — flatten structured-looking bodies onto a single line. Slice first:
+ * downstream truncation keeps at most a few hundred columns, so collapsing
+ * whitespace across a multi-KB body would be pure waste.
+ */
+function flattenStructuredPreview(text: string): string {
+	const first = text[0];
+	if (first !== "{" && first !== "[") return text;
+	return text.slice(0, PREVIEW_LINES_EXPANDED * PREVIEW_LINE_WIDTH * 2).replace(/\s+/g, " ");
+}
+
+function describeTarget(args: JobRenderArgs | undefined): string {
+	if (args?.list) return "background jobs";
+	const poll = args?.poll ?? [];
+	const cancel = args?.cancel ?? [];
+	const parts: string[] = [];
+	if (cancel.length > 0) {
+		parts.push(cancel.length === 1 ? `cancel ${cancel[0]}` : `cancel ${cancel.length} jobs`);
+	}
+	if (poll.length > 0) {
+		parts.push(poll.length === 1 ? `poll ${poll[0]}` : `poll ${poll.length} jobs`);
+	}
+	if (parts.length === 0) return "all running jobs";
+	return parts.join(", ");
+}
+
+/** Pending-call frame for job ops (wait/cancel/jobs). */
+export function jobsRenderCall(args: HubRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
+	const text = renderStatusLine({ icon: "pending", title: describeTarget(toJobRenderArgs(args)) || "Job" }, uiTheme);
+	return new Text(text, 0, 0);
+}
+
+/** Result frame for job snapshots (wait/cancel/jobs and the agents roster). */
+export function jobsRenderResult(
+	result: { content: Array<{ type: string; text?: string }>; details?: CoordinationDetails; isError?: boolean },
+	options: RenderResultOptions,
+	uiTheme: Theme,
+	hubArgs?: HubRenderArgs,
+): Component {
+	const args = toJobRenderArgs(hubArgs);
+	let jobs = result.details?.jobs ?? [];
+	const agents = result.details?.agents ?? [];
+
+	if (jobs.length === 0 && agents.length === 0) {
+		const fallback = result.content?.find(c => c.type === "text")?.text || "No jobs to process";
+		const header = renderStatusLine({ icon: "warning", title: describeTarget(args) || "Job" }, uiTheme);
+		return new Text([header, formatEmptyMessage(fallback, uiTheme)].join("\n"), 0, 0);
+	}
+
+	const isPollCall = args ? !args.list && (!args.cancel || args.cancel.length === 0 || args.poll !== undefined) : true;
+
+	// Agent-carrying results (jobs snapshot / empty-wait roster) are real
+	// snapshots, not displaceable waiting frames — only agentless waits
+	// collapse their still-running rows once sealed.
+	if (!options.isPartial && isPollCall && agents.length === 0) {
+		jobs = jobs.filter(job => job.status !== "running");
+		if (jobs.length === 0) {
+			return new Text("", 0, 0);
+		}
+	}
+
+	const counts = { completed: 0, failed: 0, cancelled: 0, running: 0 };
+	for (const job of jobs) counts[job.status]++;
+
+	// The title already carries the running count, so meta lists only the
+	// settled categories — "waiting on 19 of 19 · 19 running" read awkward.
+	const meta: string[] = [];
+	if (counts.completed > 0) meta.push(uiTheme.fg("success", `${counts.completed} done`));
+	if (counts.failed > 0) meta.push(uiTheme.fg("error", `${counts.failed} failed`));
+	if (counts.cancelled > 0) meta.push(uiTheme.fg("warning", `${counts.cancelled} cancelled`));
+	if (agents.length > 0 && jobs.length > 0) {
+		meta.push(uiTheme.fg("accent", `${agents.length} agent${agents.length === 1 ? "" : "s"}`));
+	}
+
+	const headerIcon: ToolUIStatus =
+		counts.failed > 0 ? "warning" : counts.running > 0 || agents.length > 0 ? "info" : "success";
+	const jobsNoun = jobs.length === 1 ? "job" : "jobs";
+	const description =
+		jobs.length === 0
+			? `${agents.length} running agent${agents.length === 1 ? "" : "s"} — no jobs`
+			: counts.running > 0
+				? counts.running === jobs.length
+					? `waiting on ${jobs.length} ${jobsNoun}`
+					: `waiting on ${counts.running} of ${jobs.length} ${jobsNoun}`
+				: `${jobs.length} ${jobsNoun} settled`;
+
+	const header = renderStatusLine(
+		{
+			icon: headerIcon,
+			spinnerFrame: counts.running > 0 || agents.length > 0 ? options.spinnerFrame : undefined,
+			title: description,
+			meta,
+		},
+		uiTheme,
+	);
+
+	// Sort: running first (so user sees what's still pending), then failed, then completed/cancelled.
+	const statusOrder: Record<JobSnapshot["status"], number> = {
+		running: 0,
+		failed: 1,
+		cancelled: 2,
+		completed: 3,
+	};
+	const sortedJobs = [...jobs].sort((a, b) => {
+		const diff = statusOrder[a.status] - statusOrder[b.status];
+		if (diff !== 0) return diff;
+		return b.durationMs - a.durationMs;
+	});
+
+	let cached: RenderCache | undefined;
+	return {
+		render(width: number): readonly string[] {
+			const expanded = options.expanded;
+			const spinnerFrame = options.spinnerFrame ?? 0;
+			// Running-job labels shimmer while the wait block is live; the band
+			// phase is Date.now()-sampled at render time, so serving cached bytes
+			// would pin it to the ~12.5fps spinner-glyph cadence instead of the
+			// 30fps redraw. Bypass the cache while any row animates, and key on
+			// the animation state so a sealed block never hits stale shimmered
+			// bytes (spinnerFrame falls back to 0 on both sides of the seal).
+			const shimmerActive = counts.running > 0 && options.spinnerFrame !== undefined && shimmerEnabled();
+			const key = new Hasher().bool(expanded).u32(width).u32(spinnerFrame).bool(shimmerActive).digest();
+			if (!shimmerActive && cached?.key === key) return cached.lines;
+
+			const itemLines = renderTreeList<JobSnapshot>(
+				{
+					items: sortedJobs,
+					expanded,
+					maxCollapsed: COLLAPSED_LIST_LIMIT,
+					itemType: "job",
+					renderItem: job => {
+						const lines: string[] = [];
+						const icon = formatStatusIcon(
+							statusToIcon(job.status),
+							uiTheme,
+							job.status === "running" ? options.spinnerFrame : undefined,
+						);
+						const typeBadge = formatBadge(job.type, statusToColor(job.status), uiTheme);
+						// Task jobs label themselves with their agent id, which is also
+						// the job id — drop the id column instead of stuttering it twice.
+						const idPart = job.label.trim() === job.id ? "" : ` ${uiTheme.fg("muted", job.id)}`;
+						const rawLabelLines = (job.label || "(no label)").split(/\r?\n/);
+						const maxLabelLines = expanded ? LABEL_LINES_EXPANDED : LABEL_LINES_COLLAPSED;
+						const visibleLabelLines = rawLabelLines
+							.slice(0, maxLabelLines)
+							.map(l => truncateToWidth(replaceTabs(l), LABEL_MAX_WIDTH, Ellipsis.Unicode));
+						if (rawLabelLines.length > maxLabelLines && visibleLabelLines.length > 0) {
+							const last = visibleLabelLines[visibleLabelLines.length - 1]!;
+							visibleLabelLines[visibleLabelLines.length - 1] = `${last} …`;
+						}
+						const durationText = uiTheme.fg("dim", formatDuration(job.durationMs));
+						// Running rows in a live block shimmer their label; once the block
+						// stops animating (sealed, or a settled snapshot — spinnerFrame
+						// cleared) they render static so scrollback never keeps a mid-sweep
+						// shimmer band.
+						const live = job.status === "running" && options.spinnerFrame !== undefined;
+						const headRaw = visibleLabelLines[0] ?? "";
+						const headLabel = live
+							? shimmerEnabled()
+								? shimmerText(headRaw, uiTheme)
+								: uiTheme.fg("accent", headRaw)
+							: uiTheme.fg("toolOutput", headRaw);
+						lines.push(`${icon}${idPart} ${typeBadge} ${headLabel} ${durationText}`);
+						for (let i = 1; i < visibleLabelLines.length; i++) {
+							lines.push(`  ${uiTheme.fg("toolOutput", visibleLabelLines[i]!)}`);
+						}
+
+						const preview = flattenStructuredPreview(
+							stripTaskResultEnvelope(job.errorText?.trim() || job.resultText?.trim() || ""),
+						);
+						if (preview) {
+							const maxLines = expanded ? PREVIEW_LINES_EXPANDED : PREVIEW_LINES_COLLAPSED;
+							const previewLines = getPreviewLines(preview, maxLines, PREVIEW_LINE_WIDTH, Ellipsis.Unicode);
+							const tone = job.errorText ? "error" : "dim";
+							for (const pl of previewLines) {
+								lines.push(`  ${uiTheme.fg(tone, pl)}`);
+							}
+						}
+						return lines;
+					},
+				},
+				uiTheme,
+			);
+
+			// Agents run outside job control; render them as their own tree so
+			// they never skew the job counts or the "waiting on N jobs" title.
+			const agentLines =
+				agents.length === 0
+					? []
+					: renderTreeList<AgentActivitySnapshot>(
+							{
+								items: agents,
+								expanded,
+								maxCollapsed: COLLAPSED_LIST_LIMIT,
+								itemType: "agent",
+								renderItem: agent => {
+									const icon = formatStatusIcon("running", uiTheme, options.spinnerFrame);
+									const badge = formatBadge("agent", "accent", uiTheme);
+									const gist = agent.activity
+										? ` ${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(agent.activity), LABEL_MAX_WIDTH, Ellipsis.Unicode))}`
+										: "";
+									const parent = agent.parentId ? uiTheme.fg("dim", ` ← ${agent.parentId}`) : "";
+									const age = uiTheme.fg("dim", formatDuration(agent.ageMs));
+									return [`${icon} ${uiTheme.fg("muted", agent.id)} ${badge}${gist} ${age}${parent}`];
+								},
+							},
+							uiTheme,
+						);
+
+			const all = [header, ...itemLines, ...agentLines].map(l => truncateToWidth(l, width, Ellipsis.Unicode));
+			cached = { key, lines: all };
+			return all;
+		},
+		invalidate() {
+			cached = undefined;
+		},
+	};
+}
diff --git a/packages/coding-agent/src/tools/hub/launch.ts b/packages/coding-agent/src/tools/hub/launch.ts
new file mode 100644
index 000000000..e110664ad
--- /dev/null
+++ b/packages/coding-agent/src/tools/hub/launch.ts
@@ -0,0 +1,561 @@
+/**
+ * Hub launch half — supervision of project-scoped long-running processes
+ * (dev servers, watchers, debuggers, REPLs) through the shared daemon broker.
+ * Hub ops map 1:1 onto broker operations; the hub's `ps` op is the broker's
+ * `list`, and `send`/`wait` route here when they carry a process `name`.
+ */
+
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
+import { sanitizeText } from "@oh-my-pi/pi-utils";
+import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
+import { daemonClientForProject } from "../../launch/client";
+import type { DaemonOperation, DaemonRpcResult, DaemonSnapshot, DaemonSpec, DaemonState } from "../../launch/protocol";
+import { renderTerminalOutput } from "../../launch/terminal-output";
+import type { Theme, ThemeColor } from "../../modes/theme/theme";
+import { framedBlock, outputBlockContentWidth, renderStatusLine } from "../../tui";
+import type { ToolSession } from "..";
+import { resolveToCwd } from "../path-utils";
+import {
+	capPreviewLines,
+	createCachedComponent,
+	DEFAULT_TERMINAL_PREVIEW_LINES,
+	formatDuration,
+	formatExpandHint,
+	formatMoreItems,
+	PREVIEW_LIMITS,
+	pluralize,
+	previewLine,
+	replaceTabs,
+	shortenPath,
+	TRUNCATE_LENGTHS,
+	truncateToWidth,
+} from "../render-utils";
+import { styleTerminalRow } from "../terminal-output";
+import { ToolError } from "../tool-errors";
+
+/** Broker-facing launch parameters; the hub adapts its `ps` op to `list` before calling in. */
+export interface LaunchParams {
+	op: "start" | "list" | "logs" | "wait" | "send" | "stop" | "restart" | "describe";
+	name?: string;
+	application?: string;
+	args?: string[];
+	env?: Record<string, string>;
+	cwd?: string;
+	pty?: boolean;
+	ready?: { log?: string; port?: number; host?: string; timeout?: number };
+	restart?: "no" | "on-failure" | "always";
+	persist?: boolean;
+	detached?: boolean;
+	lines?: number;
+	head?: boolean;
+	grep?: string;
+	follow?: boolean;
+	cursor?: number;
+	for?: "ready" | "exit";
+	pattern?: string;
+	text?: string;
+	enter?: boolean;
+	keys?: string[];
+	signal?: "SIGINT" | "SIGTERM" | "SIGHUP" | "SIGQUIT" | "SIGKILL";
+	timeout?: number;
+}
+
+const KEY_INPUT: Record<string, string> = {
+	ENTER: "\r",
+	TAB: "\t",
+	ESCAPE: "\u001b",
+	CTRL_C: "\u0003",
+	CTRL_D: "\u0004",
+	UP: "\u001b[A",
+	DOWN: "\u001b[B",
+	RIGHT: "\u001b[C",
+	LEFT: "\u001b[D",
+};
+
+/** Structured launch state retained for compact TUI rendering. */
+export interface LaunchToolDetails {
+	op: LaunchParams["op"];
+	daemon?: DaemonSnapshot;
+	daemons?: DaemonSnapshot[];
+	cursor?: number;
+	timedOut?: boolean;
+	/** logs: daemon lifecycle state at read time. */
+	state?: DaemonState;
+	/** logs: virtual terminal rows for display; model-facing content remains sanitized text. */
+	terminalRows?: string[];
+	/** wait: output line that satisfied the pattern. */
+	matched?: string;
+	/** describe: immutable launch spec backing the command/cwd detail lines. */
+	spec?: DaemonSpec;
+}
+
+function requiredName(params: LaunchParams): string {
+	if (!params.name) throw new ToolError(`${params.op} requires name`);
+	return params.name;
+}
+
+function timeoutMs(value: number | undefined, fallbackSeconds: number): number {
+	const seconds = Math.max(0.05, Math.min(3_600, value ?? fallbackSeconds));
+	return Math.round(seconds * 1_000);
+}
+
+function commandSpec(params: LaunchParams, session: ToolSession): DaemonSpec {
+	const name = requiredName(params);
+	if (!params.application) throw new ToolError("start requires application");
+	const ready = params.ready;
+	const detached = params.detached ?? false;
+	if (ready?.port !== undefined && (!Number.isInteger(ready.port) || ready.port < 1 || ready.port > 65_535)) {
+		throw new ToolError("ready.port must be an integer from 1 to 65535");
+	}
+	if (ready && !ready.log && ready.port === undefined) throw new ToolError("ready requires log or port");
+	return {
+		name,
+		application: params.application,
+		args: params.args ?? [],
+		env: params.env ?? {},
+		cwd: resolveToCwd(params.cwd ?? session.cwd, session.cwd),
+		pty: detached ? false : (params.pty ?? true),
+		ready: ready
+			? {
+					log: ready.log,
+					port: ready.port,
+					host: ready.host,
+					timeoutMs: timeoutMs(ready.timeout, 30),
+				}
+			: undefined,
+		restart: params.restart ?? "no",
+		persist: (params.persist ?? false) || detached,
+		detached,
+	};
+}
+
+function sendData(params: LaunchParams): string | undefined {
+	let data = params.text ?? "";
+	if (params.text && (params.enter ?? true)) data += KEY_INPUT.ENTER;
+	for (const rawKey of params.keys ?? []) {
+		const key = rawKey.trim().toUpperCase();
+		const input = KEY_INPUT[key];
+		if (input === undefined) throw new ToolError(`Unsupported launch key ${rawKey}`);
+		data += input;
+	}
+	return data || undefined;
+}
+
+function operationFor(params: LaunchParams, session: ToolSession): DaemonOperation {
+	switch (params.op) {
+		case "start":
+			return { op: "start", spec: commandSpec(params, session), owner: session.getSessionId?.() ?? undefined };
+		case "list":
+			return { op: "list" };
+		case "logs":
+			return {
+				op: "logs",
+				name: requiredName(params),
+				lines: Math.min(1_000, Math.floor(params.lines ?? 100)),
+				head: params.head ?? false,
+				grep: params.grep,
+				follow: params.follow ?? false,
+				cursor: params.cursor,
+				timeoutMs: timeoutMs(params.timeout, 30),
+			};
+		case "wait":
+			return {
+				op: "wait",
+				name: requiredName(params),
+				for: params.for ?? "exit",
+				pattern: params.pattern,
+				timeoutMs: timeoutMs(params.timeout, 30),
+			};
+		case "send":
+			return {
+				op: "send",
+				name: requiredName(params),
+				data: sendData(params),
+				signal: params.signal,
+			};
+		case "stop":
+			return { op: "stop", name: requiredName(params), timeoutMs: timeoutMs(params.timeout, 5) };
+		case "restart":
+			return { op: "restart", name: requiredName(params) };
+		case "describe":
+			return { op: "describe", name: requiredName(params) };
+	}
+}
+
+function daemonLabel(daemon: DaemonSnapshot): string {
+	const pid = daemon.pid === undefined ? "" : ` pid=${daemon.pid}`;
+	const exit = daemon.exitCode === undefined ? "" : ` exit=${daemon.exitCode}`;
+	return `${daemon.name}: ${daemon.state}${pid}${exit} uptime=${formatDuration(
+		(daemon.exitedAt ?? Date.now()) - daemon.startedAt,
+	)} restarts=${daemon.restartCount}${daemon.detached ? " detached" : daemon.persist ? " persistent" : ""}`;
+}
+
+/**
+ * Human sentences for the readiness conditions still unmet, e.g.
+ * `port 5173 on 127.0.0.1 never accepted connections`. `ready` (from the start
+ * params) adds the concrete pattern/port; absent it falls back to generic labels.
+ */
+function readyPendingSummary(daemon: DaemonSnapshot, ready?: LaunchParams["ready"]): string[] {
+	const parts: string[] = [];
+	for (const condition of daemon.readyPending ?? []) {
+		if (condition === "log") {
+			parts.push(ready?.log ? `log pattern /${ready.log}/ never matched` : "the log pattern never matched");
+		} else {
+			parts.push(
+				ready?.port !== undefined
+					? `port ${ready.port} on ${ready.host ?? "127.0.0.1"} never accepted connections`
+					: "the port never accepted connections",
+			);
+		}
+	}
+	return parts;
+}
+
+function toolContent(result: DaemonRpcResult, params: LaunchParams): string {
+	switch (result.op) {
+		case "ping":
+		case "shutdown":
+			throw new ToolError(`Internal daemon result ${result.op} is not tool-visible`);
+		case "start": {
+			const daemon = result.daemon;
+			const lines = [`${daemon.state === "failed" ? "Failed to launch" : "Started"} ${daemonLabel(daemon)}`];
+			if (daemon.state === "failed" && daemon.exitReason) lines.push(`Reason: ${daemon.exitReason}`);
+			if (daemon.readyMatch) lines.push(`Ready log matched: ${daemon.readyMatch}`);
+			if (result.readyTimedOut) {
+				const pending = readyPendingSummary(daemon, params.ready);
+				const cause = pending.length > 0 ? `: ${pending.join("; ")}` : "";
+				lines.push(
+					`NOT ready — readiness timed out after ${params.ready?.timeout ?? 30}s${cause}. The process is still running (state: ${daemon.state}); follow its logs or stop it.`,
+				);
+			}
+			return lines.join("\n");
+		}
+		case "list":
+			return result.daemons.length
+				? result.daemons.map(daemon => `- ${daemonLabel(daemon)}`).join("\n")
+				: "No daemons.";
+		case "logs": {
+			const text = sanitizeText(result.text);
+			return `${text}${text && !text.endsWith("\n") ? "\n" : ""}[${result.name}: ${result.state}; cursor=${result.cursor}${result.timedOut ? "; follow timed out" : ""}]`;
+		}
+		case "wait": {
+			const lines = [daemonLabel(result.daemon)];
+			if (result.matched) lines.push(`Matched: ${result.matched}`);
+			if (result.timedOut) {
+				const pending = readyPendingSummary(result.daemon);
+				lines.push(`Wait timed out${pending.length > 0 ? ` (still waiting on: ${pending.join("; ")})` : ""}.`);
+			}
+			return lines.join("\n");
+		}
+		case "send":
+			return `Sent input to ${daemonLabel(result.daemon)}`;
+		case "stop":
+			return `Stopped ${daemonLabel(result.daemon)}`;
+		case "restart":
+			return `Restarted ${daemonLabel(result.daemon)}`;
+		case "describe":
+			return [
+				daemonLabel(result.daemon),
+				`Command: ${[result.spec.application, ...result.spec.args].join(" ")}`,
+				`Cwd: ${shortenPath(result.spec.cwd)}`,
+				`PTY: ${result.spec.pty}; restart=${result.spec.restart}; persist=${result.spec.persist}; detached=${result.spec.detached}`,
+			].join("\n");
+	}
+}
+
+async function toolDetails(result: DaemonRpcResult, params: LaunchParams): Promise<LaunchToolDetails> {
+	switch (result.op) {
+		case "start":
+			return { op: "start", daemon: result.daemon, timedOut: result.readyTimedOut };
+		case "list":
+			return { op: "list", daemons: result.daemons };
+		case "logs": {
+			const terminalRows =
+				result.terminalText === undefined
+					? undefined
+					: await renderTerminalOutput(result.terminalText, {
+							head: params.head ?? false,
+							maxRows: Math.min(1_000, Math.floor(params.lines ?? 100)),
+						});
+			return {
+				op: "logs",
+				cursor: result.cursor,
+				timedOut: result.timedOut,
+				state: result.state,
+				terminalRows,
+			};
+		}
+		case "wait":
+			return { op: "wait", daemon: result.daemon, timedOut: result.timedOut, matched: result.matched };
+		case "send":
+			return { op: "send", daemon: result.daemon };
+		case "stop":
+			return { op: "stop", daemon: result.daemon };
+		case "restart":
+			return { op: "restart", daemon: result.daemon };
+		case "describe":
+			return { op: "describe", daemon: result.daemon, spec: result.spec };
+		case "ping":
+		case "shutdown":
+			throw new ToolError(`Internal daemon result ${result.op} is not tool-visible`);
+	}
+}
+
+/** Run one broker operation for the calling session's project. */
+export async function executeLaunch(
+	session: ToolSession,
+	params: LaunchParams,
+	signal?: AbortSignal,
+): Promise<AgentToolResult<LaunchToolDetails>> {
+	const client = await daemonClientForProject(session.cwd);
+	const result = await client.request(operationFor(params, session), signal);
+	return {
+		content: [{ type: "text", text: replaceTabs(toolContent(result, params)) }],
+		details: await toolDetails(result, params),
+	};
+}
+
+// =============================================================================
+// TUI Renderer (launch half)
+// =============================================================================
+
+/** Args shape visible to the renderer, possibly mid-stream (every field optional). */
+export type LaunchRenderArgs = Partial<Omit<LaunchParams, "op">> & { op?: string };
+
+function stateColor(state: DaemonState): ThemeColor {
+	switch (state) {
+		case "running":
+		case "ready":
+			return "success";
+		case "failed":
+			return "error";
+		case "exited":
+			return "muted";
+		default:
+			return "warning";
+	}
+}
+
+/** Compact `state · pid · uptime` fragments for the status-line meta slot. */
+function daemonMeta(daemon: DaemonSnapshot, theme: Theme): string[] {
+	const meta = [theme.fg(stateColor(daemon.state), daemon.state)];
+	if (daemon.readyPending?.length) meta.push(theme.fg("warning", `waiting on ${daemon.readyPending.join("+")}`));
+	if (daemon.exitCode !== undefined) {
+		meta.push(theme.fg(daemon.exitCode === 0 ? "muted" : "error", `exit ${daemon.exitCode}`));
+	} else if (daemon.pid !== undefined) {
+		meta.push(`pid ${daemon.pid}`);
+	}
+	const lifespan = formatDuration((daemon.exitedAt ?? Date.now()) - daemon.startedAt);
+	meta.push(daemon.exitedAt === undefined ? `up ${lifespan}` : `ran ${lifespan}`);
+	if (daemon.restartCount > 0) meta.push(`restarts ${daemon.restartCount}`);
+	if (daemon.detached) meta.push("detached");
+	else if (daemon.persist) meta.push("persistent");
+	return meta;
+}
+
+/** Op-specific call context (command line, log filters, wait condition, send payload). */
+function callMeta(args: LaunchRenderArgs): string[] {
+	const meta: string[] = [];
+	switch (args.op) {
+		case "start":
+			if (args.application) meta.push([args.application, ...(args.args ?? [])].join(" "));
+			break;
+		case "logs":
+			if (args.follow) meta.push("follow");
+			if (args.grep) meta.push(`grep /${args.grep}/`);
+			break;
+		case "wait":
+			meta.push(args.pattern ? `for /${args.pattern}/` : `for ${args.for ?? "exit"}`);
+			break;
+		case "send":
+			if (args.signal) meta.push(args.signal);
+			else if (args.text) meta.push(args.text);
+			if (args.keys?.length) meta.push(args.keys.join(" "));
+			break;
+	}
+	return meta.map(entry => previewLine(replaceTabs(entry), TRUNCATE_LENGTHS.SHORT));
+}
+
+/** Pending-call frame for launch ops; consumes the spinner while the broker call is live. */
+export function launchRenderCall(args: LaunchRenderArgs, options: RenderResultOptions, theme: Theme): Component {
+	const target = args.name ?? args.application;
+	const header = renderStatusLine(
+		{
+			icon: options.spinnerFrame !== undefined ? "running" : "pending",
+			spinnerFrame: options.spinnerFrame,
+			title: `Launch ${args.op ?? "…"}`,
+			description: target ? replaceTabs(target) : undefined,
+			meta: callMeta(args),
+		},
+		theme,
+	);
+	return new Text(header, 0, 0);
+}
+
+/** Result frame: one status header per op, meta from structured details, capped body lines. */
+export function launchRenderResult(
+	result: { content: Array<{ type: string; text?: string }>; details?: LaunchToolDetails; isError?: boolean },
+	options: RenderResultOptions,
+	theme: Theme,
+	args?: LaunchRenderArgs,
+): Component {
+	const details = result.details;
+	const params = args ?? {};
+	const op = details?.op ?? params.op;
+	const isError = result.isError === true;
+	const daemon = details?.daemon;
+	const failed = isError || daemon?.state === "failed";
+	const text =
+		result.content
+			?.filter(item => item.type === "text")
+			.map(item => item.text ?? "")
+			.join("\n") ?? "";
+
+	const meta: string[] = [];
+	const body: string[] = [];
+	let description = params.name ?? daemon?.name;
+
+	if (isError) {
+		for (const line of replaceTabs(text.trimEnd()).split("\n")) body.push(theme.fg("error", line));
+	} else {
+		switch (op) {
+			case "start": {
+				meta.push(...callMeta(params));
+				if (daemon) meta.push(...daemonMeta(daemon, theme));
+				if (daemon?.readyMatch) body.push(theme.fg("dim", `log matched: ${replaceTabs(daemon.readyMatch)}`));
+				if (daemon?.state === "failed" && daemon.exitReason)
+					body.push(theme.fg("error", replaceTabs(daemon.exitReason)));
+				if (details?.timedOut) {
+					const pending = daemon ? readyPendingSummary(daemon, params.ready) : [];
+					body.push(
+						theme.fg(
+							"warning",
+							pending.length > 0
+								? `Not ready — ${pending.join("; ")}. Still running.`
+								: "Readiness timed out; the process is still running.",
+						),
+					);
+				}
+				break;
+			}
+			case "send":
+				meta.push(...callMeta(params));
+				if (daemon) meta.push(...daemonMeta(daemon, theme));
+				break;
+			case "stop":
+			case "restart":
+				if (daemon) meta.push(...daemonMeta(daemon, theme));
+				break;
+			case "wait": {
+				meta.push(...callMeta(params));
+				if (daemon) meta.push(...daemonMeta(daemon, theme));
+				if (details?.matched) body.push(theme.fg("dim", `matched: ${replaceTabs(details.matched)}`));
+				if (details?.timedOut) {
+					const pending = daemon ? readyPendingSummary(daemon) : [];
+					body.push(
+						theme.fg(
+							"warning",
+							pending.length > 0
+								? `Wait timed out — still waiting on ${pending.join("; ")}.`
+								: "Wait timed out.",
+						),
+					);
+				}
+				break;
+			}
+			case "list": {
+				const daemons = details?.daemons ?? [];
+				description = `${daemons.length || "no"} ${pluralize("process", daemons.length)}`;
+				for (const item of daemons) {
+					body.push(
+						`${theme.fg("accent", replaceTabs(item.name))} ${theme.fg("dim", daemonMeta(item, theme).join(theme.sep.dot))}`,
+					);
+				}
+				break;
+			}
+			case "logs": {
+				if (details?.state) meta.push(theme.fg(stateColor(details.state), details.state));
+				if (details?.cursor !== undefined) meta.push(`cursor ${details.cursor}`);
+				if (details?.timedOut) meta.push(theme.fg("warning", "follow timed out"));
+				// Strip the trailing `[name: state; cursor=N]` status suffix `toolContent` appends.
+				const logText = text.replace(/\n?\[[^\n]*\]$/, "").trimEnd();
+				const terminalRows = details?.terminalRows;
+				if (terminalRows) {
+					for (const row of terminalRows) body.push(styleTerminalRow(row, theme.getFgAnsi("toolOutput")));
+				} else if (logText) {
+					for (const line of logText.split("\n")) body.push(theme.fg("toolOutput", replaceTabs(line)));
+				}
+				break;
+			}
+			case "describe": {
+				if (daemon) meta.push(...daemonMeta(daemon, theme));
+				const spec = details?.spec;
+				if (spec) {
+					body.push(theme.fg("toolOutput", replaceTabs([spec.application, ...spec.args].join(" "))));
+					body.push(theme.fg("dim", `cwd ${shortenPath(spec.cwd)}`));
+					const flags = [`pty ${spec.pty}`, `restart ${spec.restart}`];
+					if (spec.detached) flags.push("detached");
+					else if (spec.persist) flags.push("persistent");
+					body.push(theme.fg("dim", flags.join(theme.sep.dot)));
+				}
+				break;
+			}
+			default:
+				if (text.trim()) {
+					for (const line of replaceTabs(text.trimEnd()).split("\n")) body.push(theme.fg("toolOutput", line));
+				}
+		}
+	}
+
+	const header = renderStatusLine(
+		{
+			...(failed
+				? { icon: "error" as const }
+				: options.isPartial
+					? { icon: "pending" as const }
+					: { iconOverride: theme.styledSymbol("tool.launch", "accent") }),
+			title: `Launch ${op ?? ""}`.trimEnd(),
+			description: description ? replaceTabs(description) : undefined,
+			meta,
+		},
+		theme,
+	);
+
+	if (op === "logs") {
+		return framedBlock(theme, width => {
+			const innerWidth = outputBlockContentWidth(width);
+			const rows = body.map(line => truncateToWidth(line, innerWidth));
+			return {
+				header,
+				state: options.isPartial ? "pending" : failed ? "error" : "success",
+				sections: [
+					{
+						label: theme.fg("toolTitle", "Output"),
+						lines: capPreviewLines(rows, theme, {
+							expanded: options.expanded,
+							max: DEFAULT_TERMINAL_PREVIEW_LINES,
+						}),
+					},
+				],
+				width,
+			};
+		});
+	}
+
+	return createCachedComponent(
+		() => options.expanded,
+		(width, expanded) => {
+			let visible = body;
+			if (!expanded && op === "list" && body.length > PREVIEW_LIMITS.COLLAPSED_ITEMS) {
+				const remaining = body.length - PREVIEW_LIMITS.COLLAPSED_ITEMS;
+				visible = [
+					...body.slice(0, PREVIEW_LIMITS.COLLAPSED_ITEMS),
+					theme.fg("dim", `${formatMoreItems(remaining, "process")} ${formatExpandHint(theme, false, true)}`),
+				];
+			}
+			return [header, ...visible].map(line => truncateToWidth(line, width));
+		},
+	);
+}
diff --git a/packages/coding-agent/src/tools/hub/messaging.ts b/packages/coding-agent/src/tools/hub/messaging.ts
new file mode 100644
index 000000000..a533cadfd
--- /dev/null
+++ b/packages/coding-agent/src/tools/hub/messaging.ts
@@ -0,0 +1,722 @@
+/**
+ * Hub messaging half — agent-to-agent messaging over the process-global IrcBus.
+ *
+ * `send` is fire-and-forget: the bus routes the message to the recipient
+ * (waking idle agents with a real turn, reviving parked ones via the
+ * lifecycle manager, injecting a non-interrupting aside into busy ones) and
+ * returns delivery receipts immediately. Replies are real turns by the
+ * recipient, observed with `wait` (or the `await: true` send sugar). `inbox`
+ * drains pending messages; `list` shows every addressable peer.
+ */
+
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import { type Component, Text } from "@oh-my-pi/pi-tui";
+import { formatAge, formatDuration } from "@oh-my-pi/pi-utils";
+import type { Settings } from "../../config/settings";
+import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
+import { IrcBus, type IrcDeliveryReceipt, type IrcMessage } from "../../irc/bus";
+import type { Theme } from "../../modes/theme/theme";
+import { type AgentRegistry, MAIN_AGENT_ID } from "../../registry/agent-registry";
+import { canSpawnAtDepth } from "../../task/types";
+import { Ellipsis, renderStatusLine, renderTreeList, truncateToWidth } from "../../tui";
+import {
+	createCachedComponent,
+	formatBadge,
+	formatErrorDetail,
+	getPreviewLines,
+	PREVIEW_LIMITS,
+	replaceTabs,
+	type ToolUIColor,
+} from "../render-utils";
+import { type CoordinationDetails, type HubRenderArgs, hubErrorResult } from "./types";
+
+export const DEFAULT_IRC_TIMEOUT_MS = 120_000;
+
+/**
+ * Messaging availability: there must be someone to chat with. True for every
+ * subagent (it always has a parent, and possibly siblings) and for any
+ * session that can still spawn subagents through the task tool. Only a
+ * top-level session with task spawning unavailable has no peers.
+ */
+export function isIrcEnabled(settings: Settings, taskDepth: number): boolean {
+	if (taskDepth > 0) return true;
+	// Top-level session: peers exist only if it can still spawn subagents — the
+	// same capacity gate the task tool uses, reused here to avoid drift.
+	const maxDepth = settings.get("task.maxRecursionDepth") ?? 2;
+	return canSpawnAtDepth(maxDepth, taskDepth);
+}
+
+export function formatIncoming(msg: IrcMessage): string {
+	const replyTag = msg.replyTo ? ` (reply to ${msg.replyTo})` : "";
+	return `[${msg.id}] ${msg.from}${replyTag}: ${msg.body}`;
+}
+
+export function normalizeIrcTimeoutMs(value: number): number {
+	if (value === 0) return 0; // 0 = timeout disabled
+	// Negative or non-finite settings are misconfigurations — fall back to the
+	// default instead of producing an instant 1 ms timeout.
+	if (!Number.isFinite(value) || value < 0) return DEFAULT_IRC_TIMEOUT_MS;
+	return Math.max(1, Math.trunc(value));
+}
+
+/** Effective message-wait timeout: explicit param wins, then `irc.timeoutMs`. */
+export function resolveMessageTimeoutMs(settings: Settings, explicit?: number): number {
+	if (explicit !== undefined) return normalizeIrcTimeoutMs(explicit);
+	return normalizeIrcTimeoutMs(settings.get("irc.timeoutMs"));
+}
+
+/** Session-buffered inbox drain used before parking a bus waiter. */
+export function drainPendingInbox(registry: AgentRegistry, senderId: string, from?: string): IrcMessage | undefined {
+	const session = registry.get(senderId)?.session;
+	return typeof session?.drainPendingIrcInboxMessages === "function"
+		? session.drainPendingIrcInboxMessages(senderId, { from, limit: 1 })[0]
+		: undefined;
+}
+
+/** `wait` result carrying a consumed message. */
+export function messageResult(senderId: string, waited: IrcMessage): AgentToolResult<CoordinationDetails> {
+	return {
+		content: [{ type: "text", text: formatIncoming(waited) }],
+		details: { op: "wait", from: senderId, waited },
+	};
+}
+
+export function executeList(registry: AgentRegistry, senderId: string): AgentToolResult<CoordinationDetails> {
+	const bus = IrcBus.global();
+	const peers = registry
+		.list()
+		.filter(ref => ref.id !== senderId && ref.status !== "aborted" && ref.kind !== "advisor")
+		.map(ref => ({
+			id: ref.id,
+			displayName: ref.displayName,
+			kind: ref.kind,
+			status: ref.status,
+			parentId: ref.parentId,
+			unread: bus.unreadCount(ref.id),
+			lastActivity: ref.lastActivity,
+			activity: ref.activity,
+		}));
+	const lines: string[] = [];
+	if (peers.length === 0) {
+		lines.push("No other agents.");
+	} else {
+		lines.push(`${peers.length} peer(s):`);
+		for (const peer of peers) {
+			const extras = [
+				peer.activity || undefined,
+				peer.unread > 0 ? `unread ${peer.unread}` : undefined,
+				peer.parentId ? `parent ${peer.parentId}` : undefined,
+				`active ${formatDuration(Date.now() - peer.lastActivity)} ago`,
+			].filter(Boolean);
+			lines.push(`- ${peer.id} [${peer.displayName} · ${peer.kind} · ${peer.status}] — ${extras.join(", ")}`);
+		}
+		if (peers.some(peer => peer.status === "parked")) {
+			lines.push("");
+			lines.push("Parked agents are revived automatically when you message them.");
+		}
+	}
+	return {
+		content: [{ type: "text", text: lines.join("\n") }],
+		details: { op: "list", from: senderId, peers },
+	};
+}
+
+export interface HubSendParams {
+	to?: string;
+	message?: string;
+	replyTo?: string;
+	await?: boolean;
+	timeoutMs?: number;
+}
+
+export async function executeSend(
+	deps: { registry: AgentRegistry; senderId: string; settings: Settings },
+	params: HubSendParams,
+	signal?: AbortSignal,
+): Promise<AgentToolResult<CoordinationDetails>> {
+	const { registry, senderId, settings } = deps;
+	const to = params.to?.trim();
+	const message = params.message?.trim();
+	if (!to) {
+		return hubErrorResult('`to` is required for op="send".', { op: "send", from: senderId });
+	}
+	if (!message) {
+		return hubErrorResult('`message` is required for op="send".', { op: "send", from: senderId });
+	}
+	if (to === senderId) {
+		return hubErrorResult("Cannot send a message to yourself.", { op: "send", from: senderId, to });
+	}
+	const isBroadcast = to === "all";
+	if (isBroadcast && params.await) {
+		return hubErrorResult('`await` is invalid with to:"all" — broadcasts have no single replier.', {
+			op: "send",
+			from: senderId,
+			to,
+		});
+	}
+
+	const bus = IrcBus.global();
+	let waited: IrcMessage | null | undefined;
+	const timeoutMs = params.await ? resolveMessageTimeoutMs(settings, params.timeoutMs) : undefined;
+	const awaitAbort = params.await ? new AbortController() : undefined;
+	const awaitCancelled = new Error("IRC await cancelled");
+	let removeAwaitAbortListener: (() => void) | undefined;
+	const waiting = params.await
+		? bus
+				.wait(senderId, { from: to }, timeoutMs ?? DEFAULT_IRC_TIMEOUT_MS, awaitAbort?.signal, {
+					drainPending: false,
+				})
+				.then(
+					message => ({ message, error: null as Error | null }),
+					error => ({
+						message: null,
+						error: error === awaitCancelled ? null : error instanceof Error ? error : new Error(String(error)),
+					}),
+				)
+		: undefined;
+	if (params.await && signal && awaitAbort) {
+		if (signal.aborted) {
+			awaitAbort.abort(signal.reason instanceof Error ? signal.reason : new Error("IRC wait aborted"));
+		} else {
+			const onAbort = (): void => {
+				awaitAbort.abort(signal.reason instanceof Error ? signal.reason : new Error("IRC wait aborted"));
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+			removeAwaitAbortListener = () => signal.removeEventListener("abort", onAbort);
+		}
+	}
+
+	try {
+		// Broadcasts fan out to live peers only (running | idle); reviving every
+		// parked agent on a broadcast would be a stampede. Direct sends go
+		// through the bus unfiltered so parked recipients are revived.
+		const targets = isBroadcast ? registry.listVisibleTo(senderId).map(ref => ref.id) : [to];
+		// A broadcast that also reaches the main agent delivers the body to it
+		// directly (its own incoming card); relaying the sibling legs to the
+		// main UI would then show the same body once per other recipient.
+		const suppressRelay = isBroadcast && targets.includes(MAIN_AGENT_ID);
+		const receipts = await Promise.all(
+			targets.map(target =>
+				bus.send(
+					{ from: senderId, to: target, body: message, replyTo: params.replyTo },
+					// Awaited sends mark the sender as blocked on an answer so a
+					// busy recipient that cannot reach a step boundary (async
+					// disabled) auto-replies instead of stranding the sender.
+					{ expectsReply: params.await || undefined, suppressRelay: suppressRelay || undefined },
+				),
+			),
+		);
+
+		const lines: string[] = [];
+		const delivered = receipts.filter(receipt => receipt.outcome !== "failed");
+		if (targets.length === 0) {
+			lines.push("No live peers to broadcast to.");
+		} else if (delivered.length === 0) {
+			lines.push("No recipients received the message.");
+		} else {
+			lines.push(`Delivered to ${delivered.length} peer(s):`);
+		}
+		for (const receipt of receipts) {
+			lines.push(
+				receipt.outcome === "failed"
+					? `- ${receipt.to}: failed — ${receipt.error ?? "unknown error"}`
+					: `- ${receipt.to}: ${receipt.outcome}`,
+			);
+		}
+
+		if (params.await && waiting && timeoutMs !== undefined) {
+			lines.push("");
+			if (delivered.length > 0) {
+				const reply = await waiting;
+				if (reply.error) {
+					// The send already succeeded; if the wait was interrupted by our
+					// caller signal (steering / messaging), preserve the delivery receipt
+					// so the agent loop keeps this tool as "sent" instead of marking it
+					// skipped, which would prompt a duplicate resend on the next turn.
+					if (signal?.aborted) {
+						lines.push(
+							`Send delivered but the reply wait was interrupted before ${to} answered. ` +
+								"Check `inbox` or `wait` again after handling the interrupt.",
+						);
+					} else {
+						throw reply.error;
+					}
+				} else {
+					waited = reply.message;
+					if (waited) {
+						lines.push(`Reply from ${waited.from}:`);
+						lines.push(waited.body);
+					} else {
+						lines.push(
+							`No reply from ${to} within ${formatDuration(timeoutMs)}. ` +
+								"They may answer later — check `inbox` or `wait` again.",
+						);
+					}
+				}
+			} else {
+				awaitAbort?.abort(awaitCancelled);
+				const reply = await waiting;
+				if (reply.error) throw reply.error;
+			}
+		}
+
+		return {
+			content: [{ type: "text", text: lines.join("\n") }],
+			details: {
+				op: "send",
+				from: senderId,
+				to,
+				receipts,
+				...(waited !== undefined ? { waited } : {}),
+			},
+			isError: delivered.length === 0 && targets.length > 0,
+		};
+	} finally {
+		awaitAbort?.abort(awaitCancelled);
+		removeAwaitAbortListener?.();
+	}
+}
+
+/** Pure message wait: no jobs in play, block on the bus with peer liveness. */
+export async function executeMessageWait(
+	deps: { registry: AgentRegistry; senderId: string; settings: Settings },
+	params: { from?: string; timeoutMs?: number },
+	signal?: AbortSignal,
+): Promise<AgentToolResult<CoordinationDetails>> {
+	const { registry, senderId, settings } = deps;
+	const from = params.from?.trim() || undefined;
+	const timeoutMs = resolveMessageTimeoutMs(settings, params.timeoutMs);
+	try {
+		const waited = await IrcBus.global().wait(senderId, { from }, timeoutMs, signal, {
+			liveness: { registry, senderId },
+		});
+		if (!waited) {
+			const filterNote = from ? ` from ${from}` : "";
+			return {
+				content: [{ type: "text", text: `No message${filterNote} within ${formatDuration(timeoutMs)}.` }],
+				details: { op: "wait", from: senderId, waited: null },
+				// A clean wait timeout carries no information once consumed.
+				useless: true,
+			};
+		}
+		return messageResult(senderId, waited);
+	} catch (error) {
+		if (signal?.aborted) {
+			throw error;
+		}
+		return hubErrorResult(error instanceof Error ? error.message : String(error), { op: "wait", from: senderId });
+	}
+}
+
+export function executeInbox(
+	registry: AgentRegistry,
+	senderId: string,
+	peek?: boolean,
+): AgentToolResult<CoordinationDetails> {
+	const busMessages = IrcBus.global().inbox(senderId, { peek });
+	const session = registry.get(senderId)?.session;
+	const pendingMessages =
+		typeof session?.drainPendingIrcInboxMessages === "function" ? session.drainPendingIrcInboxMessages(senderId) : [];
+	const messages = [...busMessages, ...pendingMessages].sort((a, b) => a.ts - b.ts);
+	if (messages.length === 0) {
+		return {
+			content: [{ type: "text", text: "Inbox empty." }],
+			details: { op: "inbox", from: senderId, inbox: [] },
+			// An empty inbox drain carries no information once consumed.
+			useless: true,
+		};
+	}
+	const header = peek ? `${messages.length} unread message(s):` : `${messages.length} message(s):`;
+	const lines = [header, ...messages.map(msg => `- ${formatIncoming(msg)}`)];
+	return {
+		content: [{ type: "text", text: lines.join("\n") }],
+		details: { op: "inbox", from: senderId, inbox: messages },
+	};
+}
+
+// =============================================================================
+// TUI Renderer (messaging half)
+// =============================================================================
+
+const BODY_LINES_COLLAPSED = 2;
+const BODY_LINES_EXPANDED = 12;
+const BODY_LINE_WIDTH = 100;
+
+const PEER_STATUS_ORDER: Record<string, number> = { running: 0, idle: 1, parked: 2 };
+
+function ircGlyph(theme: Theme): string {
+	return theme.styledSymbol("tool.irc", "accent");
+}
+
+function outcomeColor(outcome: IrcDeliveryReceipt["outcome"]): ToolUIColor {
+	switch (outcome) {
+		case "woken":
+			return "success";
+		case "revived":
+			return "warning";
+		case "injected":
+			return "accent";
+		case "failed":
+			return "error";
+	}
+}
+
+/** Glyph + status word, matching the agent-hub status conventions. */
+function peerStatusBadge(status: string, theme: Theme): string {
+	switch (status) {
+		case "running":
+			return theme.fg("accent", `${theme.status.running} running`);
+		case "idle":
+			return theme.fg("success", `${theme.status.enabled} idle`);
+		case "parked":
+			return theme.fg("muted", `${theme.status.shadowed} parked`);
+		default:
+			return theme.fg("error", `${theme.status.aborted} ${status}`);
+	}
+}
+
+function messageAge(ts: number | undefined): string {
+	if (!ts) return "";
+	return formatAge(Math.max(1, Math.round((Date.now() - ts) / 1000)));
+}
+
+function textContent(result: { content: Array<{ type: string; text?: string }> }): string {
+	return result.content.find(part => part.type === "text")?.text?.trim() ?? "";
+}
+
+/**
+ * Quote-bordered message body preview. `tone` separates outbound text (dim)
+ * from received text (toolOutput); a trailing dim counter marks elided lines.
+ */
+function bodyLines(
+	body: string,
+	expanded: boolean,
+	theme: Theme,
+	options: { indent?: string; tone?: "dim" | "toolOutput"; collapsedLines?: number } = {},
+): string[] {
+	const indent = options.indent ?? "";
+	const tone = options.tone ?? "toolOutput";
+	const max = expanded ? BODY_LINES_EXPANDED : (options.collapsedLines ?? BODY_LINES_COLLAPSED);
+	const total = body.split("\n").filter(line => line.trim()).length;
+	const quote = theme.fg("dim", theme.md.quoteBorder);
+	const lines = getPreviewLines(body, max, BODY_LINE_WIDTH, Ellipsis.Unicode).map(
+		line => `${indent}${quote} ${theme.fg(tone, replaceTabs(line))}`,
+	);
+	const hidden = total - Math.min(total, max);
+	if (hidden > 0) {
+		lines.push(`${indent}${quote} ${theme.fg("dim", `… +${hidden} more ${hidden === 1 ? "line" : "lines"}`)}`);
+	}
+	return lines;
+}
+
+/** Header title carrying the op direction: `IRC ➤ peer` out, `IRC ⟵ peer` in. */
+function callTitle(args: HubRenderArgs | undefined, theme: Theme): string {
+	switch (args?.op) {
+		case "send":
+			return `IRC ${theme.nav.selected} ${args.to?.trim() || "…"}`;
+		case "wait":
+			return `IRC ${theme.nav.back} ${args.from?.trim() || "anyone"}`;
+		case "inbox":
+			return "IRC inbox";
+		case "list":
+			return "IRC peers";
+		default:
+			return "Hub";
+	}
+}
+
+function callMeta(args: HubRenderArgs | undefined): string[] {
+	const meta: string[] = [];
+	if (args?.op === "send") {
+		if (args.to === "all") meta.push("broadcast");
+		if (args.await) meta.push("await reply");
+		if (args.replyTo) meta.push("reply");
+	}
+	if (args?.op === "wait" && args.timeoutMs) meta.push(`timeout ${formatDuration(args.timeoutMs)}`);
+	if (args?.op === "inbox" && args.peek) meta.push("peek");
+	return meta;
+}
+
+function renderErrorResult(
+	result: { content: Array<{ type: string; text?: string }> },
+	args: HubRenderArgs | undefined,
+	theme: Theme,
+): string[] {
+	const text = textContent(result) || "IRC call failed.";
+	return [
+		renderStatusLine({ icon: "error", title: callTitle(args, theme), meta: callMeta(args) }, theme),
+		formatErrorDetail(text, theme),
+	];
+}
+
+/**
+ * Display-only transcript card for live IRC traffic: `irc:incoming` DMs
+ * delivered to this session, `irc:autoreply` side-channel replies sent on
+ * this session's behalf, and `irc:relay` observations of agent↔agent
+ * traffic. Shares the tool renderer's glyph + quote-border conventions so
+ * cards and hub messaging output look identical in the transcript.
+ */
+export function createIrcMessageCard(
+	card: {
+		kind: "incoming" | "autoreply" | "relay";
+		from?: string;
+		to?: string;
+		body?: string;
+		replyTo?: string;
+		timestamp?: number;
+	},
+	getExpanded: () => boolean,
+	uiTheme: Theme,
+): Component {
+	const from = card.from?.trim() || "?";
+	const title =
+		card.kind === "incoming"
+			? `IRC ${uiTheme.nav.back} ${from}`
+			: card.kind === "autoreply"
+				? `IRC ${uiTheme.nav.selected} ${card.to?.trim() || "?"}`
+				: `IRC ${from} ${uiTheme.nav.selected} ${card.to?.trim() || "?"}`;
+	const body = card.body ?? "";
+	const meta: string[] = [];
+	if (card.kind === "autoreply") meta.push("auto");
+	if (card.replyTo) meta.push("reply");
+	const age = messageAge(card.timestamp);
+	if (age) meta.push(age);
+	return createCachedComponent(
+		getExpanded,
+		(width, expanded) => {
+			const lines = [renderStatusLine({ iconOverride: ircGlyph(uiTheme), title, meta }, uiTheme)];
+			if (body.trim()) {
+				lines.push(...bodyLines(body, expanded, uiTheme, { indent: "  ", collapsedLines: 3 }));
+			}
+			return lines.map(line => truncateToWidth(line, width, Ellipsis.Unicode));
+		},
+		{ paddingX: 1 },
+	);
+}
+
+function renderSendResult(
+	result: { content: Array<{ type: string; text?: string }>; isError?: boolean },
+	details: Partial<CoordinationDetails>,
+	args: HubRenderArgs | undefined,
+	expanded: boolean,
+	theme: Theme,
+): string[] {
+	const receipts = details.receipts ?? [];
+	const to = details.to ?? args?.to?.trim() ?? "?";
+	const title = `IRC ${theme.nav.selected} ${to}`;
+
+	// Pre-delivery failures (validation) and empty broadcasts carry no receipts.
+	if (receipts.length === 0) {
+		const text = textContent(result) || (result.isError ? "Send failed." : "Nothing to deliver.");
+		return [
+			renderStatusLine({ icon: result.isError ? "error" : "warning", title }, theme),
+			result.isError ? formatErrorDetail(text, theme) : `  ${theme.fg("muted", replaceTabs(text))}`,
+		];
+	}
+
+	const delivered = receipts.filter(receipt => receipt.outcome !== "failed");
+	const failedCount = receipts.length - delivered.length;
+	const waited = details.waited;
+	const timedOut = waited === null;
+
+	const meta: string[] = [];
+	if (to === "all") meta.push("broadcast");
+	if (receipts.length === 1) {
+		const receipt = receipts[0]!;
+		meta.push(theme.fg(outcomeColor(receipt.outcome), receipt.outcome));
+	} else {
+		if (delivered.length > 0) meta.push(theme.fg("success", `${delivered.length} delivered`));
+		if (failedCount > 0) meta.push(theme.fg("error", `${failedCount} failed`));
+	}
+	if (timedOut) meta.push(theme.fg("warning", "no reply"));
+
+	const icon = result.isError
+		? { icon: "error" as const }
+		: timedOut
+			? { icon: "warning" as const }
+			: { iconOverride: ircGlyph(theme) };
+	const lines = [renderStatusLine({ ...icon, title, meta }, theme)];
+
+	const sent = args?.message?.trim();
+	if (sent) lines.push(...bodyLines(sent, expanded, theme, { indent: "  ", tone: "dim" }));
+
+	if (receipts.length > 1 || failedCount > 0) {
+		lines.push(
+			...renderTreeList<IrcDeliveryReceipt>(
+				{
+					items: receipts,
+					expanded,
+					maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
+					itemType: "recipient",
+					renderItem: receipt => {
+						const badge = formatBadge(receipt.outcome, outcomeColor(receipt.outcome), theme);
+						const error =
+							receipt.outcome === "failed" && receipt.error
+								? ` ${theme.fg("error", `${theme.format.dash} ${receipt.error}`)}`
+								: "";
+						return `${theme.fg("toolOutput", receipt.to)} ${badge}${error}`;
+					},
+				},
+				theme,
+			),
+		);
+	}
+
+	if (waited) {
+		const age = messageAge(waited.ts);
+		lines.push(
+			`  ${theme.fg("dim", theme.nav.back)} ${theme.fg("accent", waited.from)}${age ? ` ${theme.fg("dim", age)}` : ""}`,
+		);
+		lines.push(...bodyLines(waited.body, expanded, theme, { indent: "  " }));
+	} else if (timedOut) {
+		lines.push(`  ${theme.fg("warning", "No reply yet — they may answer later; check inbox or wait again.")}`);
+	}
+	return lines;
+}
+
+function renderWaitResult(
+	result: { content: Array<{ type: string; text?: string }>; isError?: boolean },
+	details: Partial<CoordinationDetails>,
+	args: HubRenderArgs | undefined,
+	expanded: boolean,
+	theme: Theme,
+): string[] {
+	const waited = details.waited;
+	if (!waited) {
+		const text = textContent(result) || "No message arrived.";
+		return [
+			renderStatusLine(
+				{ icon: "warning", title: `IRC ${theme.nav.back} ${args?.from?.trim() || "anyone"}`, meta: ["timed out"] },
+				theme,
+			),
+			`  ${theme.fg("muted", replaceTabs(text))}`,
+		];
+	}
+	const meta = [messageAge(waited.ts)];
+	if (waited.replyTo) meta.push("reply");
+	return [
+		renderStatusLine({ iconOverride: ircGlyph(theme), title: `IRC ${theme.nav.back} ${waited.from}`, meta }, theme),
+		...bodyLines(waited.body, expanded, theme, { indent: "  " }),
+	];
+}
+
+function renderInboxResult(
+	details: Partial<CoordinationDetails>,
+	args: HubRenderArgs | undefined,
+	expanded: boolean,
+	theme: Theme,
+): string[] {
+	const messages = details.inbox ?? [];
+	if (messages.length === 0) {
+		return [renderStatusLine({ iconOverride: ircGlyph(theme), title: "IRC inbox", meta: ["empty"] }, theme)];
+	}
+	const meta = [`${messages.length} ${messages.length === 1 ? "message" : "messages"}`];
+	if (args?.peek) meta.push("peek");
+	const header = renderStatusLine({ iconOverride: ircGlyph(theme), title: "IRC inbox", meta }, theme);
+	const items = renderTreeList<IrcMessage>(
+		{
+			items: messages,
+			expanded,
+			maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
+			itemType: "message",
+			renderItem: msg => {
+				const age = messageAge(msg.ts);
+				const replyBadge = msg.replyTo ? ` ${formatBadge("reply", "muted", theme)}` : "";
+				const head = `${theme.fg("accent", msg.from)}${age ? ` ${theme.fg("dim", age)}` : ""}${replyBadge}`;
+				return [head, ...bodyLines(msg.body, expanded, theme, { collapsedLines: 1 })];
+			},
+		},
+		theme,
+	);
+	return [header, ...items];
+}
+
+function renderListResult(details: Partial<CoordinationDetails>, expanded: boolean, theme: Theme): string[] {
+	const peers = [...(details.peers ?? [])].sort(
+		(a, b) =>
+			(PEER_STATUS_ORDER[a.status] ?? 9) - (PEER_STATUS_ORDER[b.status] ?? 9) || b.lastActivity - a.lastActivity,
+	);
+	if (peers.length === 0) {
+		return [renderStatusLine({ icon: "info", title: "IRC peers", meta: ["no other agents"] }, theme)];
+	}
+	const counts = new Map<string, number>();
+	for (const peer of peers) counts.set(peer.status, (counts.get(peer.status) ?? 0) + 1);
+	const meta = [...counts].map(([status, count]) => `${count} ${status}`);
+	const unreadTotal = peers.reduce((sum, peer) => sum + peer.unread, 0);
+	if (unreadTotal > 0) meta.push(theme.fg("warning", `${unreadTotal} unread`));
+	const header = renderStatusLine({ iconOverride: ircGlyph(theme), title: "IRC peers", meta }, theme);
+	const items = renderTreeList(
+		{
+			items: peers,
+			expanded,
+			maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
+			itemType: "peer",
+			renderItem: peer => {
+				const kindText = peer.parentId ? `${peer.kind}${theme.sep.dot}of ${peer.parentId}` : peer.kind;
+				const unread = peer.unread > 0 ? ` ${formatBadge(`${peer.unread} unread`, "warning", theme)}` : "";
+				const age = messageAge(peer.lastActivity);
+				const activity = peer.activity ? ` ${theme.fg("dim", replaceTabs(peer.activity))}` : "";
+				const name = theme.fg("dim", replaceTabs(peer.displayName));
+				return `${peerStatusBadge(peer.status, theme)} ${theme.bold(replaceTabs(peer.id))} ${name} ${theme.fg("dim", kindText)}${activity}${unread}${age ? ` ${theme.fg("dim", age)}` : ""}`;
+			},
+		},
+		theme,
+	);
+	return [header, ...items];
+}
+
+function buildResultLines(
+	result: { content: Array<{ type: string; text?: string }>; isError?: boolean },
+	details: Partial<CoordinationDetails>,
+	args: HubRenderArgs | undefined,
+	expanded: boolean,
+	theme: Theme,
+): string[] {
+	switch (details.op ?? args?.op) {
+		case "send":
+			return renderSendResult(result, details, args, expanded, theme);
+		case "wait":
+			return renderWaitResult(result, details, args, expanded, theme);
+		case "inbox":
+			return result.isError
+				? renderErrorResult(result, args, theme)
+				: renderInboxResult(details, args, expanded, theme);
+		case "list":
+			return result.isError ? renderErrorResult(result, args, theme) : renderListResult(details, expanded, theme);
+		default: {
+			const text = textContent(result) || (result.isError ? "Hub call failed." : "Done.");
+			return [
+				renderStatusLine({ icon: result.isError ? "error" : "success", title: callTitle(args, theme) }, theme),
+				result.isError ? formatErrorDetail(text, theme) : `  ${theme.fg("muted", replaceTabs(text))}`,
+			];
+		}
+	}
+}
+
+/** Pending-call frame for messaging ops (send/wait-from/inbox/list). */
+export function messagingRenderCall(args: HubRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
+	const lines = [
+		renderStatusLine({ icon: "pending", title: callTitle(args, uiTheme), meta: callMeta(args) }, uiTheme),
+	];
+	if (args?.op === "send" && args.message?.trim()) {
+		lines.push(...bodyLines(args.message, false, uiTheme, { indent: "  ", tone: "dim", collapsedLines: 1 }));
+	}
+	return new Text(lines.join("\n"), 0, 0);
+}
+
+/** Result frame for messaging ops and message-carrying `wait` results. */
+export function messagingRenderResult(
+	result: { content: Array<{ type: string; text?: string }>; details?: CoordinationDetails; isError?: boolean },
+	options: RenderResultOptions,
+	uiTheme: Theme,
+	args?: HubRenderArgs,
+): Component {
+	const details: Partial<CoordinationDetails> = result.details ?? {};
+	return createCachedComponent(
+		() => options.expanded,
+		(width, expanded) =>
+			buildResultLines(result, details, args, expanded, uiTheme).map(line =>
+				truncateToWidth(line, width, Ellipsis.Unicode),
+			),
+	);
+}
diff --git a/packages/coding-agent/src/tools/hub/types.ts b/packages/coding-agent/src/tools/hub/types.ts
new file mode 100644
index 000000000..233794ab6
--- /dev/null
+++ b/packages/coding-agent/src/tools/hub/types.ts
@@ -0,0 +1,115 @@
+/**
+ * Shared types for the hub tool — the merged agent-coordination surface
+ * covering peer messaging (IRC bus), background-job control, and supervised
+ * long-running processes (launch).
+ */
+
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { IrcDeliveryReceipt, IrcMessage } from "../../irc/bus";
+import type { LaunchParams, LaunchToolDetails } from "./launch";
+
+/**
+ * Hub operations: messaging (`send`/`wait`/`inbox`/`list`), jobs
+ * (`wait`/`cancel`/`jobs`), and process supervision (`start`/`ps`/`logs`/
+ * `stop`/`restart`/`describe`, plus `send`/`wait` when they carry `name`).
+ */
+export type HubOp =
+	| "send"
+	| "wait"
+	| "inbox"
+	| "list"
+	| "jobs"
+	| "cancel"
+	| "start"
+	| "ps"
+	| "logs"
+	| "stop"
+	| "restart"
+	| "describe";
+
+/** Peer row surfaced by `op:"list"`. */
+export interface HubPeerInfo {
+	id: string;
+	displayName: string;
+	kind: string;
+	status: string;
+	parentId?: string;
+	unread: number;
+	lastActivity: number;
+	activity?: string;
+}
+
+/** Background-job row surfaced by `wait`/`cancel`/`jobs` results. */
+export interface JobSnapshot {
+	id: string;
+	type: "bash" | "task";
+	status: "running" | "completed" | "failed" | "cancelled";
+	label: string;
+	durationMs: number;
+	resultText?: string;
+	errorText?: string;
+}
+
+export type CancelStatus = "cancelled" | "not_found" | "already_completed";
+
+export interface CancelOutcome {
+	id: string;
+	status: CancelStatus;
+	message: string;
+}
+
+/**
+ * A live subagent from the AgentRegistry that has no backing job in the
+ * AsyncJobManager — e.g. an idle agent woken (or a parked agent revived) via
+ * a hub message, or a spawn owned by another agent. Surfaced by `jobs` and
+ * empty-wait snapshots so the hub's picture matches the UI's running-agent
+ * count.
+ */
+export interface AgentActivitySnapshot {
+	id: string;
+	parentId?: string;
+	/** Latest activity gist recorded by the registry (display-only). */
+	activity?: string;
+	/** Time since the agent was registered. */
+	ageMs: number;
+}
+
+/** Result details for messaging and job ops; fields are disjoint per op. */
+export interface CoordinationDetails {
+	op: HubOp;
+	from?: string;
+	to?: string;
+	receipts?: IrcDeliveryReceipt[];
+	/** Message consumed by `wait` / `send await:true`; null when the wait timed out. */
+	waited?: IrcMessage | null;
+	inbox?: IrcMessage[];
+	peers?: HubPeerInfo[];
+	jobs?: JobSnapshot[];
+	cancelled?: { id: string; status: CancelStatus }[];
+	/** Running subagents not represented by a job row in this result. */
+	agents?: AgentActivitySnapshot[];
+}
+
+/** Hub result details: coordination snapshots or launch (process) state. */
+export type HubDetails = CoordinationDetails | LaunchToolDetails;
+
+/** Partially-streamed hub call arguments, as seen by the renderers. */
+export type HubRenderArgs = {
+	op?: string;
+	to?: string;
+	message?: string;
+	replyTo?: string;
+	await?: boolean;
+	from?: string;
+	timeoutMs?: number;
+	peek?: boolean;
+	ids?: string[];
+} & Partial<Omit<LaunchParams, "op">>;
+
+export function hubErrorResult(text: string, details: CoordinationDetails): AgentToolResult<HubDetails> {
+	return {
+		content: [{ type: "text", text }],
+		details,
+		isError: true,
+	};
+}
diff --git a/packages/coding-agent/src/tools/index.ts b/packages/coding-agent/src/tools/index.ts
index 1f4529058..b3e88bf53 100644
--- a/packages/coding-agent/src/tools/index.ts
+++ b/packages/coding-agent/src/tools/index.ts
@@ -29,8 +29,6 @@ import type { ToolChoiceQueue } from "../session/tool-choice-queue";
 import { TaskTool } from "../task";
 import type { AgentOutputManager } from "../task/output-manager";
 import { canSpawnAtDepth } from "../task/types";
-import { countToolsForAutoDiscovery, resolveEffectiveToolDiscoveryMode } from "../tool-discovery/mode";
-import type { DiscoverableTool, DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
 import type { EventBus } from "../utils/event-bus";
 import { WebSearchTool } from "../web/search";
 import type { WorkspaceTree } from "../workspace-tree";
@@ -39,7 +37,7 @@ import { AstEditTool } from "./ast-edit";
 import { AstGrepTool } from "./ast-grep";
 import { BashTool } from "./bash";
 import { BrowserTool } from "./browser";
-import { type BuiltinToolName, normalizeToolNames } from "./builtin-names";
+import { type BuiltinToolName, type HiddenToolName, normalizeToolNames } from "./builtin-names";
 import { type CheckpointState, CheckpointTool, type CompletedRewindState, RewindTool } from "./checkpoint";
 import { DebugTool } from "./debug";
 import { EvalTool } from "./eval";
@@ -47,10 +45,8 @@ import { resolveEvalBackends } from "./eval-backends";
 import { GithubTool } from "./gh";
 import { GlobTool } from "./glob";
 import { GrepTool } from "./grep";
+import { HubTool } from "./hub";
 import { InspectImageTool } from "./inspect-image";
-import { IrcTool, isIrcEnabled } from "./irc";
-import { JobTool } from "./job";
-import { LaunchTool } from "./launch";
 import { LearnTool } from "./learn";
 import { ManageSkillTool } from "./manage-skill";
 import { MemoryEditTool } from "./memory-edit";
@@ -59,13 +55,10 @@ import { MemoryReflectTool } from "./memory-reflect";
 import { MemoryRetainTool } from "./memory-retain";
 import { wrapToolWithMetaNotice } from "./output-meta";
 import { ReadTool } from "./read";
-import { createReportToolIssueTool, isAutoQaEnabled } from "./report-tool-issue";
-import { ResolveTool } from "./resolve";
-import { reportFindingTool } from "./review";
-import { SearchToolBm25Tool } from "./search-tool-bm25";
-import { loadSshTool } from "./ssh";
+import type { PlanProposalHandler } from "./resolve";
 import { type TodoPhase, TodoTool } from "./todo";
 import { WriteTool } from "./write";
+import { isMountableUnderXdev, XdevRegistry } from "./xdev";
 import { YieldTool } from "./yield";
 
 export * from "../edit";
@@ -86,11 +79,9 @@ export * from "./eval-backends";
 export * from "./gh";
 export * from "./glob";
 export * from "./grep";
+export * from "./hub";
 export * from "./image-gen";
 export * from "./inspect-image";
-export * from "./irc";
-export * from "./job";
-export * from "./launch";
 export * from "./learn";
 export * from "./manage-skill";
 export * from "./memory-edit";
@@ -101,12 +92,11 @@ export * from "./read";
 export * from "./report-tool-issue";
 export * from "./resolve";
 export * from "./review";
-export * from "./search-tool-bm25";
-export * from "./ssh";
 export * from "./todo";
 export * from "./tts";
 export * from "./vibe";
 export * from "./write";
+export * from "./xdev";
 export * from "./yield";
 
 /** Tool type (AgentTool from pi-ai) */
@@ -125,13 +115,6 @@ export type ImageAttachmentEntry = {
 	image: ImageContent;
 };
 
-export type {
-	DiscoverableTool,
-	DiscoverableToolSearchIndex,
-	DiscoverableToolSearchResult,
-	DiscoverableToolSource,
-} from "../tool-discovery/tool-index";
-
 /**
  * A late LSP diagnostics result that arrived after the edit/write tool already
  * returned. Surfaced to the model and the transcript via
@@ -234,6 +217,8 @@ export interface ToolSession {
 	isToolActive?: (name: string) => boolean;
 	/** Update the active built-in tool predicate when a session changes tools mid-run. */
 	setActiveToolNames?: (names: Iterable<string>) => void;
+	/** Tools mounted under `xd://` (set by createTools when `tools.xdev` is active); read/write consult it at execute time. */
+	xdevRegistry?: XdevRegistry;
 	/** Agent registry for IRC routing across live sessions. */
 	agentRegistry?: AgentRegistry;
 	/** Get artifacts directory for artifact:// URLs */
@@ -299,45 +284,27 @@ export interface ToolSession {
 	getTodoPhases?: () => TodoPhase[];
 	/** Replace cached todo phases for this session. */
 	setTodoPhases?: (phases: TodoPhase[]) => void;
-	/** Whether MCP tool discovery is active for this session. */
-	isMCPDiscoveryEnabled?: () => boolean;
-	/** Get MCP tools activated by prior search_tool_bm25 calls. */
-	getSelectedMCPToolNames?: () => string[];
-	/** Merge MCP tool selections into the active session tool set. */
-	activateDiscoveredMCPTools?: (toolNames: string[]) => Promise<string[]>;
-	// ── Generic tool discovery (unified — covers built-in + MCP + extension) ──
-	/** Whether any form of tool discovery is active (tools.discoveryMode !== "off" or mcp.discoveryMode). */
-	isToolDiscoveryEnabled?: () => boolean;
-	/** Get all hidden-but-discoverable tools for search_tool_bm25 prompts. */
-	getDiscoverableTools?: (filter?: {
-		source?: import("../tool-discovery/tool-index").DiscoverableToolSource;
-	}) => DiscoverableTool[];
-	/** Get the cached generic discoverable search index. */
-	getDiscoverableToolSearchIndex?: () => DiscoverableToolSearchIndex;
-	/** Get tool names activated by prior search_tool_bm25 calls (all sources). */
-	getSelectedDiscoveredToolNames?: () => string[];
-	/** Merge tool selections into the active session tool set. */
-	activateDiscoveredTools?: (toolNames: string[]) => Promise<string[]>;
 	/** The tool-choice queue used to force forthcoming tool invocations and carry invocation handlers. */
 	getToolChoiceQueue?(): ToolChoiceQueue;
 	/** Build a model-provider-specific ToolChoice that targets the named tool, or undefined if unsupported. */
 	buildToolChoice?(toolName: string): ToolChoice | undefined;
 	/** Steer a hidden custom message into the conversation (e.g. a preview reminder). */
 	steer?(message: { customType: string; content: string; details?: unknown }): void;
-	/** Peek the currently in-flight tool-choice queue directive's invocation handler. Used by the `resolve` tool to dispatch to the pending action. */
+	/** Peek the currently in-flight tool-choice queue directive's invocation handler. Used by
+	 *  the `xd://resolve` and `xd://reject` dispatch to reach the pending action. */
 	peekQueueInvoker?(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
-	/** Peek the most-recently registered non-forcing pending preview invoker. The `resolve`
-	 *  tool dispatches to it so a staged preview resolves WITHOUT forcing tool_choice — the
-	 *  agent-loop's SoftToolRequirement lifecycle owns reminder injection and escalation. */
+	/** Peek the most-recently registered non-forcing pending preview invoker. A `write` to
+	 *  `xd://resolve` or `xd://reject` dispatches to it so a staged preview resolves
+	 *  WITHOUT forcing tool_choice — the agent-loop's SoftToolRequirement lifecycle owns
+	 *  reminder injection and escalation. */
 	peekPendingInvoker?(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
-	/** Clear stale pending preview markers when `resolve` cannot dispatch them. */
+	/** Clear stale pending preview markers when a resolution dispatch cannot run them. */
 	clearPendingInvokers?(): void;
-	/** Peek the long-lived "standing" resolve handler registered by a mode (e.g. plan mode).
-	 *  Consulted by the `resolve` tool as a fallback when no queue invoker is in flight,
-	 *  letting modes accept `resolve` invocations without forcing the tool choice every turn. */
-	peekStandingResolveHandler?(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
-	/** Register or clear the standing resolve handler. Passing `null` clears it. */
-	setStandingResolveHandler?(handler: ((input: unknown) => Promise<unknown> | unknown) | null): void;
+	/** Peek the plan-proposal handler installed by plan mode. `xd://propose` dispatches the
+	 *  written plan title to it. */
+	peekPlanProposalHandler?(): PlanProposalHandler | undefined;
+	/** Register or clear the plan-proposal handler. Passing `null` clears it. */
+	setPlanProposalHandler?(handler: PlanProposalHandler | null): void;
 	/** Get active checkpoint state if any. */
 	getCheckpointState?: () => CheckpointState | undefined;
 	/** Set or clear active checkpoint state. */
@@ -388,65 +355,6 @@ export interface ToolSession {
 
 export type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
 
-export type BuiltinToolLoadMode = "essential" | "discoverable";
-
-/** Default essential tool names when tools.essentialOverride is empty. */
-export const DEFAULT_ESSENTIAL_TOOL_NAMES: readonly string[] = [
-	"read",
-	"bash",
-	"launch",
-	"edit",
-	"write",
-	"glob",
-	"eval",
-] as const;
-
-/**
- * Resolve the active essential built-in tool names from settings.
- * Returns `tools.essentialOverride` if non-empty (filtered to known built-ins),
- * otherwise `DEFAULT_ESSENTIAL_TOOL_NAMES`.
- */
-export function computeEssentialBuiltinNames(settings: Settings): string[] {
-	const override = settings.get("tools.essentialOverride") ?? [];
-	const cleaned = normalizeToolNames(override.map(name => name.trim()).filter(Boolean));
-	if (cleaned.length > 0) {
-		return cleaned.filter(name => name in BUILTIN_TOOLS);
-	}
-	return [...DEFAULT_ESSENTIAL_TOOL_NAMES];
-}
-
-/**
- * Filter the initial active tool set when `tools.discoveryMode === "all"`.
- *
- * Non-essential discoverable built-ins are hidden — the model rediscovers them
- * via `search_tool_bm25` and activates them on demand. A tool survives hiding
- * when it is essential, explicitly requested, restored from a prior selection,
- * or required by a forced tool_choice feature (`forceActive`). The last case is
- * load-bearing: a named tool_choice (e.g. the eager `todo` prelude) must
- * reference a tool present in the request, or the provider rejects it with 400.
- */
-export function filterInitialToolsForDiscoveryAll(
-	initialToolNames: string[],
-	opts: {
-		loadModeOf: (name: string) => BuiltinToolLoadMode | undefined;
-		essentialNames: ReadonlySet<string>;
-		explicitlyRequested: ReadonlySet<string>;
-		restored: ReadonlySet<string>;
-		forceActive: ReadonlySet<string>;
-	},
-): string[] {
-	return initialToolNames.filter(name => {
-		const loadMode = opts.loadModeOf(name);
-		if (!loadMode) return true; // not a built-in — leave MCP/custom/extension to existing logic
-		if (loadMode === "essential") return true;
-		if (opts.essentialNames.has(name)) return true;
-		if (opts.explicitlyRequested.has(name)) return true;
-		if (opts.restored.has(name)) return true;
-		if (opts.forceActive.has(name)) return true;
-		return false;
-	});
-}
-
 /**
  * Public callable factory map. External callers may invoke `BUILTIN_TOOLS.read(session)` or
  * `BUILTIN_TOOLS[name](session)` to construct a tool directly.
@@ -454,14 +362,12 @@ export function filterInitialToolsForDiscoveryAll(
 export const BUILTIN_TOOLS: Record<BuiltinToolName, ToolFactory> = {
 	read: s => new ReadTool(s),
 	bash: s => new BashTool(s),
-	launch: s => new LaunchTool(s),
 	edit: s => new EditTool(s),
 	ast_grep: s => new AstGrepTool(s),
 	ast_edit: s => new AstEditTool(s),
 	ask: AskTool.createIf,
 	debug: DebugTool.createIf,
 	eval: s => new EvalTool(s),
-	ssh: loadSshTool,
 	github: GithubTool.createIf,
 	glob: s => new GlobTool(s, { rootPathAlias: true }),
 	grep: s => new GrepTool(s),
@@ -471,11 +377,9 @@ export const BUILTIN_TOOLS: Record<BuiltinToolName, ToolFactory> = {
 	checkpoint: CheckpointTool.createIf,
 	rewind: RewindTool.createIf,
 	task: s => TaskTool.create(s),
-	job: s => new JobTool(s),
-	irc: IrcTool.createIf,
+	hub: s => new HubTool(s),
 	todo: s => new TodoTool(s),
 	web_search: s => new WebSearchTool(s),
-	search_tool_bm25: SearchToolBm25Tool.createIf,
 	write: s => new WriteTool(s),
 	memory_edit: MemoryEditTool.createIf,
 	retain: MemoryRetainTool.createIf,
@@ -485,11 +389,8 @@ export const BUILTIN_TOOLS: Record<BuiltinToolName, ToolFactory> = {
 	manage_skill: ManageSkillTool.createIf,
 };
 
-export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
+export const HIDDEN_TOOLS: Record<HiddenToolName, ToolFactory> = {
 	yield: s => new YieldTool(s),
-	report_finding: () => reportFindingTool,
-	report_tool_issue: s => createReportToolIssueTool(s),
-	resolve: s => new ResolveTool(s),
 	goal: s => new GoalTool(s),
 };
 
@@ -599,20 +500,11 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 			}
 		}
 	}
-	// Resolve effective tool discovery mode.
-	// tools.discoveryMode controls the new modes; mcp.discoveryMode remains a back-compat alias for "mcp-only".
-	const effectiveDiscoveryMode = resolveEffectiveToolDiscoveryMode(
-		session.settings,
-		countToolsForAutoDiscovery(requestedTools ?? Object.keys(BUILTIN_TOOLS)),
-	);
-	const discoveryActive = effectiveDiscoveryMode !== "off";
-
 	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };
 	const isToolAllowed = (name: string) => {
 		if (name === "goal") return goalEnabled && goalModeActive;
 		if (name === "lsp") return enableLsp && session.settings.get("lsp.enabled");
 		if (name === "bash") return session.settings.get("bash.enabled");
-		if (name === "launch") return session.settings.get("launch.enabled");
 		if (name === "eval") return allowEval;
 		if (name === "debug") return session.settings.get("debug.enabled");
 		if (name === "todo")
@@ -624,12 +516,9 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "ast_edit") return session.settings.get("astEdit.enabled");
 		if (name === "inspect_image") return session.settings.get("inspect_image.enabled");
 		if (name === "web_search") return session.settings.get("web_search.enabled");
-		// search_tool_bm25 is allowed when either legacy mcp.discoveryMode or new tools.discoveryMode is active.
-		if (name === "search_tool_bm25") return discoveryActive;
 		if (name === "ask") return session.settings.get("ask.enabled");
 		if (name === "browser") return session.settings.get("browser.enabled");
 		if (name === "checkpoint" || name === "rewind") return session.settings.get("checkpoint.enabled");
-		if (name === "irc") return isIrcEnabled(session.settings, session.taskDepth ?? 0);
 		if (name === "retain" || name === "recall" || name === "reflect") {
 			return ["hindsight", "mnemopi"].includes(session.settings.get("memory.backend") ?? "");
 		}
@@ -653,7 +542,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 	const filteredRequestedTools = requestedTools?.filter(name => name in allTools && isToolAllowed(name));
 	const baseEntries =
 		filteredRequestedTools !== undefined
-			? filteredRequestedTools.filter(name => name !== "resolve").map(name => [name, allTools[name]] as const)
+			? filteredRequestedTools.map(name => [name, allTools[name]] as const)
 			: [
 					...Object.entries(BUILTIN_TOOLS)
 						.filter(([name]) => isToolAllowed(name))
@@ -675,28 +564,43 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 			return tool ? wrapToolWithMetaNotice(tool) : null;
 		}),
 	);
-	const tools = baseResults.filter((r): r is Tool => r !== null);
-	if (!tools.some(tool => tool.name === "resolve")) {
-		const resolveTool = await logger.time("createTools:resolve", HIDDEN_TOOLS.resolve, session);
-		if (resolveTool) {
-			tools.push(wrapToolWithMetaNotice(resolveTool));
+	let tools = baseResults.filter((r): r is Tool => r !== null);
+
+	// xd:// mounting: unmount discoverable built-ins from the tools array and
+	// expose them as virtual device URLs driven through read/write. Active for
+	// default tool sets when `tools.xdev` is enabled.
+	const xdevEnabled = requestedTools === undefined && session.settings.get("tools.xdev");
+	if (xdevEnabled) {
+		const mounted: Tool[] = [];
+		const kept: Tool[] = [];
+		for (const tool of tools) {
+			const mountable = isMountableUnderXdev(tool) && tool.name in BUILTIN_TOOLS;
+			(mountable ? mounted : kept).push(tool);
+		}
+		session.xdevRegistry = new XdevRegistry(mounted);
+		tools = kept;
+		const finalActiveNames = new Set(tools.map(tool => tool.name));
+		if (session.setActiveToolNames) {
+			session.setActiveToolNames(finalActiveNames);
+		} else {
+			session.isToolActive = name => finalActiveNames.has(name);
 		}
 	}
-
-	// Auto-inject report_tool_issue when autoqa is enabled (env or setting).
-	// Injected unconditionally into every agent, regardless of requested tool list.
-	const autoQA = isAutoQaEnabled(session.settings);
-	if (autoQA && !tools.some(t => t.name === "report_tool_issue")) {
-		// Build the enum from tools we just constructed via BUILTIN_TOOLS / HIDDEN_TOOLS.
-		// Extension overrides (e.g. a user's custom `bash`) get added later by
-		// other code paths, so they're absent here — exactly what we want; MCP /
-		// extension tools never end up in the report enum.
-		const activeBuiltinNames = tools
-			.map(t => t.name)
-			.filter(name => (name in BUILTIN_TOOLS || name in HIDDEN_TOOLS) && name !== "report_tool_issue");
-		const qaTool = createReportToolIssueTool(session, activeBuiltinNames);
-		if (qaTool) {
-			tools.push(wrapToolWithMetaNotice(qaTool));
+	// The xd:// transport rides read/write: `read xd://` lists+documents devices,
+	// `write xd://<tool>` executes them. Staged previews from deferrable tools
+	// (e.g. ast_edit) also resolve through a `write` to xd://resolve/reject. Retain
+	// both whenever any device is mounted or a deferrable tool can stage one.
+	const xdevMounted = (session.xdevRegistry?.size ?? 0) > 0;
+	if ((tools.some(tool => tool.deferrable === true) || xdevMounted) && !tools.some(tool => tool.name === "write")) {
+		const writeTool = await logger.time("createTools:write", BUILTIN_TOOLS.write, session);
+		if (writeTool) {
+			tools.push(wrapToolWithMetaNotice(writeTool));
+		}
+	}
+	if (xdevMounted && !tools.some(tool => tool.name === "read")) {
+		const readTool = await logger.time("createTools:read", BUILTIN_TOOLS.read, session);
+		if (readTool) {
+			tools.push(wrapToolWithMetaNotice(readTool));
 		}
 	}
 
diff --git a/packages/coding-agent/src/tools/irc.ts b/packages/coding-agent/src/tools/irc.ts
deleted file mode 100644
index d6841d84a..000000000
--- a/packages/coding-agent/src/tools/irc.ts
+++ /dev/null
@@ -1,852 +0,0 @@
-/**
- * IRC tool — agent-to-agent messaging over the process-global IrcBus.
- *
- * `send` is fire-and-forget: the bus routes the message to the recipient
- * (waking idle agents with a real turn, reviving parked ones via the
- * lifecycle manager, injecting a non-interrupting aside into busy ones) and
- * returns delivery receipts immediately. Replies are real turns by the
- * recipient, observed with `wait` (or the `await: true` send sugar). `inbox`
- * drains pending messages; `list` shows every addressable peer.
- */
-
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import type { ToolExample } from "@oh-my-pi/pi-ai";
-import { type Component, Text } from "@oh-my-pi/pi-tui";
-import { formatAge, formatDuration, prompt } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
-import type { Settings } from "../config/settings";
-import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { IrcBus, type IrcDeliveryReceipt, type IrcMessage } from "../irc/bus";
-import type { Theme } from "../modes/theme/theme";
-import ircDescription from "../prompts/tools/irc.md" with { type: "text" };
-import { type AgentRegistry, MAIN_AGENT_ID } from "../registry/agent-registry";
-import { canSpawnAtDepth } from "../task/types";
-import { Ellipsis, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
-import type { ToolSession } from ".";
-import {
-	createCachedComponent,
-	formatBadge,
-	formatErrorDetail,
-	getPreviewLines,
-	PREVIEW_LIMITS,
-	replaceTabs,
-	type ToolUIColor,
-} from "./render-utils";
-
-const DEFAULT_IRC_TIMEOUT_MS = 120_000;
-
-/**
- * IRC availability: there must be someone to chat with. True for every
- * subagent (it always has a parent, and possibly siblings) and for any
- * session that can still spawn subagents through the task tool. Only a
- * top-level session with task spawning unavailable has no peers — no irc.
- */
-export function isIrcEnabled(settings: Settings, taskDepth: number): boolean {
-	if (taskDepth > 0) return true;
-	// Top-level session: peers exist only if it can still spawn subagents — the
-	// same capacity gate the task tool uses, reused here to avoid drift.
-	const maxDepth = settings.get("task.maxRecursionDepth") ?? 2;
-	return canSpawnAtDepth(maxDepth, taskDepth);
-}
-
-const ircSchema = type({
-	op: type("'send' | 'wait' | 'inbox' | 'list'").describe("irc operation"),
-	"to?": type("string").describe('send: recipient agent id or "all"'),
-	"message?": type("string").describe("send: message body"),
-	"replyTo?": type("string").describe("send: message id being answered"),
-	"await?": type("boolean").describe('send: wait for the recipient\'s reply (invalid with to:"all")'),
-	"from?": type("string").describe("wait: only accept a message from this agent id"),
-	"timeoutMs?": type("number").describe("wait: timeout in milliseconds (0 waits indefinitely)"),
-	"peek?": type("boolean").describe("inbox: list messages without consuming them"),
-});
-
-type IrcParams = typeof ircSchema.infer;
-
-interface IrcPeerInfo {
-	id: string;
-	displayName: string;
-	kind: string;
-	status: string;
-	parentId?: string;
-	unread: number;
-	lastActivity: number;
-	activity?: string;
-}
-
-export interface IrcDetails {
-	op: "send" | "wait" | "inbox" | "list";
-	from?: string;
-	to?: string;
-	receipts?: IrcDeliveryReceipt[];
-	/** Message consumed by `wait` / `send await:true`; null when the wait timed out. */
-	waited?: IrcMessage | null;
-	inbox?: IrcMessage[];
-	peers?: IrcPeerInfo[];
-}
-
-function formatIncoming(msg: IrcMessage): string {
-	const replyTag = msg.replyTo ? ` (reply to ${msg.replyTo})` : "";
-	return `[${msg.id}] ${msg.from}${replyTag}: ${msg.body}`;
-}
-
-export class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
-	readonly name = "irc";
-	readonly approval = "read" as const;
-	readonly label = "IRC";
-	readonly summary = "Send and receive messages between agents";
-	readonly description: string;
-	readonly parameters = ircSchema;
-	readonly strict = true;
-	readonly interruptible = true;
-
-	readonly examples: readonly ToolExample<typeof ircSchema.infer>[] = [
-		{
-			caption: "List peers",
-			call: { op: "list" },
-		},
-		{
-			caption: "Fire-and-forget DM — same send wakes idle/parked peers",
-			call: {
-				op: "send",
-				to: "AuthLoader",
-				message: "Still touching src/server/auth.ts? I need to add a 401 path.",
-			},
-		},
-		{
-			caption: "Round-trip when you cannot proceed without the answer",
-			call: {
-				op: "send",
-				to: "Main",
-				message: "JWT or session cookies for the auth flow?",
-				await: true,
-			},
-		},
-		{
-			caption: "Block until a specific peer answers",
-			call: { op: "wait", from: "AuthLoader", timeoutMs: 60000 },
-		},
-		{
-			caption: "Drain pending messages",
-			call: { op: "inbox" },
-		},
-		{
-			caption: "Broadcast to live peers (no replies expected)",
-			call: {
-				op: "send",
-				to: "all",
-				message: "About to refactor src/server/middleware/*. Anyone already in there?",
-			},
-		},
-	];
-	readonly loadMode = "discoverable";
-	constructor(private readonly session: ToolSession) {
-		this.description = prompt.render(ircDescription);
-	}
-
-	static createIf(session: ToolSession): IrcTool | null {
-		if (!isIrcEnabled(session.settings, session.taskDepth ?? 0)) return null;
-		if (!session.agentRegistry || !session.getAgentId) return null;
-		return new IrcTool(session);
-	}
-
-	async execute(
-		_toolCallId: string,
-		params: IrcParams,
-		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<IrcDetails>,
-		_context?: AgentToolContext,
-	): Promise<AgentToolResult<IrcDetails>> {
-		const registry = this.session.agentRegistry;
-		const senderId = this.session.getAgentId?.() ?? null;
-		if (!registry) {
-			return errorResult("IRC is unavailable in this session.", { op: params.op });
-		}
-		if (!senderId) {
-			return errorResult("IRC is unavailable: caller has no agent id.", { op: params.op });
-		}
-
-		switch (params.op) {
-			case "list":
-				return this.#executeList(registry, senderId);
-			case "send":
-				return this.#executeSend(registry, senderId, params, signal);
-			case "wait":
-				return this.#executeWait(registry, senderId, params, signal);
-			case "inbox":
-				return this.#executeInbox(registry, senderId, params);
-			default:
-				return errorResult("Unknown irc op.", { op: params.op });
-		}
-	}
-
-	#executeList(registry: AgentRegistry, senderId: string): AgentToolResult<IrcDetails> {
-		const bus = IrcBus.global();
-		const peers = registry
-			.list()
-			.filter(ref => ref.id !== senderId && ref.status !== "aborted" && ref.kind !== "advisor")
-			.map(ref => ({
-				id: ref.id,
-				displayName: ref.displayName,
-				kind: ref.kind,
-				status: ref.status,
-				parentId: ref.parentId,
-				unread: bus.unreadCount(ref.id),
-				lastActivity: ref.lastActivity,
-				activity: ref.activity,
-			}));
-		const lines: string[] = [];
-		if (peers.length === 0) {
-			lines.push("No other agents.");
-		} else {
-			lines.push(`${peers.length} peer(s):`);
-			for (const peer of peers) {
-				const extras = [
-					peer.activity || undefined,
-					peer.unread > 0 ? `unread ${peer.unread}` : undefined,
-					peer.parentId ? `parent ${peer.parentId}` : undefined,
-					`active ${formatDuration(Date.now() - peer.lastActivity)} ago`,
-				].filter(Boolean);
-				lines.push(`- ${peer.id} [${peer.displayName} · ${peer.kind} · ${peer.status}] — ${extras.join(", ")}`);
-			}
-			if (peers.some(peer => peer.status === "parked")) {
-				lines.push("");
-				lines.push("Parked agents are revived automatically when you message them.");
-			}
-		}
-		return {
-			content: [{ type: "text", text: lines.join("\n") }],
-			details: { op: "list", from: senderId, peers },
-		};
-	}
-
-	async #executeSend(
-		registry: AgentRegistry,
-		senderId: string,
-		params: IrcParams,
-		signal?: AbortSignal,
-	): Promise<AgentToolResult<IrcDetails>> {
-		const to = params.to?.trim();
-		const message = params.message?.trim();
-		if (!to) {
-			return errorResult('`to` is required for op="send".', { op: "send", from: senderId });
-		}
-		if (!message) {
-			return errorResult('`message` is required for op="send".', { op: "send", from: senderId });
-		}
-		if (to === senderId) {
-			return errorResult("Cannot send an IRC message to yourself.", { op: "send", from: senderId, to });
-		}
-		const isBroadcast = to === "all";
-		if (isBroadcast && params.await) {
-			return errorResult('`await` is invalid with to:"all" — broadcasts have no single replier.', {
-				op: "send",
-				from: senderId,
-				to,
-			});
-		}
-
-		const bus = IrcBus.global();
-		let waited: IrcMessage | null | undefined;
-		const timeoutMs = params.await ? this.#resolveTimeoutMs(params) : undefined;
-		const awaitAbort = params.await ? new AbortController() : undefined;
-		const awaitCancelled = new Error("IRC await cancelled");
-		let removeAwaitAbortListener: (() => void) | undefined;
-		const waiting = params.await
-			? bus
-					.wait(senderId, { from: to }, timeoutMs ?? DEFAULT_IRC_TIMEOUT_MS, awaitAbort?.signal, {
-						drainPending: false,
-					})
-					.then(
-						message => ({ message, error: null as Error | null }),
-						error => ({
-							message: null,
-							error: error === awaitCancelled ? null : error instanceof Error ? error : new Error(String(error)),
-						}),
-					)
-			: undefined;
-		if (params.await && signal && awaitAbort) {
-			if (signal.aborted) {
-				awaitAbort.abort(signal.reason instanceof Error ? signal.reason : new Error("IRC wait aborted"));
-			} else {
-				const onAbort = (): void => {
-					awaitAbort.abort(signal.reason instanceof Error ? signal.reason : new Error("IRC wait aborted"));
-				};
-				signal.addEventListener("abort", onAbort, { once: true });
-				removeAwaitAbortListener = () => signal.removeEventListener("abort", onAbort);
-			}
-		}
-
-		try {
-			// Broadcasts fan out to live peers only (running | idle); reviving every
-			// parked agent on a broadcast would be a stampede. Direct sends go
-			// through the bus unfiltered so parked recipients are revived.
-			const targets = isBroadcast ? registry.listVisibleTo(senderId).map(ref => ref.id) : [to];
-			// A broadcast that also reaches the main agent delivers the body to it
-			// directly (its own incoming card); relaying the sibling legs to the
-			// main UI would then show the same body once per other recipient.
-			const suppressRelay = isBroadcast && targets.includes(MAIN_AGENT_ID);
-			const receipts = await Promise.all(
-				targets.map(target =>
-					bus.send(
-						{ from: senderId, to: target, body: message, replyTo: params.replyTo },
-						// Awaited sends mark the sender as blocked on an answer so a
-						// busy recipient that cannot reach a step boundary (async
-						// disabled) auto-replies instead of stranding the sender.
-						{ expectsReply: params.await || undefined, suppressRelay: suppressRelay || undefined },
-					),
-				),
-			);
-
-			const lines: string[] = [];
-			const delivered = receipts.filter(receipt => receipt.outcome !== "failed");
-			if (targets.length === 0) {
-				lines.push("No live peers to broadcast to.");
-			} else if (delivered.length === 0) {
-				lines.push("No recipients received the message.");
-			} else {
-				lines.push(`Delivered to ${delivered.length} peer(s):`);
-			}
-			for (const receipt of receipts) {
-				lines.push(
-					receipt.outcome === "failed"
-						? `- ${receipt.to}: failed — ${receipt.error ?? "unknown error"}`
-						: `- ${receipt.to}: ${receipt.outcome}`,
-				);
-			}
-
-			if (params.await && waiting && timeoutMs !== undefined) {
-				lines.push("");
-				if (delivered.length > 0) {
-					const reply = await waiting;
-					if (reply.error) {
-						// The send already succeeded; if the wait was interrupted by our
-						// caller signal (steering / IRC), preserve the delivery receipt so
-						// the agent loop keeps this tool as "sent" instead of marking it
-						// skipped, which would prompt a duplicate resend on the next turn.
-						if (signal?.aborted) {
-							lines.push(
-								`Send delivered but the reply wait was interrupted before ${to} answered. ` +
-									"Check `inbox` or `wait` again after handling the interrupt.",
-							);
-						} else {
-							throw reply.error;
-						}
-					} else {
-						waited = reply.message;
-						if (waited) {
-							lines.push(`Reply from ${waited.from}:`);
-							lines.push(waited.body);
-						} else {
-							lines.push(
-								`No reply from ${to} within ${formatDuration(timeoutMs)}. ` +
-									"They may answer later — check `inbox` or `wait` again.",
-							);
-						}
-					}
-				} else {
-					awaitAbort?.abort(awaitCancelled);
-					const reply = await waiting;
-					if (reply.error) throw reply.error;
-				}
-			}
-
-			return {
-				content: [{ type: "text", text: lines.join("\n") }],
-				details: {
-					op: "send",
-					from: senderId,
-					to,
-					receipts,
-					...(waited !== undefined ? { waited } : {}),
-				},
-				isError: delivered.length === 0 && targets.length > 0,
-			};
-		} finally {
-			awaitAbort?.abort(awaitCancelled);
-			removeAwaitAbortListener?.();
-		}
-	}
-
-	async #executeWait(
-		registry: AgentRegistry,
-		senderId: string,
-		params: IrcParams,
-		signal?: AbortSignal,
-	): Promise<AgentToolResult<IrcDetails>> {
-		const from = params.from?.trim() || undefined;
-		const session = registry.get(senderId)?.session;
-		const pending =
-			typeof session?.drainPendingIrcInboxMessages === "function"
-				? session.drainPendingIrcInboxMessages(senderId, { from, limit: 1 })[0]
-				: undefined;
-		if (pending) {
-			return {
-				content: [{ type: "text", text: formatIncoming(pending) }],
-				details: { op: "wait", from: senderId, waited: pending },
-			};
-		}
-		const timeoutMs = this.#resolveTimeoutMs(params);
-		try {
-			const waited = await IrcBus.global().wait(senderId, { from }, timeoutMs, signal, {
-				liveness: { registry, senderId },
-			});
-			if (!waited) {
-				const filterNote = from ? ` from ${from}` : "";
-				return {
-					content: [{ type: "text", text: `No message${filterNote} within ${formatDuration(timeoutMs)}.` }],
-					details: { op: "wait", from: senderId, waited: null },
-					// A clean wait timeout carries no information once consumed.
-					useless: true,
-				};
-			}
-			return {
-				content: [{ type: "text", text: formatIncoming(waited) }],
-				details: { op: "wait", from: senderId, waited },
-			};
-		} catch (error) {
-			if (signal?.aborted) {
-				throw error;
-			}
-			return errorResult(error instanceof Error ? error.message : String(error), { op: "wait", from: senderId });
-		}
-	}
-
-	#executeInbox(registry: AgentRegistry, senderId: string, params: IrcParams): AgentToolResult<IrcDetails> {
-		const busMessages = IrcBus.global().inbox(senderId, { peek: params.peek });
-		const session = registry.get(senderId)?.session;
-		const pendingMessages =
-			typeof session?.drainPendingIrcInboxMessages === "function"
-				? session.drainPendingIrcInboxMessages(senderId)
-				: [];
-		const messages = [...busMessages, ...pendingMessages].sort((a, b) => a.ts - b.ts);
-		if (messages.length === 0) {
-			return {
-				content: [{ type: "text", text: "Inbox empty." }],
-				details: { op: "inbox", from: senderId, inbox: [] },
-				// An empty inbox drain carries no information once consumed.
-				useless: true,
-			};
-		}
-		const header = params.peek ? `${messages.length} unread message(s):` : `${messages.length} message(s):`;
-		const lines = [header, ...messages.map(msg => `- ${formatIncoming(msg)}`)];
-		return {
-			content: [{ type: "text", text: lines.join("\n") }],
-			details: { op: "inbox", from: senderId, inbox: messages },
-		};
-	}
-
-	#resolveTimeoutMs(params: IrcParams): number {
-		if (params.timeoutMs !== undefined) {
-			return normalizeIrcTimeoutMs(params.timeoutMs);
-		}
-		return normalizeIrcTimeoutMs(this.session.settings.get("irc.timeoutMs"));
-	}
-}
-
-function errorResult(text: string, details: IrcDetails): AgentToolResult<IrcDetails> {
-	return {
-		content: [{ type: "text", text }],
-		details,
-		isError: true,
-	};
-}
-
-function normalizeIrcTimeoutMs(value: number): number {
-	if (value === 0) return 0; // 0 = timeout disabled
-	// Negative or non-finite settings are misconfigurations — fall back to the
-	// default instead of producing an instant 1 ms timeout.
-	if (!Number.isFinite(value) || value < 0) return DEFAULT_IRC_TIMEOUT_MS;
-	return Math.max(1, Math.trunc(value));
-}
-
-// =============================================================================
-// TUI Renderer
-// =============================================================================
-
-type IrcRenderArgs = Partial<IrcParams>;
-
-const BODY_LINES_COLLAPSED = 2;
-const BODY_LINES_EXPANDED = 12;
-const BODY_LINE_WIDTH = 100;
-
-const PEER_STATUS_ORDER: Record<string, number> = { running: 0, idle: 1, parked: 2 };
-
-function ircGlyph(theme: Theme): string {
-	return theme.styledSymbol("tool.irc", "accent");
-}
-
-function outcomeColor(outcome: IrcDeliveryReceipt["outcome"]): ToolUIColor {
-	switch (outcome) {
-		case "woken":
-			return "success";
-		case "revived":
-			return "warning";
-		case "injected":
-			return "accent";
-		case "failed":
-			return "error";
-	}
-}
-
-/** Glyph + status word, matching the agent-hub status conventions. */
-function peerStatusBadge(status: string, theme: Theme): string {
-	switch (status) {
-		case "running":
-			return theme.fg("accent", `${theme.status.running} running`);
-		case "idle":
-			return theme.fg("success", `${theme.status.enabled} idle`);
-		case "parked":
-			return theme.fg("muted", `${theme.status.shadowed} parked`);
-		default:
-			return theme.fg("error", `${theme.status.aborted} ${status}`);
-	}
-}
-
-function messageAge(ts: number | undefined): string {
-	if (!ts) return "";
-	return formatAge(Math.max(1, Math.round((Date.now() - ts) / 1000)));
-}
-
-function textContent(result: { content: Array<{ type: string; text?: string }> }): string {
-	return result.content.find(part => part.type === "text")?.text?.trim() ?? "";
-}
-
-/**
- * Quote-bordered message body preview. `tone` separates outbound text (dim)
- * from received text (toolOutput); a trailing dim counter marks elided lines.
- */
-function bodyLines(
-	body: string,
-	expanded: boolean,
-	theme: Theme,
-	options: { indent?: string; tone?: "dim" | "toolOutput"; collapsedLines?: number } = {},
-): string[] {
-	const indent = options.indent ?? "";
-	const tone = options.tone ?? "toolOutput";
-	const max = expanded ? BODY_LINES_EXPANDED : (options.collapsedLines ?? BODY_LINES_COLLAPSED);
-	const total = body.split("\n").filter(line => line.trim()).length;
-	const quote = theme.fg("dim", theme.md.quoteBorder);
-	const lines = getPreviewLines(body, max, BODY_LINE_WIDTH, Ellipsis.Unicode).map(
-		line => `${indent}${quote} ${theme.fg(tone, replaceTabs(line))}`,
-	);
-	const hidden = total - Math.min(total, max);
-	if (hidden > 0) {
-		lines.push(`${indent}${quote} ${theme.fg("dim", `… +${hidden} more ${hidden === 1 ? "line" : "lines"}`)}`);
-	}
-	return lines;
-}
-
-/** Header title carrying the op direction: `IRC ➤ peer` out, `IRC ⟵ peer` in. */
-function callTitle(args: IrcRenderArgs | undefined, theme: Theme): string {
-	switch (args?.op) {
-		case "send":
-			return `IRC ${theme.nav.selected} ${args.to?.trim() || "…"}`;
-		case "wait":
-			return `IRC ${theme.nav.back} ${args.from?.trim() || "anyone"}`;
-		case "inbox":
-			return "IRC inbox";
-		case "list":
-			return "IRC peers";
-		default:
-			return "IRC";
-	}
-}
-
-function callMeta(args: IrcRenderArgs | undefined): string[] {
-	const meta: string[] = [];
-	if (args?.op === "send") {
-		if (args.to === "all") meta.push("broadcast");
-		if (args.await) meta.push("await reply");
-		if (args.replyTo) meta.push("reply");
-	}
-	if (args?.op === "wait" && args.timeoutMs) meta.push(`timeout ${formatDuration(args.timeoutMs)}`);
-	if (args?.op === "inbox" && args.peek) meta.push("peek");
-	return meta;
-}
-
-function renderErrorResult(
-	result: { content: Array<{ type: string; text?: string }> },
-	args: IrcRenderArgs | undefined,
-	theme: Theme,
-): string[] {
-	const text = textContent(result) || "IRC call failed.";
-	return [
-		renderStatusLine({ icon: "error", title: callTitle(args, theme), meta: callMeta(args) }, theme),
-		formatErrorDetail(text, theme),
-	];
-}
-
-/**
- * Display-only transcript card for live IRC traffic: `irc:incoming` DMs
- * delivered to this session, `irc:autoreply` side-channel replies sent on
- * this session's behalf, and `irc:relay` observations of agent↔agent
- * traffic. Shares the tool renderer's glyph + quote-border conventions so
- * cards and `irc` tool output look identical in the transcript.
- */
-export function createIrcMessageCard(
-	card: {
-		kind: "incoming" | "autoreply" | "relay";
-		from?: string;
-		to?: string;
-		body?: string;
-		replyTo?: string;
-		timestamp?: number;
-	},
-	getExpanded: () => boolean,
-	uiTheme: Theme,
-): Component {
-	const from = card.from?.trim() || "?";
-	const title =
-		card.kind === "incoming"
-			? `IRC ${uiTheme.nav.back} ${from}`
-			: card.kind === "autoreply"
-				? `IRC ${uiTheme.nav.selected} ${card.to?.trim() || "?"}`
-				: `IRC ${from} ${uiTheme.nav.selected} ${card.to?.trim() || "?"}`;
-	const body = card.body ?? "";
-	const meta: string[] = [];
-	if (card.kind === "autoreply") meta.push("auto");
-	if (card.replyTo) meta.push("reply");
-	const age = messageAge(card.timestamp);
-	if (age) meta.push(age);
-	return createCachedComponent(
-		getExpanded,
-		(width, expanded) => {
-			const lines = [renderStatusLine({ iconOverride: ircGlyph(uiTheme), title, meta }, uiTheme)];
-			if (body.trim()) {
-				lines.push(...bodyLines(body, expanded, uiTheme, { indent: "  ", collapsedLines: 3 }));
-			}
-			return lines.map(line => truncateToWidth(line, width, Ellipsis.Unicode));
-		},
-		{ paddingX: 1 },
-	);
-}
-
-function renderSendResult(
-	result: { content: Array<{ type: string; text?: string }>; isError?: boolean },
-	details: Partial<IrcDetails>,
-	args: IrcRenderArgs | undefined,
-	expanded: boolean,
-	theme: Theme,
-): string[] {
-	const receipts = details.receipts ?? [];
-	const to = details.to ?? args?.to?.trim() ?? "?";
-	const title = `IRC ${theme.nav.selected} ${to}`;
-
-	// Pre-delivery failures (validation) and empty broadcasts carry no receipts.
-	if (receipts.length === 0) {
-		const text = textContent(result) || (result.isError ? "Send failed." : "Nothing to deliver.");
-		return [
-			renderStatusLine({ icon: result.isError ? "error" : "warning", title }, theme),
-			result.isError ? formatErrorDetail(text, theme) : `  ${theme.fg("muted", replaceTabs(text))}`,
-		];
-	}
-
-	const delivered = receipts.filter(receipt => receipt.outcome !== "failed");
-	const failedCount = receipts.length - delivered.length;
-	const waited = details.waited;
-	const timedOut = waited === null;
-
-	const meta: string[] = [];
-	if (to === "all") meta.push("broadcast");
-	if (receipts.length === 1) {
-		const receipt = receipts[0]!;
-		meta.push(theme.fg(outcomeColor(receipt.outcome), receipt.outcome));
-	} else {
-		if (delivered.length > 0) meta.push(theme.fg("success", `${delivered.length} delivered`));
-		if (failedCount > 0) meta.push(theme.fg("error", `${failedCount} failed`));
-	}
-	if (timedOut) meta.push(theme.fg("warning", "no reply"));
-
-	const icon = result.isError
-		? { icon: "error" as const }
-		: timedOut
-			? { icon: "warning" as const }
-			: { iconOverride: ircGlyph(theme) };
-	const lines = [renderStatusLine({ ...icon, title, meta }, theme)];
-
-	const sent = args?.message?.trim();
-	if (sent) lines.push(...bodyLines(sent, expanded, theme, { indent: "  ", tone: "dim" }));
-
-	if (receipts.length > 1 || failedCount > 0) {
-		lines.push(
-			...renderTreeList<IrcDeliveryReceipt>(
-				{
-					items: receipts,
-					expanded,
-					maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
-					itemType: "recipient",
-					renderItem: receipt => {
-						const badge = formatBadge(receipt.outcome, outcomeColor(receipt.outcome), theme);
-						const error =
-							receipt.outcome === "failed" && receipt.error
-								? ` ${theme.fg("error", `${theme.format.dash} ${receipt.error}`)}`
-								: "";
-						return `${theme.fg("toolOutput", receipt.to)} ${badge}${error}`;
-					},
-				},
-				theme,
-			),
-		);
-	}
-
-	if (waited) {
-		const age = messageAge(waited.ts);
-		lines.push(
-			`  ${theme.fg("dim", theme.nav.back)} ${theme.fg("accent", waited.from)}${age ? ` ${theme.fg("dim", age)}` : ""}`,
-		);
-		lines.push(...bodyLines(waited.body, expanded, theme, { indent: "  " }));
-	} else if (timedOut) {
-		lines.push(`  ${theme.fg("warning", "No reply yet — they may answer later; check inbox or wait again.")}`);
-	}
-	return lines;
-}
-
-function renderWaitResult(
-	result: { content: Array<{ type: string; text?: string }>; isError?: boolean },
-	details: Partial<IrcDetails>,
-	args: IrcRenderArgs | undefined,
-	expanded: boolean,
-	theme: Theme,
-): string[] {
-	const waited = details.waited;
-	if (!waited) {
-		const text = textContent(result) || "No message arrived.";
-		return [
-			renderStatusLine(
-				{ icon: "warning", title: `IRC ${theme.nav.back} ${args?.from?.trim() || "anyone"}`, meta: ["timed out"] },
-				theme,
-			),
-			`  ${theme.fg("muted", replaceTabs(text))}`,
-		];
-	}
-	const meta = [messageAge(waited.ts)];
-	if (waited.replyTo) meta.push("reply");
-	return [
-		renderStatusLine({ iconOverride: ircGlyph(theme), title: `IRC ${theme.nav.back} ${waited.from}`, meta }, theme),
-		...bodyLines(waited.body, expanded, theme, { indent: "  " }),
-	];
-}
-
-function renderInboxResult(
-	details: Partial<IrcDetails>,
-	args: IrcRenderArgs | undefined,
-	expanded: boolean,
-	theme: Theme,
-): string[] {
-	const messages = details.inbox ?? [];
-	if (messages.length === 0) {
-		return [renderStatusLine({ iconOverride: ircGlyph(theme), title: "IRC inbox", meta: ["empty"] }, theme)];
-	}
-	const meta = [`${messages.length} ${messages.length === 1 ? "message" : "messages"}`];
-	if (args?.peek) meta.push("peek");
-	const header = renderStatusLine({ iconOverride: ircGlyph(theme), title: "IRC inbox", meta }, theme);
-	const items = renderTreeList<IrcMessage>(
-		{
-			items: messages,
-			expanded,
-			maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
-			itemType: "message",
-			renderItem: msg => {
-				const age = messageAge(msg.ts);
-				const replyBadge = msg.replyTo ? ` ${formatBadge("reply", "muted", theme)}` : "";
-				const head = `${theme.fg("accent", msg.from)}${age ? ` ${theme.fg("dim", age)}` : ""}${replyBadge}`;
-				return [head, ...bodyLines(msg.body, expanded, theme, { collapsedLines: 1 })];
-			},
-		},
-		theme,
-	);
-	return [header, ...items];
-}
-
-function renderListResult(details: Partial<IrcDetails>, expanded: boolean, theme: Theme): string[] {
-	const peers = [...(details.peers ?? [])].sort(
-		(a, b) =>
-			(PEER_STATUS_ORDER[a.status] ?? 9) - (PEER_STATUS_ORDER[b.status] ?? 9) || b.lastActivity - a.lastActivity,
-	);
-	if (peers.length === 0) {
-		return [renderStatusLine({ icon: "info", title: "IRC peers", meta: ["no other agents"] }, theme)];
-	}
-	const counts = new Map<string, number>();
-	for (const peer of peers) counts.set(peer.status, (counts.get(peer.status) ?? 0) + 1);
-	const meta = [...counts].map(([status, count]) => `${count} ${status}`);
-	const unreadTotal = peers.reduce((sum, peer) => sum + peer.unread, 0);
-	if (unreadTotal > 0) meta.push(theme.fg("warning", `${unreadTotal} unread`));
-	const header = renderStatusLine({ iconOverride: ircGlyph(theme), title: "IRC peers", meta }, theme);
-	const items = renderTreeList(
-		{
-			items: peers,
-			expanded,
-			maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
-			itemType: "peer",
-			renderItem: peer => {
-				const kindText = peer.parentId ? `${peer.kind}${theme.sep.dot}of ${peer.parentId}` : peer.kind;
-				const unread = peer.unread > 0 ? ` ${formatBadge(`${peer.unread} unread`, "warning", theme)}` : "";
-				const age = messageAge(peer.lastActivity);
-				const activity = peer.activity ? ` ${theme.fg("dim", replaceTabs(peer.activity))}` : "";
-				const name = theme.fg("dim", replaceTabs(peer.displayName));
-				return `${peerStatusBadge(peer.status, theme)} ${theme.bold(replaceTabs(peer.id))} ${name} ${theme.fg("dim", kindText)}${activity}${unread}${age ? ` ${theme.fg("dim", age)}` : ""}`;
-			},
-		},
-		theme,
-	);
-	return [header, ...items];
-}
-
-function buildResultLines(
-	result: { content: Array<{ type: string; text?: string }>; isError?: boolean },
-	details: Partial<IrcDetails>,
-	args: IrcRenderArgs | undefined,
-	expanded: boolean,
-	theme: Theme,
-): string[] {
-	switch (details.op ?? args?.op) {
-		case "send":
-			return renderSendResult(result, details, args, expanded, theme);
-		case "wait":
-			return renderWaitResult(result, details, args, expanded, theme);
-		case "inbox":
-			return result.isError
-				? renderErrorResult(result, args, theme)
-				: renderInboxResult(details, args, expanded, theme);
-		case "list":
-			return result.isError ? renderErrorResult(result, args, theme) : renderListResult(details, expanded, theme);
-		default: {
-			const text = textContent(result) || (result.isError ? "IRC call failed." : "Done.");
-			return [
-				renderStatusLine({ icon: result.isError ? "error" : "success", title: callTitle(args, theme) }, theme),
-				result.isError ? formatErrorDetail(text, theme) : `  ${theme.fg("muted", replaceTabs(text))}`,
-			];
-		}
-	}
-}
-
-export const ircToolRenderer = {
-	inline: true,
-	mergeCallAndResult: true,
-
-	renderCall(args: IrcRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const lines = [
-			renderStatusLine({ icon: "pending", title: callTitle(args, uiTheme), meta: callMeta(args) }, uiTheme),
-		];
-		if (args?.op === "send" && args.message?.trim()) {
-			lines.push(...bodyLines(args.message, false, uiTheme, { indent: "  ", tone: "dim", collapsedLines: 1 }));
-		}
-		return new Text(lines.join("\n"), 0, 0);
-	},
-
-	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: IrcDetails; isError?: boolean },
-		options: RenderResultOptions,
-		uiTheme: Theme,
-		args?: IrcRenderArgs,
-	): Component {
-		const details: Partial<IrcDetails> = result.details ?? {};
-		return createCachedComponent(
-			() => options.expanded,
-			(width, expanded) =>
-				buildResultLines(result, details, args, expanded, uiTheme).map(line =>
-					truncateToWidth(line, width, Ellipsis.Unicode),
-				),
-		);
-	},
-};
diff --git a/packages/coding-agent/src/tools/job.ts b/packages/coding-agent/src/tools/job.ts
deleted file mode 100644
index 360cbf908..000000000
--- a/packages/coding-agent/src/tools/job.ts
+++ /dev/null
@@ -1,752 +0,0 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import type { Component } from "@oh-my-pi/pi-tui";
-import { Text } from "@oh-my-pi/pi-tui";
-import { prompt } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
-import type { AsyncJob, AsyncJobManager } from "../async";
-import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { shimmerEnabled, shimmerText } from "../modes/theme/shimmer";
-import type { Theme } from "../modes/theme/theme";
-import jobDescription from "../prompts/tools/job.md" with { type: "text" };
-import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
-import type { ToolSession } from "./index";
-import {
-	formatBadge,
-	formatDuration,
-	formatEmptyMessage,
-	formatStatusIcon,
-	getPreviewLines,
-	PREVIEW_LIMITS,
-	replaceTabs,
-	type ToolUIColor,
-	type ToolUIStatus,
-} from "./render-utils";
-import { ToolError } from "./tool-errors";
-
-const jobSchema = type({
-	"poll?": type("string[]").describe("job ids to wait for; omit to wait on all running jobs"),
-	"cancel?": type("string[]").describe("job ids to cancel"),
-	"list?": type("boolean").describe("snapshot all jobs"),
-});
-
-type JobParams = typeof jobSchema.infer;
-
-const WAIT_DURATION_MS: Record<string, number> = {
-	"5s": 5_000,
-	"10s": 10_000,
-	"30s": 30_000,
-	"1m": 60_000,
-	"5m": 5 * 60_000,
-};
-
-function parseWaitDurationMs(value: string | undefined): number {
-	return (value ? WAIT_DURATION_MS[value] : undefined) ?? WAIT_DURATION_MS["30s"];
-}
-
-interface JobSnapshot {
-	id: string;
-	type: "bash" | "task";
-	status: "running" | "completed" | "failed" | "cancelled";
-	label: string;
-	durationMs: number;
-	resultText?: string;
-	errorText?: string;
-}
-
-type CancelStatus = "cancelled" | "not_found" | "already_completed";
-
-interface CancelOutcome {
-	id: string;
-	status: CancelStatus;
-	message: string;
-}
-
-/**
- * A live subagent from the AgentRegistry that has no backing job in the
- * AsyncJobManager — e.g. an idle agent woken (or a parked agent revived) via
- * `irc`, or a spawn owned by another agent. Surfaced by `list` and empty-poll
- * snapshots so the job tool's picture matches the UI's running-agent count.
- */
-interface AgentActivitySnapshot {
-	id: string;
-	parentId?: string;
-	/** Latest activity gist recorded by the registry (display-only). */
-	activity?: string;
-	/** Time since the agent was registered. */
-	ageMs: number;
-}
-
-export interface JobToolDetails {
-	jobs: JobSnapshot[];
-	cancelled?: { id: string; status: CancelStatus }[];
-	/** Running subagents not represented by a job row in this result. */
-	agents?: AgentActivitySnapshot[];
-}
-
-/**
- * A poll snapshot where every watched job is still running and nothing was
- * cancelled — pure "still waiting" noise once a newer poll exists. The TUI
- * keeps such a block un-finalized (displaceable) so a follow-up `job` call
- * replaces it instead of stacking another waiting frame in the transcript.
- */
-export function isWaitingPollDetails(details: unknown): boolean {
-	const d = details as JobToolDetails | undefined;
-	if (!d || !Array.isArray(d.jobs) || d.jobs.length === 0) return false;
-	if (d.cancelled?.length) return false;
-	return d.jobs.every(job => job?.status === "running");
-}
-
-export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
-	readonly name = "job";
-	readonly approval = "read" as const;
-	readonly label = "Job";
-	readonly summary = "Manage long-running background jobs (async bash/python)";
-	readonly description: string;
-	readonly parameters = jobSchema;
-	readonly strict = true;
-	readonly interruptible = true;
-	readonly loadMode = "discoverable";
-	constructor(private readonly session: ToolSession) {
-		this.description = prompt.render(jobDescription);
-	}
-
-	async execute(
-		_toolCallId: string,
-		params: JobParams,
-		signal?: AbortSignal,
-		onUpdate?: AgentToolUpdateCallback<JobToolDetails>,
-		_context?: AgentToolContext,
-	): Promise<AgentToolResult<JobToolDetails>> {
-		const manager = this.session.asyncJobManager;
-		if (!manager) {
-			return {
-				content: [{ type: "text", text: "Async execution is disabled; no background jobs are available." }],
-				details: { jobs: [] },
-			};
-		}
-
-		// Scope every visible operation to the calling agent. Tests / SDK
-		// consumers without an agent id see everything (legacy behavior).
-		const ownerId = this.session.getAgentId?.() ?? undefined;
-		const ownerFilter = ownerId ? { ownerId } : undefined;
-
-		// `list` is a read-only snapshot mode. Replaces the legacy `jobs://` URL.
-		if (params.list) {
-			if (params.cancel?.length || params.poll?.length) {
-				throw new ToolError("`list` cannot be combined with `poll` or `cancel`.");
-			}
-			const jobs = manager.getAllJobs(ownerFilter);
-			const agents = this.#runningAgentsOutsideJobs();
-			return this.#buildResult(manager, jobs, [], agents);
-		}
-
-		const cancelIds = params.cancel ?? [];
-		const cancelOutcomes: CancelOutcome[] = [];
-		for (const id of cancelIds) {
-			const existing = manager.getJob(id);
-			if (!existing || (ownerId && existing.ownerId !== ownerId)) {
-				cancelOutcomes.push({ id, status: "not_found", message: `Background job not found: ${id}` });
-				continue;
-			}
-			if (existing.status !== "running") {
-				cancelOutcomes.push({
-					id,
-					status: "already_completed",
-					message: `Background job ${id} is already ${existing.status}.`,
-				});
-				continue;
-			}
-			const cancelled = manager.cancel(id, ownerFilter);
-			cancelOutcomes.push(
-				cancelled
-					? { id, status: "cancelled", message: `Cancelled background job ${id}.` }
-					: { id, status: "already_completed", message: `Background job ${id} is already completed.` },
-			);
-		}
-
-		const requestedPollIds = params.poll;
-		// If only `cancel` was provided (no `poll`), don't wait \u2014 return immediately.
-		const shouldPoll = requestedPollIds !== undefined || cancelIds.length === 0;
-
-		if (!shouldPoll) {
-			const cancelledJobs = this.#visibleJobs(manager, cancelIds, ownerId);
-			return this.#buildResult(manager, cancelledJobs, cancelOutcomes);
-		}
-
-		// Resolve which jobs to watch.
-		// - If `poll` was passed explicitly, watch exactly those (filtered to existing).
-		// - If `poll` was omitted (and so was `cancel`), default to all running jobs.
-		const jobsToWatch = requestedPollIds
-			? this.#visibleJobs(manager, requestedPollIds, ownerId)
-			: manager.getRunningJobs(ownerFilter);
-
-		if (jobsToWatch.length === 0) {
-			if (cancelOutcomes.length > 0) {
-				const cancelledJobs = this.#visibleJobs(manager, cancelIds, ownerId);
-				return this.#buildResult(manager, cancelledJobs, cancelOutcomes);
-			}
-			// Zero pollable jobs is not necessarily "nothing running": agents
-			// woken via irc or owned by another agent run with no job entry.
-			// Report them so the snapshot matches the UI's running-agent count
-			// (task job ids are agent ids, so a stale poll id often names one).
-			const agents = this.#runningAgentsOutsideJobs();
-			const lines: string[] = [];
-			if (requestedPollIds?.length) {
-				lines.push(`No matching jobs found for IDs: ${requestedPollIds.join(", ")}`);
-				const registry = this.session.agentRegistry;
-				for (const id of requestedPollIds) {
-					const ref = registry?.get(id);
-					if (!ref) continue;
-					lines.push(
-						ref.status === "running"
-							? `- \`${id}\` is a running agent with no job entry — coordinate via \`irc\`; transcript at history://${id}`
-							: `- \`${id}\` is a ${ref.status} agent (its job is gone) — transcript at history://${id}`,
-					);
-				}
-			} else {
-				lines.push("No running background jobs to wait for.");
-			}
-			if (agents.length > 0) {
-				lines.push("", ...this.#describeAgents(agents));
-			}
-			return {
-				content: [{ type: "text", text: lines.join("\n") }],
-				details: { jobs: [], ...(agents.length ? { agents } : {}) },
-				// Nothing found / nothing to wait for is noise once consumed —
-				// the follow-up call has already corrected course. Running agents
-				// are real state the model may act on, so keep those results.
-				...(agents.length === 0 ? { useless: true } : {}),
-			};
-		}
-
-		// If all watched jobs are already done, build immediate result.
-		const runningJobs = jobsToWatch.filter(j => j.status === "running");
-		if (runningJobs.length === 0) {
-			const cancelledJobs = cancelIds.map(id => manager.getJob(id)).filter(j => j != null);
-			return this.#buildResult(manager, [...cancelledJobs, ...jobsToWatch], cancelOutcomes);
-		}
-
-		// Wait until at least one running job finishes, the wait window elapses,
-		// or the call is aborted. With `async.pollWaitDuration` set to `smart`,
-		// the window adapts: it starts at the ladder floor and climbs as the agent
-		// polls in a tight loop, then resets to the floor once the agent steps
-		// away from polling (see AsyncJobManager.nextPollWaitMs). Any fixed value
-		// waits that exact duration every time.
-		const racePromises: Promise<unknown>[] = runningJobs.map(j => j.promise);
-		const pollSetting = this.session.settings.get("async.pollWaitDuration");
-		const smartPoll = pollSetting === "smart";
-		const waitMs = smartPoll ? manager.nextPollWaitMs(ownerId) : parseWaitDurationMs(pollSetting);
-		const { promise: timeoutPromise, resolve: timeoutResolve } = Promise.withResolvers<void>();
-		const timeoutHandle = setTimeout(() => timeoutResolve(), waitMs);
-		racePromises.push(timeoutPromise);
-
-		const watchedJobIds = runningJobs.map(job => job.id);
-		manager.watchJobs(watchedJobIds);
-
-		const cancelledJobs = this.#visibleJobs(manager, cancelIds, ownerId);
-		const allTrackedJobs = [...cancelledJobs, ...jobsToWatch];
-
-		const PROGRESS_INTERVAL_MS = 500;
-		const emitProgress = () => {
-			if (!onUpdate) return;
-			const snapshot = this.#snapshotJobs(allTrackedJobs);
-			onUpdate({
-				content: [{ type: "text", text: "" }],
-				details: {
-					jobs: snapshot,
-					...(cancelOutcomes.length
-						? { cancelled: cancelOutcomes.map(({ id, status }) => ({ id, status })) }
-						: {}),
-				},
-			});
-		};
-		const progressTimer = onUpdate ? setInterval(emitProgress, PROGRESS_INTERVAL_MS) : undefined;
-		emitProgress();
-
-		try {
-			if (signal) {
-				const { promise: abortPromise, resolve: abortResolve } = Promise.withResolvers<void>();
-				const onAbort = () => abortResolve();
-				signal.addEventListener("abort", onAbort, { once: true });
-				racePromises.push(abortPromise);
-				try {
-					await Promise.race(racePromises);
-				} finally {
-					signal.removeEventListener("abort", onAbort);
-				}
-			} else {
-				await Promise.race(racePromises);
-			}
-		} finally {
-			manager.unwatchJobs(watchedJobIds);
-			clearTimeout(timeoutHandle);
-			if (progressTimer) clearInterval(progressTimer);
-			if (smartPoll) {
-				// Reset the idle-gap clock: escalate if the agent polls again soon,
-				// drop back to the floor once it goes quiet for a while.
-				manager.recordPollWaitEnd(ownerId);
-			}
-		}
-
-		return this.#buildResult(manager, allTrackedJobs, cancelOutcomes);
-	}
-
-	/**
-	 * Resolve a list of job ids to job records visible to the calling agent.
-	 * Drops missing ids and ids owned by other agents, so cross-agent inspection
-	 * via the `job` tool is impossible.
-	 */
-	#visibleJobs(manager: AsyncJobManager, ids: string[], ownerId: string | undefined): AsyncJob[] {
-		const out: AsyncJob[] = [];
-		for (const id of ids) {
-			const job = manager.getJob(id);
-			if (!job) continue;
-			if (ownerId && job.ownerId !== ownerId) continue;
-			out.push(job);
-		}
-		return out;
-	}
-
-	/**
-	 * Running subagents from the registry that are not covered by one of the
-	 * caller's running jobs. Agents woken via `irc` (idle wake / park revival)
-	 * and spawns owned by another agent run with no AsyncJobManager entry, yet
-	 * the UI's agent badge counts them — a snapshot must account for that
-	 * activity instead of implying the system is quiet. Existence is already
-	 * public via the `irc` roster, so listing ids here leaks nothing new; job
-	 * *control* stays owner-scoped.
-	 */
-	#runningAgentsOutsideJobs(): AgentActivitySnapshot[] {
-		const registry = this.session.agentRegistry;
-		if (!registry) return [];
-		const selfId = this.session.getAgentId?.() ?? undefined;
-		// Cover = the caller's RUNNING jobs only. A settled job still sitting in
-		// delivery retention must not hide its agent if that agent was re-woken
-		// (e.g. via irc) and is running again without a job.
-		const covered = new Set<string>();
-		const manager = this.session.asyncJobManager;
-		if (manager) {
-			for (const job of manager.getRunningJobs(selfId ? { ownerId: selfId } : undefined)) {
-				covered.add(job.id);
-				if (job.agentId) covered.add(job.agentId);
-			}
-		}
-		const now = Date.now();
-		const out: AgentActivitySnapshot[] = [];
-		for (const ref of registry.list()) {
-			if (ref.kind !== "sub" || ref.status !== "running") continue;
-			if (ref.id === selfId || covered.has(ref.id)) continue;
-			out.push({
-				id: ref.id,
-				...(ref.parentId ? { parentId: ref.parentId } : {}),
-				...(ref.activity ? { activity: ref.activity } : {}),
-				ageMs: Math.max(0, now - ref.createdAt),
-			});
-		}
-		return out;
-	}
-
-	/** Model-facing lines for the running-agents section shared by `list` and empty-poll results. */
-	#describeAgents(agents: AgentActivitySnapshot[]): string[] {
-		const lines = [`## Running Agents (${agents.length}) — not job-backed\n`];
-		for (const agent of agents) {
-			const parent = agent.parentId ? ` (spawned by \`${agent.parentId}\`)` : "";
-			const activity = agent.activity ? ` — ${agent.activity}` : "";
-			lines.push(`- \`${agent.id}\`${parent} — up ${formatDuration(agent.ageMs)}${activity}`);
-		}
-		lines.push("", "These agents have no job entry; coordinate via `irc`, transcripts at `history://<id>`.");
-		return lines;
-	}
-
-	#snapshotJobs(
-		jobs: {
-			id: string;
-			type: "bash" | "task";
-			status: string;
-			label: string;
-			startTime: number;
-			resultText?: string;
-			errorText?: string;
-		}[],
-	): JobSnapshot[] {
-		const now = Date.now();
-		return jobs.map(j => {
-			const current = this.session.asyncJobManager?.getJob(j.id);
-			const latest = current ?? j;
-			return {
-				id: latest.id,
-				type: latest.type,
-				status: latest.status as JobSnapshot["status"],
-				label: latest.label,
-				durationMs: Math.max(0, now - latest.startTime),
-				...(latest.resultText ? { resultText: latest.resultText } : {}),
-				...(latest.errorText ? { errorText: latest.errorText } : {}),
-			};
-		});
-	}
-
-	#buildResult(
-		manager: AsyncJobManager,
-		jobs: {
-			id: string;
-			type: "bash" | "task";
-			status: string;
-			label: string;
-			startTime: number;
-			resultText?: string;
-			errorText?: string;
-		}[],
-		cancelOutcomes: CancelOutcome[],
-		agents: AgentActivitySnapshot[] = [],
-	): AgentToolResult<JobToolDetails> {
-		// Deduplicate by id (cancelled jobs may also appear in the watched set).
-		const seen = new Set<string>();
-		const uniqueJobs = jobs.filter(j => {
-			if (seen.has(j.id)) return false;
-			seen.add(j.id);
-			return true;
-		});
-		const jobResults = this.#snapshotJobs(uniqueJobs);
-
-		manager.acknowledgeDeliveries(jobResults.filter(j => j.status !== "running").map(j => j.id));
-
-		const completed = jobResults.filter(j => j.status !== "running");
-		const running = jobResults.filter(j => j.status === "running");
-
-		const lines: string[] = [];
-
-		if (cancelOutcomes.length > 0) {
-			lines.push(`## Cancelled (${cancelOutcomes.length})\n`);
-			for (const o of cancelOutcomes) lines.push(`- ${o.message}`);
-			lines.push("");
-		}
-
-		if (completed.length > 0) {
-			lines.push(`## Completed (${completed.length})\n`);
-			for (const j of completed) {
-				lines.push(`### ${j.id} [${j.type}] — ${j.status}`);
-				lines.push(`Label: ${j.label}`);
-				if (j.resultText) {
-					lines.push("```", j.resultText, "```");
-				}
-				if (j.errorText) {
-					lines.push(`Error: ${j.errorText}`);
-				}
-				lines.push("");
-			}
-		}
-
-		if (running.length > 0) {
-			lines.push(`## Still Running (${running.length})\n`);
-			for (const j of running) {
-				lines.push(`- \`${j.id}\` [${j.type}] — ${j.label}`);
-			}
-		}
-
-		if (agents.length > 0) {
-			if (lines.length > 0) lines.push("");
-			lines.push(...this.#describeAgents(agents));
-		}
-
-		// A tool result must never be empty text — the model cannot tell "no
-		// jobs" from a malfunction (reported exactly that way in QA).
-		if (lines.length === 0) {
-			lines.push("No background jobs.");
-		}
-
-		const details: JobToolDetails = {
-			jobs: jobResults,
-			...(cancelOutcomes.length ? { cancelled: cancelOutcomes.map(({ id, status }) => ({ id, status })) } : {}),
-			...(agents.length ? { agents } : {}),
-		};
-		return {
-			content: [{ type: "text", text: lines.join("\n").trimEnd() }],
-			details,
-			// A poll where everything is still running carries no new information
-			// once a later poll exists — same predicate the TUI uses to displace
-			// stale waiting frames.
-			...(isWaitingPollDetails(details) ? { useless: true } : {}),
-		};
-	}
-}
-
-// =============================================================================
-// TUI Renderer
-// =============================================================================
-
-interface JobRenderArgs {
-	poll?: string[];
-	cancel?: string[];
-	list?: boolean;
-}
-
-const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
-const LABEL_MAX_WIDTH = 60;
-const PREVIEW_LINES_COLLAPSED = 1;
-const PREVIEW_LINES_EXPANDED = 4;
-const LABEL_LINES_COLLAPSED = 1;
-const LABEL_LINES_EXPANDED = 3;
-const PREVIEW_LINE_WIDTH = 80;
-
-function statusToIcon(status: JobSnapshot["status"]): ToolUIStatus {
-	switch (status) {
-		case "completed":
-			return "done";
-		case "failed":
-			return "error";
-		case "cancelled":
-			return "aborted";
-		case "running":
-			return "running";
-	}
-}
-
-function statusToColor(status: JobSnapshot["status"]): ToolUIColor {
-	switch (status) {
-		case "completed":
-			return "success";
-		case "failed":
-			return "error";
-		case "cancelled":
-			return "warning";
-		case "running":
-			return "accent";
-	}
-}
-
-/**
- * Task job results are delivered in the model-facing `<task-result>` envelope
- * (prompts/tools/task-summary.md) so the parent agent can parse status and the
- * `agent://` pointer. The wrapper markup is noise to a human — preview the
- * inner <output>/<preview> body instead.
- */
-function stripTaskResultEnvelope(text: string): string {
-	if (!text.startsWith("<task-result")) return text;
-	const body = /<(output|preview)(?:\s[^>]*)?>\n?([\s\S]*?)\n?<\/\1>/.exec(text)?.[2];
-	return body?.trim() || text;
-}
-
-/**
- * Pretty-printed JSON output wastes the collapsed one-line preview on a lone
- * "{" — flatten structured-looking bodies onto a single line. Slice first:
- * downstream truncation keeps at most a few hundred columns, so collapsing
- * whitespace across a multi-KB body would be pure waste.
- */
-function flattenStructuredPreview(text: string): string {
-	const first = text[0];
-	if (first !== "{" && first !== "[") return text;
-	return text.slice(0, PREVIEW_LINES_EXPANDED * PREVIEW_LINE_WIDTH * 2).replace(/\s+/g, " ");
-}
-
-function describeTarget(args: JobRenderArgs | undefined): string {
-	if (args?.list) return "background jobs";
-	const poll = args?.poll ?? [];
-	const cancel = args?.cancel ?? [];
-	const parts: string[] = [];
-	if (cancel.length > 0) {
-		parts.push(cancel.length === 1 ? `cancel ${cancel[0]}` : `cancel ${cancel.length} jobs`);
-	}
-	if (poll.length > 0) {
-		parts.push(poll.length === 1 ? `poll ${poll[0]}` : `poll ${poll.length} jobs`);
-	}
-	if (parts.length === 0) return "all running jobs";
-	return parts.join(", ");
-}
-
-export const jobToolRenderer = {
-	inline: true,
-
-	renderCall(args: JobRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const text = renderStatusLine({ icon: "pending", title: describeTarget(args) || "Job" }, uiTheme);
-		return new Text(text, 0, 0);
-	},
-
-	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: JobToolDetails; isError?: boolean },
-		options: RenderResultOptions,
-		uiTheme: Theme,
-		args?: JobRenderArgs,
-	): Component {
-		let jobs = result.details?.jobs ?? [];
-		const agents = result.details?.agents ?? [];
-
-		if (jobs.length === 0 && agents.length === 0) {
-			const fallback = result.content?.find(c => c.type === "text")?.text || "No jobs to process";
-			const header = renderStatusLine({ icon: "warning", title: describeTarget(args) || "Job" }, uiTheme);
-			return new Text([header, formatEmptyMessage(fallback, uiTheme)].join("\n"), 0, 0);
-		}
-
-		const isPollCall = args
-			? !args.list && (!args.cancel || args.cancel.length === 0 || args.poll !== undefined)
-			: true;
-
-		// Agent-carrying results (list / empty-poll roster) are real snapshots,
-		// not displaceable waiting frames — only agentless polls collapse their
-		// still-running rows once sealed.
-		if (!options.isPartial && isPollCall && agents.length === 0) {
-			jobs = jobs.filter(job => job.status !== "running");
-			if (jobs.length === 0) {
-				return new Text("", 0, 0);
-			}
-		}
-
-		const counts = { completed: 0, failed: 0, cancelled: 0, running: 0 };
-		for (const job of jobs) counts[job.status]++;
-
-		// The title already carries the running count, so meta lists only the
-		// settled categories — "waiting on 19 of 19 · 19 running" read awkward.
-		const meta: string[] = [];
-		if (counts.completed > 0) meta.push(uiTheme.fg("success", `${counts.completed} done`));
-		if (counts.failed > 0) meta.push(uiTheme.fg("error", `${counts.failed} failed`));
-		if (counts.cancelled > 0) meta.push(uiTheme.fg("warning", `${counts.cancelled} cancelled`));
-		if (agents.length > 0 && jobs.length > 0) {
-			meta.push(uiTheme.fg("accent", `${agents.length} agent${agents.length === 1 ? "" : "s"}`));
-		}
-
-		const headerIcon: ToolUIStatus =
-			counts.failed > 0 ? "warning" : counts.running > 0 || agents.length > 0 ? "info" : "success";
-		const jobsNoun = jobs.length === 1 ? "job" : "jobs";
-		const description =
-			jobs.length === 0
-				? `${agents.length} running agent${agents.length === 1 ? "" : "s"} — no jobs`
-				: counts.running > 0
-					? counts.running === jobs.length
-						? `waiting on ${jobs.length} ${jobsNoun}`
-						: `waiting on ${counts.running} of ${jobs.length} ${jobsNoun}`
-					: `${jobs.length} ${jobsNoun} settled`;
-
-		const header = renderStatusLine(
-			{
-				icon: headerIcon,
-				spinnerFrame: counts.running > 0 || agents.length > 0 ? options.spinnerFrame : undefined,
-				title: description,
-				meta,
-			},
-			uiTheme,
-		);
-
-		// Sort: running first (so user sees what's still pending), then failed, then completed/cancelled.
-		const statusOrder: Record<JobSnapshot["status"], number> = {
-			running: 0,
-			failed: 1,
-			cancelled: 2,
-			completed: 3,
-		};
-		const sortedJobs = [...jobs].sort((a, b) => {
-			const diff = statusOrder[a.status] - statusOrder[b.status];
-			if (diff !== 0) return diff;
-			return b.durationMs - a.durationMs;
-		});
-
-		let cached: RenderCache | undefined;
-		return {
-			render(width: number): readonly string[] {
-				const expanded = options.expanded;
-				const spinnerFrame = options.spinnerFrame ?? 0;
-				// Running-job labels shimmer while the poll block is live; the band
-				// phase is Date.now()-sampled at render time, so serving cached bytes
-				// would pin it to the ~12.5fps spinner-glyph cadence instead of the
-				// 30fps redraw. Bypass the cache while any row animates, and key on
-				// the animation state so a sealed block never hits stale shimmered
-				// bytes (spinnerFrame falls back to 0 on both sides of the seal).
-				const shimmerActive = counts.running > 0 && options.spinnerFrame !== undefined && shimmerEnabled();
-				const key = new Hasher().bool(expanded).u32(width).u32(spinnerFrame).bool(shimmerActive).digest();
-				if (!shimmerActive && cached?.key === key) return cached.lines;
-
-				const itemLines = renderTreeList<JobSnapshot>(
-					{
-						items: sortedJobs,
-						expanded,
-						maxCollapsed: COLLAPSED_LIST_LIMIT,
-						itemType: "job",
-						renderItem: job => {
-							const lines: string[] = [];
-							const icon = formatStatusIcon(
-								statusToIcon(job.status),
-								uiTheme,
-								job.status === "running" ? options.spinnerFrame : undefined,
-							);
-							const typeBadge = formatBadge(job.type, statusToColor(job.status), uiTheme);
-							// Task jobs label themselves with their agent id, which is also
-							// the job id — drop the id column instead of stuttering it twice.
-							const idPart = job.label.trim() === job.id ? "" : ` ${uiTheme.fg("muted", job.id)}`;
-							const rawLabelLines = (job.label || "(no label)").split(/\r?\n/);
-							const maxLabelLines = expanded ? LABEL_LINES_EXPANDED : LABEL_LINES_COLLAPSED;
-							const visibleLabelLines = rawLabelLines
-								.slice(0, maxLabelLines)
-								.map(l => truncateToWidth(replaceTabs(l), LABEL_MAX_WIDTH, Ellipsis.Unicode));
-							if (rawLabelLines.length > maxLabelLines && visibleLabelLines.length > 0) {
-								const last = visibleLabelLines[visibleLabelLines.length - 1]!;
-								visibleLabelLines[visibleLabelLines.length - 1] = `${last} …`;
-							}
-							const durationText = uiTheme.fg("dim", formatDuration(job.durationMs));
-							// Running rows in a live block shimmer their label; once the block
-							// stops animating (sealed, or a settled snapshot — spinnerFrame
-							// cleared) they render static so scrollback never keeps a mid-sweep
-							// shimmer band.
-							const live = job.status === "running" && options.spinnerFrame !== undefined;
-							const headRaw = visibleLabelLines[0] ?? "";
-							const headLabel = live
-								? shimmerEnabled()
-									? shimmerText(headRaw, uiTheme)
-									: uiTheme.fg("accent", headRaw)
-								: uiTheme.fg("toolOutput", headRaw);
-							lines.push(`${icon}${idPart} ${typeBadge} ${headLabel} ${durationText}`);
-							for (let i = 1; i < visibleLabelLines.length; i++) {
-								lines.push(`  ${uiTheme.fg("toolOutput", visibleLabelLines[i]!)}`);
-							}
-
-							const preview = flattenStructuredPreview(
-								stripTaskResultEnvelope(job.errorText?.trim() || job.resultText?.trim() || ""),
-							);
-							if (preview) {
-								const maxLines = expanded ? PREVIEW_LINES_EXPANDED : PREVIEW_LINES_COLLAPSED;
-								const previewLines = getPreviewLines(preview, maxLines, PREVIEW_LINE_WIDTH, Ellipsis.Unicode);
-								const tone = job.errorText ? "error" : "dim";
-								for (const pl of previewLines) {
-									lines.push(`  ${uiTheme.fg(tone, pl)}`);
-								}
-							}
-							return lines;
-						},
-					},
-					uiTheme,
-				);
-
-				// Agents run outside job control; render them as their own tree so
-				// they never skew the job counts or the "waiting on N jobs" title.
-				const agentLines =
-					agents.length === 0
-						? []
-						: renderTreeList<AgentActivitySnapshot>(
-								{
-									items: agents,
-									expanded,
-									maxCollapsed: COLLAPSED_LIST_LIMIT,
-									itemType: "agent",
-									renderItem: agent => {
-										const icon = formatStatusIcon("running", uiTheme, options.spinnerFrame);
-										const badge = formatBadge("agent", "accent", uiTheme);
-										const gist = agent.activity
-											? ` ${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(agent.activity), LABEL_MAX_WIDTH, Ellipsis.Unicode))}`
-											: "";
-										const parent = agent.parentId ? uiTheme.fg("dim", ` ← ${agent.parentId}`) : "";
-										const age = uiTheme.fg("dim", formatDuration(agent.ageMs));
-										return [`${icon} ${uiTheme.fg("muted", agent.id)} ${badge}${gist} ${age}${parent}`];
-									},
-								},
-								uiTheme,
-							);
-
-				const all = [header, ...itemLines, ...agentLines].map(l => truncateToWidth(l, width, Ellipsis.Unicode));
-				cached = { key, lines: all };
-				return all;
-			},
-			invalidate() {
-				cached = undefined;
-			},
-		};
-	},
-
-	mergeCallAndResult: true,
-};
diff --git a/packages/coding-agent/src/tools/launch.ts b/packages/coding-agent/src/tools/launch.ts
deleted file mode 100644
index 2c68ae446..000000000
--- a/packages/coding-agent/src/tools/launch.ts
+++ /dev/null
@@ -1,643 +0,0 @@
-import type {
-	AgentTool,
-	AgentToolContext,
-	AgentToolResult,
-	AgentToolUpdateCallback,
-	ToolApprovalDecision,
-} from "@oh-my-pi/pi-agent-core";
-import type { ToolExample } from "@oh-my-pi/pi-ai";
-import type { Component } from "@oh-my-pi/pi-tui";
-import { Text } from "@oh-my-pi/pi-tui";
-import { prompt, sanitizeText } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
-import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { daemonClientForProject } from "../launch/client";
-import type { DaemonOperation, DaemonRpcResult, DaemonSnapshot, DaemonSpec, DaemonState } from "../launch/protocol";
-import { renderTerminalOutput } from "../launch/terminal-output";
-import type { Theme, ThemeColor } from "../modes/theme/theme";
-import launchDescription from "../prompts/tools/launch.md" with { type: "text" };
-import { framedBlock, outputBlockContentWidth, renderStatusLine } from "../tui";
-import type { ToolSession } from ".";
-import { resolveToCwd } from "./path-utils";
-import {
-	capPreviewLines,
-	createCachedComponent,
-	DEFAULT_TERMINAL_PREVIEW_LINES,
-	formatDuration,
-	formatExpandHint,
-	formatMoreItems,
-	PREVIEW_LIMITS,
-	pluralize,
-	previewLine,
-	replaceTabs,
-	shortenPath,
-	TRUNCATE_LENGTHS,
-	truncateToWidth,
-} from "./render-utils";
-import { styleTerminalRow } from "./terminal-output";
-import { ToolError } from "./tool-errors";
-
-const launchSchema = type({
-	op: type("'start' | 'list' | 'logs' | 'wait' | 'send' | 'stop' | 'restart' | 'describe'").describe(
-		"launch operation",
-	),
-	"name?": type("string <= 48").describe("stable project-scoped launch name"),
-	"application?": type("string > 0").describe("start: executable or application path"),
-	"args?": type("string[]").describe("start: argv passed directly to the application"),
-	"env?": type({ "[string]": "string" }).describe("start: extra environment variables"),
-	"cwd?": type("string").describe("start: working directory; defaults to the session directory"),
-	"pty?": type("boolean").describe("start: allocate an interactive PTY; default true"),
-	"ready?": type({
-		"log?": type("string > 0").describe("regex matched against output"),
-		"port?": type("number").describe("TCP port that must accept connections"),
-		"host?": type("string > 0").describe("TCP readiness host; default 127.0.0.1"),
-		"timeout?": type("number > 0").describe("seconds to wait; default 30"),
-	}).describe("start: readiness conditions; all supplied conditions must pass"),
-	"restart?": type("'no' | 'on-failure' | 'always'").describe("start: restart policy; default no"),
-	"persist?": type("boolean").describe("start: survive the last omp client exiting; default false"),
-	"detached?": type("boolean").describe(
-		"start: survive every omp and broker exit; implies persist and disables PTY input",
-	),
-	"lines?": type("number > 0").describe("logs: output lines; default 100, max 1000"),
-	"head?": type("boolean").describe("logs: read from the beginning instead of the tail"),
-	"grep?": type("string > 0").describe("logs: regex filter"),
-	"follow?": type("boolean").describe("logs: wait for output newer than cursor"),
-	"cursor?": type("number >= 0").describe("logs: output cursor returned by an earlier call"),
-	"for?": type("'ready' | 'exit'").describe("wait: lifecycle condition; default exit"),
-	"pattern?": type("string > 0").describe("wait: output regex; takes precedence over for"),
-	"text?": type("string > 0").describe("send: stdin text"),
-	"enter?": type("boolean").describe("send: append Enter after text; default true"),
-	"keys?": type("string[]").describe("send: terminal keys after text"),
-	"signal?": type("'SIGINT' | 'SIGTERM' | 'SIGHUP' | 'SIGQUIT' | 'SIGKILL'").describe("send: process-tree signal"),
-	"timeout?": type("number > 0").describe("logs/wait/stop: max seconds; default 30 (stop: 5)"),
-});
-
-type LaunchParams = typeof launchSchema.infer;
-
-const KEY_INPUT: Record<string, string> = {
-	ENTER: "\r",
-	TAB: "\t",
-	ESCAPE: "\u001b",
-	CTRL_C: "\u0003",
-	CTRL_D: "\u0004",
-	UP: "\u001b[A",
-	DOWN: "\u001b[B",
-	RIGHT: "\u001b[C",
-	LEFT: "\u001b[D",
-};
-
-/** Structured launch state retained for compact TUI rendering. */
-export interface LaunchToolDetails {
-	op: LaunchParams["op"];
-	daemon?: DaemonSnapshot;
-	daemons?: DaemonSnapshot[];
-	cursor?: number;
-	timedOut?: boolean;
-	/** logs: daemon lifecycle state at read time. */
-	state?: DaemonState;
-	/** logs: virtual terminal rows for display; model-facing content remains sanitized text. */
-	terminalRows?: string[];
-	/** wait: output line that satisfied the pattern. */
-	matched?: string;
-	/** describe: immutable launch spec backing the command/cwd detail lines. */
-	spec?: DaemonSpec;
-}
-
-function requiredName(params: LaunchParams): string {
-	if (!params.name) throw new ToolError(`${params.op} requires name`);
-	return params.name;
-}
-
-function timeoutMs(value: number | undefined, fallbackSeconds: number): number {
-	const seconds = Math.max(0.05, Math.min(3_600, value ?? fallbackSeconds));
-	return Math.round(seconds * 1_000);
-}
-
-function commandSpec(params: LaunchParams, session: ToolSession): DaemonSpec {
-	const name = requiredName(params);
-	if (!params.application) throw new ToolError("start requires application");
-	const ready = params.ready;
-	const detached = params.detached ?? false;
-	if (ready?.port !== undefined && (!Number.isInteger(ready.port) || ready.port < 1 || ready.port > 65_535)) {
-		throw new ToolError("ready.port must be an integer from 1 to 65535");
-	}
-	if (ready && !ready.log && ready.port === undefined) throw new ToolError("ready requires log or port");
-	return {
-		name,
-		application: params.application,
-		args: params.args ?? [],
-		env: params.env ?? {},
-		cwd: resolveToCwd(params.cwd ?? session.cwd, session.cwd),
-		pty: detached ? false : (params.pty ?? true),
-		ready: ready
-			? {
-					log: ready.log,
-					port: ready.port,
-					host: ready.host,
-					timeoutMs: timeoutMs(ready.timeout, 30),
-				}
-			: undefined,
-		restart: params.restart ?? "no",
-		persist: (params.persist ?? false) || detached,
-		detached,
-	};
-}
-
-function sendData(params: LaunchParams): string | undefined {
-	let data = params.text ?? "";
-	if (params.text && (params.enter ?? true)) data += KEY_INPUT.ENTER;
-	for (const rawKey of params.keys ?? []) {
-		const key = rawKey.trim().toUpperCase();
-		const input = KEY_INPUT[key];
-		if (input === undefined) throw new ToolError(`Unsupported launch key ${rawKey}`);
-		data += input;
-	}
-	return data || undefined;
-}
-
-function operationFor(params: LaunchParams, session: ToolSession): DaemonOperation {
-	switch (params.op) {
-		case "start":
-			return { op: "start", spec: commandSpec(params, session), owner: session.getSessionId?.() ?? undefined };
-		case "list":
-			return { op: "list" };
-		case "logs":
-			return {
-				op: "logs",
-				name: requiredName(params),
-				lines: Math.min(1_000, Math.floor(params.lines ?? 100)),
-				head: params.head ?? false,
-				grep: params.grep,
-				follow: params.follow ?? false,
-				cursor: params.cursor,
-				timeoutMs: timeoutMs(params.timeout, 30),
-			};
-		case "wait":
-			return {
-				op: "wait",
-				name: requiredName(params),
-				for: params.for ?? "exit",
-				pattern: params.pattern,
-				timeoutMs: timeoutMs(params.timeout, 30),
-			};
-		case "send":
-			return {
-				op: "send",
-				name: requiredName(params),
-				data: sendData(params),
-				signal: params.signal,
-			};
-		case "stop":
-			return { op: "stop", name: requiredName(params), timeoutMs: timeoutMs(params.timeout, 5) };
-		case "restart":
-			return { op: "restart", name: requiredName(params) };
-		case "describe":
-			return { op: "describe", name: requiredName(params) };
-	}
-}
-
-function daemonLabel(daemon: DaemonSnapshot): string {
-	const pid = daemon.pid === undefined ? "" : ` pid=${daemon.pid}`;
-	const exit = daemon.exitCode === undefined ? "" : ` exit=${daemon.exitCode}`;
-	return `${daemon.name}: ${daemon.state}${pid}${exit} uptime=${formatDuration(
-		(daemon.exitedAt ?? Date.now()) - daemon.startedAt,
-	)} restarts=${daemon.restartCount}${daemon.detached ? " detached" : daemon.persist ? " persistent" : ""}`;
-}
-
-/**
- * Human sentences for the readiness conditions still unmet, e.g.
- * `port 5173 on 127.0.0.1 never accepted connections`. `ready` (from the start
- * params) adds the concrete pattern/port; absent it falls back to generic labels.
- */
-function readyPendingSummary(daemon: DaemonSnapshot, ready?: LaunchParams["ready"]): string[] {
-	const parts: string[] = [];
-	for (const condition of daemon.readyPending ?? []) {
-		if (condition === "log") {
-			parts.push(ready?.log ? `log pattern /${ready.log}/ never matched` : "the log pattern never matched");
-		} else {
-			parts.push(
-				ready?.port !== undefined
-					? `port ${ready.port} on ${ready.host ?? "127.0.0.1"} never accepted connections`
-					: "the port never accepted connections",
-			);
-		}
-	}
-	return parts;
-}
-
-function toolContent(result: DaemonRpcResult, params: LaunchParams): string {
-	switch (result.op) {
-		case "ping":
-		case "shutdown":
-			throw new ToolError(`Internal daemon result ${result.op} is not tool-visible`);
-		case "start": {
-			const daemon = result.daemon;
-			const lines = [`${daemon.state === "failed" ? "Failed to launch" : "Started"} ${daemonLabel(daemon)}`];
-			if (daemon.state === "failed" && daemon.exitReason) lines.push(`Reason: ${daemon.exitReason}`);
-			if (daemon.readyMatch) lines.push(`Ready log matched: ${daemon.readyMatch}`);
-			if (result.readyTimedOut) {
-				const pending = readyPendingSummary(daemon, params.ready);
-				const cause = pending.length > 0 ? `: ${pending.join("; ")}` : "";
-				lines.push(
-					`NOT ready — readiness timed out after ${params.ready?.timeout ?? 30}s${cause}. The process is still running (state: ${daemon.state}); follow its logs or stop it.`,
-				);
-			}
-			return lines.join("\n");
-		}
-		case "list":
-			return result.daemons.length
-				? result.daemons.map(daemon => `- ${daemonLabel(daemon)}`).join("\n")
-				: "No daemons.";
-		case "logs": {
-			const text = sanitizeText(result.text);
-			return `${text}${text && !text.endsWith("\n") ? "\n" : ""}[${result.name}: ${result.state}; cursor=${result.cursor}${result.timedOut ? "; follow timed out" : ""}]`;
-		}
-		case "wait": {
-			const lines = [daemonLabel(result.daemon)];
-			if (result.matched) lines.push(`Matched: ${result.matched}`);
-			if (result.timedOut) {
-				const pending = readyPendingSummary(result.daemon);
-				lines.push(`Wait timed out${pending.length > 0 ? ` (still waiting on: ${pending.join("; ")})` : ""}.`);
-			}
-			return lines.join("\n");
-		}
-		case "send":
-			return `Sent input to ${daemonLabel(result.daemon)}`;
-		case "stop":
-			return `Stopped ${daemonLabel(result.daemon)}`;
-		case "restart":
-			return `Restarted ${daemonLabel(result.daemon)}`;
-		case "describe":
-			return [
-				daemonLabel(result.daemon),
-				`Command: ${[result.spec.application, ...result.spec.args].join(" ")}`,
-				`Cwd: ${shortenPath(result.spec.cwd)}`,
-				`PTY: ${result.spec.pty}; restart=${result.spec.restart}; persist=${result.spec.persist}; detached=${result.spec.detached}`,
-			].join("\n");
-	}
-}
-
-async function toolDetails(result: DaemonRpcResult, params: LaunchParams): Promise<LaunchToolDetails> {
-	switch (result.op) {
-		case "start":
-			return { op: "start", daemon: result.daemon, timedOut: result.readyTimedOut };
-		case "list":
-			return { op: "list", daemons: result.daemons };
-		case "logs": {
-			const terminalRows =
-				result.terminalText === undefined
-					? undefined
-					: await renderTerminalOutput(result.terminalText, {
-							head: params.head ?? false,
-							maxRows: Math.min(1_000, Math.floor(params.lines ?? 100)),
-						});
-			return {
-				op: "logs",
-				cursor: result.cursor,
-				timedOut: result.timedOut,
-				state: result.state,
-				terminalRows,
-			};
-		}
-		case "wait":
-			return { op: "wait", daemon: result.daemon, timedOut: result.timedOut, matched: result.matched };
-		case "send":
-			return { op: "send", daemon: result.daemon };
-		case "stop":
-			return { op: "stop", daemon: result.daemon };
-		case "restart":
-			return { op: "restart", daemon: result.daemon };
-		case "describe":
-			return { op: "describe", daemon: result.daemon, spec: result.spec };
-		case "ping":
-		case "shutdown":
-			throw new ToolError(`Internal daemon result ${result.op} is not tool-visible`);
-	}
-}
-function approvalFor(params: unknown): ToolApprovalDecision {
-	if (typeof params !== "object" || params === null || !("op" in params)) return "exec";
-	switch (params.op) {
-		case "list":
-		case "logs":
-		case "wait":
-		case "describe":
-			return "read";
-		default:
-			return "exec";
-	}
-}
-
-/** Project-scoped launch tool for supervising processes in every coding-agent session. */
-export class LaunchTool implements AgentTool<typeof launchSchema, LaunchToolDetails, Theme> {
-	readonly name = "launch";
-	readonly label = "Launch";
-	readonly loadMode = "essential";
-	readonly summary = "Launch and control shared long-running project processes";
-	readonly description = prompt.render(launchDescription);
-	readonly parameters = launchSchema;
-	readonly strict = true;
-	readonly examples: readonly ToolExample<LaunchParams>[] = [
-		{
-			caption: "Start a dev server and wait for its log banner and port",
-			call: {
-				op: "start",
-				name: "web",
-				application: "bun",
-				args: ["run", "dev"],
-				ready: { log: "Local:.*http", port: 5173, timeout: 30 },
-			},
-		},
-		{
-			caption: "Run a noninteractive service beyond broker lifetime",
-			call: {
-				op: "start",
-				name: "worker",
-				application: "worker",
-				args: ["serve"],
-				detached: true,
-			},
-		},
-		{
-			caption: "Inspect recent output",
-			call: { op: "logs", name: "web", lines: 100 },
-		},
-		{
-			caption: "Follow output after a cursor",
-			call: { op: "logs", name: "web", follow: true, cursor: 1842, timeout: 30 },
-		},
-		{
-			caption: "Set a debugger breakpoint",
-			call: { op: "send", name: "debugger", text: "breakpoint set --name main" },
-		},
-		{
-			caption: "Run a debugger command",
-			call: { op: "send", name: "debugger", text: "run" },
-		},
-		{
-			caption: "Interrupt a debugger",
-			call: { op: "send", name: "debugger", keys: ["CTRL_C"] },
-		},
-	];
-	readonly approval = approvalFor;
-
-	constructor(private readonly session: ToolSession) {}
-
-	async execute(
-		_toolCallId: string,
-		params: LaunchParams,
-		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<LaunchToolDetails, typeof launchSchema>,
-		_context?: AgentToolContext,
-	): Promise<AgentToolResult<LaunchToolDetails>> {
-		const client = await daemonClientForProject(this.session.cwd);
-		const result = await client.request(operationFor(params, this.session), signal);
-		return {
-			content: [{ type: "text", text: replaceTabs(toolContent(result, params)) }],
-			details: await toolDetails(result, params),
-		};
-	}
-}
-
-/** Args shape visible to the renderer, possibly mid-stream (every field optional). */
-type LaunchRenderArgs = Partial<LaunchParams>;
-
-function stateColor(state: DaemonState): ThemeColor {
-	switch (state) {
-		case "running":
-		case "ready":
-			return "success";
-		case "failed":
-			return "error";
-		case "exited":
-			return "muted";
-		default:
-			return "warning";
-	}
-}
-
-/** Compact `state · pid · uptime` fragments for the status-line meta slot. */
-function daemonMeta(daemon: DaemonSnapshot, theme: Theme): string[] {
-	const meta = [theme.fg(stateColor(daemon.state), daemon.state)];
-	if (daemon.readyPending?.length) meta.push(theme.fg("warning", `waiting on ${daemon.readyPending.join("+")}`));
-	if (daemon.exitCode !== undefined) {
-		meta.push(theme.fg(daemon.exitCode === 0 ? "muted" : "error", `exit ${daemon.exitCode}`));
-	} else if (daemon.pid !== undefined) {
-		meta.push(`pid ${daemon.pid}`);
-	}
-	const lifespan = formatDuration((daemon.exitedAt ?? Date.now()) - daemon.startedAt);
-	meta.push(daemon.exitedAt === undefined ? `up ${lifespan}` : `ran ${lifespan}`);
-	if (daemon.restartCount > 0) meta.push(`restarts ${daemon.restartCount}`);
-	if (daemon.detached) meta.push("detached");
-	else if (daemon.persist) meta.push("persistent");
-	return meta;
-}
-
-/** Op-specific call context (command line, log filters, wait condition, send payload). */
-function callMeta(args: LaunchRenderArgs): string[] {
-	const meta: string[] = [];
-	switch (args.op) {
-		case "start":
-			if (args.application) meta.push([args.application, ...(args.args ?? [])].join(" "));
-			break;
-		case "logs":
-			if (args.follow) meta.push("follow");
-			if (args.grep) meta.push(`grep /${args.grep}/`);
-			break;
-		case "wait":
-			meta.push(args.pattern ? `for /${args.pattern}/` : `for ${args.for ?? "exit"}`);
-			break;
-		case "send":
-			if (args.signal) meta.push(args.signal);
-			else if (args.text) meta.push(args.text);
-			if (args.keys?.length) meta.push(args.keys.join(" "));
-			break;
-	}
-	return meta.map(entry => previewLine(replaceTabs(entry), TRUNCATE_LENGTHS.SHORT));
-}
-
-/** TUI renderer: one status header per op, meta from structured details, capped body lines. */
-export const launchToolRenderer = {
-	inline: true,
-	mergeCallAndResult: true,
-	animatedPendingPreview: true,
-
-	renderCall(args: LaunchRenderArgs, options: RenderResultOptions, theme: Theme): Component {
-		const target = args.name ?? args.application;
-		const header = renderStatusLine(
-			{
-				icon: options.spinnerFrame !== undefined ? "running" : "pending",
-				spinnerFrame: options.spinnerFrame,
-				title: `Launch ${args.op ?? "…"}`,
-				description: target ? replaceTabs(target) : undefined,
-				meta: callMeta(args),
-			},
-			theme,
-		);
-		return new Text(header, 0, 0);
-	},
-
-	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: LaunchToolDetails; isError?: boolean },
-		options: RenderResultOptions,
-		theme: Theme,
-		args?: LaunchRenderArgs,
-	): Component {
-		const details = result.details;
-		const params = args ?? {};
-		const op = details?.op ?? params.op;
-		const isError = result.isError === true;
-		const daemon = details?.daemon;
-		const failed = isError || daemon?.state === "failed";
-		const text =
-			result.content
-				?.filter(item => item.type === "text")
-				.map(item => item.text ?? "")
-				.join("\n") ?? "";
-
-		const meta: string[] = [];
-		const body: string[] = [];
-		let description = params.name ?? daemon?.name;
-
-		if (isError) {
-			for (const line of replaceTabs(text.trimEnd()).split("\n")) body.push(theme.fg("error", line));
-		} else {
-			switch (op) {
-				case "start": {
-					meta.push(...callMeta(params));
-					if (daemon) meta.push(...daemonMeta(daemon, theme));
-					if (daemon?.readyMatch) body.push(theme.fg("dim", `log matched: ${replaceTabs(daemon.readyMatch)}`));
-					if (daemon?.state === "failed" && daemon.exitReason)
-						body.push(theme.fg("error", replaceTabs(daemon.exitReason)));
-					if (details?.timedOut) {
-						const pending = daemon ? readyPendingSummary(daemon, params.ready) : [];
-						body.push(
-							theme.fg(
-								"warning",
-								pending.length > 0
-									? `Not ready — ${pending.join("; ")}. Still running.`
-									: "Readiness timed out; the process is still running.",
-							),
-						);
-					}
-					break;
-				}
-				case "send":
-					meta.push(...callMeta(params));
-					if (daemon) meta.push(...daemonMeta(daemon, theme));
-					break;
-				case "stop":
-				case "restart":
-					if (daemon) meta.push(...daemonMeta(daemon, theme));
-					break;
-				case "wait": {
-					meta.push(...callMeta(params));
-					if (daemon) meta.push(...daemonMeta(daemon, theme));
-					if (details?.matched) body.push(theme.fg("dim", `matched: ${replaceTabs(details.matched)}`));
-					if (details?.timedOut) {
-						const pending = daemon ? readyPendingSummary(daemon) : [];
-						body.push(
-							theme.fg(
-								"warning",
-								pending.length > 0
-									? `Wait timed out — still waiting on ${pending.join("; ")}.`
-									: "Wait timed out.",
-							),
-						);
-					}
-					break;
-				}
-				case "list": {
-					const daemons = details?.daemons ?? [];
-					description = `${daemons.length || "no"} ${pluralize("process", daemons.length)}`;
-					for (const item of daemons) {
-						body.push(
-							`${theme.fg("accent", replaceTabs(item.name))} ${theme.fg("dim", daemonMeta(item, theme).join(theme.sep.dot))}`,
-						);
-					}
-					break;
-				}
-				case "logs": {
-					if (details?.state) meta.push(theme.fg(stateColor(details.state), details.state));
-					if (details?.cursor !== undefined) meta.push(`cursor ${details.cursor}`);
-					if (details?.timedOut) meta.push(theme.fg("warning", "follow timed out"));
-					// Strip the trailing `[name: state; cursor=N]` status suffix `toolContent` appends.
-					const logText = text.replace(/\n?\[[^\n]*\]$/, "").trimEnd();
-					const terminalRows = details?.terminalRows;
-					if (terminalRows) {
-						for (const row of terminalRows) body.push(styleTerminalRow(row, theme.getFgAnsi("toolOutput")));
-					} else if (logText) {
-						for (const line of logText.split("\n")) body.push(theme.fg("toolOutput", replaceTabs(line)));
-					}
-					break;
-				}
-				case "describe": {
-					if (daemon) meta.push(...daemonMeta(daemon, theme));
-					const spec = details?.spec;
-					if (spec) {
-						body.push(theme.fg("toolOutput", replaceTabs([spec.application, ...spec.args].join(" "))));
-						body.push(theme.fg("dim", `cwd ${shortenPath(spec.cwd)}`));
-						const flags = [`pty ${spec.pty}`, `restart ${spec.restart}`];
-						if (spec.detached) flags.push("detached");
-						else if (spec.persist) flags.push("persistent");
-						body.push(theme.fg("dim", flags.join(theme.sep.dot)));
-					}
-					break;
-				}
-				default:
-					if (text.trim()) {
-						for (const line of replaceTabs(text.trimEnd()).split("\n")) body.push(theme.fg("toolOutput", line));
-					}
-			}
-		}
-
-		const header = renderStatusLine(
-			{
-				...(failed
-					? { icon: "error" as const }
-					: options.isPartial
-						? { icon: "pending" as const }
-						: { iconOverride: theme.styledSymbol("tool.launch", "accent") }),
-				title: `Launch ${op ?? ""}`.trimEnd(),
-				description: description ? replaceTabs(description) : undefined,
-				meta,
-			},
-			theme,
-		);
-
-		if (op === "logs") {
-			return framedBlock(theme, width => {
-				const innerWidth = outputBlockContentWidth(width);
-				const rows = body.map(line => truncateToWidth(line, innerWidth));
-				return {
-					header,
-					state: options.isPartial ? "pending" : failed ? "error" : "success",
-					sections: [
-						{
-							label: theme.fg("toolTitle", "Output"),
-							lines: capPreviewLines(rows, theme, {
-								expanded: options.expanded,
-								max: DEFAULT_TERMINAL_PREVIEW_LINES,
-							}),
-						},
-					],
-					width,
-				};
-			});
-		}
-
-		return createCachedComponent(
-			() => options.expanded,
-			(width, expanded) => {
-				let visible = body;
-				if (!expanded && op === "list" && body.length > PREVIEW_LIMITS.COLLAPSED_ITEMS) {
-					const remaining = body.length - PREVIEW_LIMITS.COLLAPSED_ITEMS;
-					visible = [
-						...body.slice(0, PREVIEW_LIMITS.COLLAPSED_ITEMS),
-						theme.fg("dim", `${formatMoreItems(remaining, "process")} ${formatExpandHint(theme, false, true)}`),
-					];
-				}
-				return [header, ...visible].map(line => truncateToWidth(line, width));
-			},
-		);
-	},
-};
diff --git a/packages/coding-agent/src/tools/read.ts b/packages/coding-agent/src/tools/read.ts
index 907026882..53db53ad7 100644
--- a/packages/coding-agent/src/tools/read.ts
+++ b/packages/coding-agent/src/tools/read.ts
@@ -107,6 +107,8 @@ import {
 	splitPathAndSelPreferringLiteral,
 } from "./path-utils";
 import { formatBytes, replaceTabs, shortenPath, wrapBrackets } from "./render-utils";
+import { REPORT_ISSUE_DEVICE_NAME, reportIssueDeviceUsage } from "./report-tool-issue";
+import { isResolutionDeviceName, resolutionDeviceUsage } from "./resolve";
 import {
 	executeReadQuery,
 	getRowByKey,
@@ -1599,7 +1601,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		const displayLineByNumber = new Map<number, string>();
 		const fullLines = rawSelector ? undefined : await readBracketContextFullLines(absolutePath, fileSize);
 		let columnTruncated = 0;
-		const clippedLines = new Set<number>();
 		let displayContent: { text: string; startLine: number; lineNumbers?: Array<number | null> } | undefined;
 
 		for (const range of ranges) {
@@ -1647,7 +1648,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 						if (!cloned) cloned = collectedLines.slice();
 						cloned[i] = text;
 						columnTruncated = maxColumns;
-						clippedLines.add(range.startLine + i);
 					}
 				}
 				if (cloned) displayLines = cloned;
@@ -1679,7 +1679,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 						const truncated = truncateLine(sourceText, maxColumns);
 						if (truncated.wasTruncated) {
 							columnTruncated = maxColumns;
-							clippedLines.add(lineNumber);
 						}
 						return truncated.text;
 					},
@@ -1698,7 +1697,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		if (shouldAddHashLines && outputText) {
 			const tag = await recordFileSnapshot(this.session, absolutePath);
 			if (tag) {
-				recordSeenLinesFromBody(this.session, absolutePath, tag, outputText, clippedLines);
+				recordSeenLinesFromBody(this.session, absolutePath, tag, outputText);
 				outputText = `${formatReadHashlineHeader(formatPathRelativeToCwd(absolutePath, this.session.cwd), tag)}\n${outputText}`;
 			}
 		} else if (rawSelector && visibleSpans.length > 0) {
@@ -2569,7 +2568,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					// ellipsis-truncated text made every long-line file uneditable on
 					// the next edit attempt.
 					let displayLines: string[] = collectedLines;
-					const clippedLines = new Set<number>();
 					if (!rawSelector && maxColumns > 0) {
 						let cloned: string[] | undefined;
 						for (let i = 0; i < collectedLines.length; i++) {
@@ -2578,7 +2576,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 								if (!cloned) cloned = collectedLines.slice();
 								cloned[i] = text;
 								columnTruncated = maxColumns;
-								clippedLines.add(startLineDisplay + i);
 							}
 						}
 						if (cloned) displayLines = cloned;
@@ -2663,7 +2660,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 									const truncated = truncateLine(sourceText, maxColumns);
 									if (truncated.wasTruncated) {
 										columnTruncated = maxColumns;
-										clippedLines.add(lineNumber);
 									}
 									return truncated.text;
 								},
@@ -2738,7 +2734,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					}
 
 					if (hashContext?.tag) {
-						recordSeenLinesFromBody(this.session, absolutePath, hashContext.tag, outputText, clippedLines);
+						recordSeenLinesFromBody(this.session, absolutePath, hashContext.tag, outputText);
 					}
 					if (rawSelector && !firstLineExceedsLimit && collectedLines.length > 0) {
 						await recordFileSnapshot(
@@ -3129,6 +3125,15 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			signal,
 			localProtocolOptions: this.session.localProtocolOptions,
 			skills: this.session.skills,
+			xd: {
+				read: async name => {
+					if (name === REPORT_ISSUE_DEVICE_NAME) return reportIssueDeviceUsage();
+					if (name && isResolutionDeviceName(name)) return resolutionDeviceUsage(name);
+					const registry = this.session.xdevRegistry;
+					if (!registry || registry.size === 0) throw new ToolError("xd:// is not mounted in this session.");
+					return name === null ? registry.listing() : registry.docs(name);
+				},
+			},
 		});
 		const details: ReadToolDetails = { resolvedPath: resource.sourcePath, contentType: resource.contentType };
 
diff --git a/packages/coding-agent/src/tools/renderers.ts b/packages/coding-agent/src/tools/renderers.ts
index 5e8850b42..895718bc2 100644
--- a/packages/coding-agent/src/tools/renderers.ts
+++ b/packages/coding-agent/src/tools/renderers.ts
@@ -21,18 +21,15 @@ import { evalToolRenderer } from "./eval-render";
 import { githubToolRenderer } from "./gh-renderer";
 import { globToolRenderer } from "./glob";
 import { grepToolRenderer } from "./grep";
+import { hubToolRenderer } from "./hub";
 import { inspectImageToolRenderer } from "./inspect-image-renderer";
-import { ircToolRenderer } from "./irc";
-import { jobToolRenderer } from "./job";
-import { launchToolRenderer } from "./launch";
 import { recallToolRenderer, reflectToolRenderer, retainToolRenderer } from "./memory-render";
 import { readToolRenderer } from "./read";
-import { resolveToolRenderer } from "./resolve";
-import { searchToolBm25Renderer } from "./search-tool-bm25";
-import { sshToolRenderer } from "./ssh";
+import { resolveRenderer } from "./resolve";
 import { todoToolRenderer } from "./todo";
 import { createVibeToolRenderer } from "./vibe";
 import { writeToolRenderer } from "./write";
+import { setXdevRendererLookup } from "./xdev";
 
 /**
  * Per-renderer opt-in for a full viewport replay when the first result
@@ -93,16 +90,16 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	grep: grepToolRenderer as ToolRenderer,
 	lsp: lspToolRenderer as ToolRenderer,
 	inspect_image: inspectImageToolRenderer as ToolRenderer,
-	irc: ircToolRenderer as ToolRenderer,
-	launch: launchToolRenderer as ToolRenderer,
+	hub: hubToolRenderer as ToolRenderer,
 	read: readToolRenderer as ToolRenderer,
-	job: jobToolRenderer as ToolRenderer,
-	resolve: resolveToolRenderer as ToolRenderer,
+	// Keyed by xd:// resolution-device names: the write dispatch delegates here
+	// by dispatch tool, and historical `resolve` tool transcripts still render
+	// through the `resolve` entry. Both devices carry the same ResolveDetails.
+	resolve: resolveRenderer as ToolRenderer,
+	reject: resolveRenderer as ToolRenderer,
 	retain: retainToolRenderer as ToolRenderer,
 	recall: recallToolRenderer as ToolRenderer,
 	reflect: reflectToolRenderer as ToolRenderer,
-	search_tool_bm25: searchToolBm25Renderer as ToolRenderer,
-	ssh: sshToolRenderer as ToolRenderer,
 	// Lazy getter: `taskToolRenderer` lives in a module that closes an import
 	// cycle back here (task/renderer → task/render → … → tools/renderers), so
 	// reading it at init order-dependently hits its temporal dead zone. Deferring
@@ -121,3 +118,8 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	vibe_list: createVibeToolRenderer("list") as ToolRenderer,
 	write: writeToolRenderer as ToolRenderer,
 };
+
+// Wire the xd:// render delegation. Injected (instead of the xdev module
+// importing this module) to avoid the renderers → tool modules → sdk →
+// tools/index → xdev import cycle.
+setXdevRendererLookup(name => toolRenderers[name]);
diff --git a/packages/coding-agent/src/tools/report-tool-issue.ts b/packages/coding-agent/src/tools/report-tool-issue.ts
index 7d887531c..42aaea432 100644
--- a/packages/coding-agent/src/tools/report-tool-issue.ts
+++ b/packages/coding-agent/src/tools/report-tool-issue.ts
@@ -1,43 +1,91 @@
 /**
- * report_tool_issue — automated QA tool for tracking unexpected tool behavior.
+ * report_issue — automated QA backend for tracking unexpected tool behavior.
  *
- * Enabled by default; gated behind PI_AUTO_QA=1 / `dev.autoqa` so a user
- * who flips the setting off short-circuits injection entirely.
- * Always injected into every agent (including subagents) regardless of tool selection.
- * Records grievances to a local SQLite database; never throws.
+ * No model-facing tool schema anymore: the write tool dispatches plain text to
+ * `xd://report_issue`, and the system prompt tells the model to write
+ * `<tool>: <concise description>` there when auto-QA is enabled.
+ *
+ * Enabled by default; gated behind PI_AUTO_QA=1 / `dev.autoqa` so a user who
+ * flips the setting off short-circuits injection entirely.
+ * Records grievances to a local SQLite database; never throws from the device
+ * dispatch path.
  *
  * Before the first record lands, the user's consent is checked. If they've
  * never been asked (`dev.autoqa.consent === "unset"`) the process-global
- * consent handler — wired by `InteractiveMode` to a Yes/No popup — is
- * invoked exactly once and the decision is persisted. Subsequent calls
- * (including from subagents) read the cached decision without prompting.
+ * consent handler — wired by `InteractiveMode` to a Yes/No popup — is invoked
+ * exactly once and the decision is persisted. Subsequent calls (including from
+ * subagents) read the cached decision without prompting.
  *
  * When the user grants consent, push is automatically active against the
  * bundled endpoint (`dev.autoqaPush.endpoint`, default `qa.omp.sh`). Each
- * insert schedules a background flush that POSTs pending rows and deletes
- * them on HTTP 2xx. `PI_AUTO_QA_PUSH=1` forces push in non-interactive
- * environments where the consent dialog never fires. Tool execution is
- * never blocked on the network and never throws.
+ * insert schedules a background flush that POSTs pending rows and deletes them
+ * on HTTP 2xx. `PI_AUTO_QA_PUSH=1` forces push in non-interactive environments
+ * where the consent dialog never fires. Device execution is never blocked on
+ * the network and never throws.
  */
 import { Database } from "bun:sqlite";
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import type { FetchImpl } from "@oh-my-pi/pi-ai";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
 import { $env, $flag, getAutoQaDbDir, getInstallId, logger, VERSION } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
 import type { Settings } from "..";
+import type { Theme } from "../modes/theme/theme";
+import { renderStatusLine, truncateToWidth } from "../tui";
 import type { ToolSession } from "./index";
+import { replaceTabs } from "./render-utils";
+import { ToolError } from "./tool-errors";
+import type { XdevDispatch } from "./xdev";
 
-function buildReportToolIssueParams(activeBuiltinNames: readonly string[]) {
-	// Enum gives the model a tight schema; the runtime check in `execute` is the
-	// source of truth (handles models that ignore the enum and the empty-list
-	// fallback used by call sites that don't know the active set yet).
-	const toolSchema = activeBuiltinNames.length > 0 ? type.enumerated(...activeBuiltinNames) : type("string");
-	return type({
-		tool: toolSchema.describe("tool name"),
-		report: type("string").describe(
-			"unexpected behavior; generic, NEVER PII (paths, file contents, identifiers, prompt text)",
-		),
-	});
+export const REPORT_ISSUE_DEVICE_NAME = "report_issue";
+export const REPORT_ISSUE_DEVICE_PATH = `xd://${REPORT_ISSUE_DEVICE_NAME}`;
+
+/** Usage text for `read xd://report_issue`. */
+export function reportIssueDeviceUsage(): string {
+	return `Write \`<tool>: <concise description>\` as plain text to ${REPORT_ISSUE_DEVICE_PATH}. A two-line fallback also works: tool name on line 1, report body below.`;
+}
+
+/** Whether a tool call writes to `xd://report_issue`. */
+export function isReportIssueToolCall(toolCall: { name: string; arguments?: Record<string, unknown> }): boolean {
+	if (toolCall.name !== "write") return false;
+	const args = toolCall.arguments;
+	const path =
+		typeof args?.path === "string" ? args.path : typeof args?.file_path === "string" ? args.file_path : undefined;
+	return path === REPORT_ISSUE_DEVICE_PATH || path === `${REPORT_ISSUE_DEVICE_PATH}/`;
+}
+
+/** Call preview for an `xd://report_issue` write. */
+export function renderReportIssueDeviceCall(content: unknown, uiTheme: Theme): Component {
+	const body = typeof content === "string" ? replaceTabs(content.trim().split("\n")[0] ?? "") : "";
+	const text = renderStatusLine(
+		{
+			icon: "pending",
+			title: "Report Tool Issue",
+			description: body ? truncateToWidth(body, 72) : undefined,
+		},
+		uiTheme,
+	);
+	return new Text(text, 0, 0);
+}
+
+function parseReportIssueBody(text: string): { tool: string; report: string } {
+	const body = text.trim();
+	if (!body) {
+		throw new ToolError(`Empty report. ${reportIssueDeviceUsage()}`);
+	}
+	const firstNewline = body.indexOf("\n");
+	if (firstNewline >= 0) {
+		const tool = body.slice(0, firstNewline).trim();
+		const report = body.slice(firstNewline + 1).trim();
+		if (tool && report) return { tool, report };
+	}
+	const colon = body.indexOf(":");
+	if (colon > 0) {
+		const tool = body.slice(0, colon).trim();
+		const report = body.slice(colon + 1).trim();
+		if (tool && report) return { tool, report };
+	}
+	throw new ToolError(`Invalid report format. ${reportIssueDeviceUsage()}`);
 }
 
 export function isAutoQaEnabled(settings?: Settings): boolean {
@@ -56,14 +104,14 @@ export function isAutoQaEnabled(settings?: Settings): boolean {
  *   - `false` — user declined; suppress for this run and persist.
  *   - `null`  — user dismissed the dialog (ESC, click-away, …) without
  *               picking an option. The decision is NOT cached or persisted,
- *               so the next `report_tool_issue` invocation re-prompts.
+ *               so the next `report_issue` invocation re-prompts.
  *
- * Persistence is the tool's job (so subagent invocations can persist into
- * the disk-backed `Settings` instance the host registered alongside the
- * handler), not the handler's. Implementations live in hosts that have UI
- * affordances — today only `InteractiveMode`. When no handler is
- * registered (CLI subcommands, tests, non-interactive runs) consent
- * defaults to `false` — the explicit "don't collect by default" stance.
+ * Persistence is the tool's job (so subagent invocations can persist into the
+ * disk-backed `Settings` instance the host registered alongside the handler),
+ * not the handler's. Implementations live in hosts that have UI affordances —
+ * today only `InteractiveMode`. When no handler is registered (CLI subcommands,
+ * tests, non-interactive runs) consent defaults to `false` — the explicit
+ * "don't collect by default" stance.
  */
 export type AutoQaConsentHandler = () => Promise<boolean | null>;
 
@@ -72,14 +120,14 @@ let consentHandler: AutoQaConsentHandler | null = null;
  * Persistent settings instance supplied by the consent-handler registrant.
  * Subagents have in-memory `Settings` snapshots that don't write to disk;
  * we persist the decision through this disk-backed reference so a grant
- * survives across runs even when triggered from a subagent tool call.
+ * survives across runs even when triggered from a subagent device write.
  */
 let persistentConsentSettings: Settings | null = null;
 /**
  * Process-global cache of the resolved consent decision. Survives across
- * subagent boundaries (subagents share this module instance), so a grant
- * in the parent applies immediately to children — including children that
- * spawned BEFORE the grant and would otherwise see a stale snapshot of
+ * subagent boundaries (subagents share this module instance), so a grant in
+ * the parent applies immediately to children — including children that spawned
+ * BEFORE the grant and would otherwise see a stale snapshot of
  * `dev.autoqa.consent` in their isolated `Settings`.
  *
  * `null` = never asked, never cached.
@@ -87,8 +135,8 @@ let persistentConsentSettings: Settings | null = null;
 let cachedConsent: boolean | null = null;
 /**
  * Single-flight in-flight consent request. While the dialog is open, every
- * concurrent `report_tool_issue` call (main + every subagent) awaits this
- * promise instead of stacking duplicate popups.
+ * concurrent `report_issue` call (main + every subagent) awaits this promise
+ * instead of stacking duplicate popups.
  */
 let consentInFlight: Promise<boolean> | null = null;
 
@@ -123,58 +171,56 @@ function readPersistedConsent(settings: Settings | undefined): boolean | null {
 
 function persistConsent(localSettings: Settings | undefined, granted: boolean): void {
 	const value = granted ? "granted" : "denied";
-	// Write on every settings instance we know about. The local one keeps
-	// the in-memory snapshot consistent for the current subagent; the
-	// persistent one (registered by the host) is what actually lands on disk.
-	for (const target of [localSettings, persistentConsentSettings]) {
-		if (!target) continue;
+	try {
+		localSettings?.set("dev.autoqa.consent", value);
+	} catch (error) {
+		logger.warn("Failed to persist auto-QA consent to local settings snapshot", { error: String(error) });
+	}
+	if (persistentConsentSettings && persistentConsentSettings !== localSettings) {
 		try {
-			target.set("dev.autoqa.consent", value);
+			persistentConsentSettings.set("dev.autoqa.consent", value);
 		} catch (error) {
-			logger.debug("autoqa consent persist failed", { error: String(error) });
+			logger.warn("Failed to persist auto-QA consent to persistent settings", { error: String(error) });
 		}
 	}
 }
 
 /**
- * Resolve the user's consent for `report_tool_issue` grievances.
+ * Resolve the user's consent for Auto-QA grievances.
  *
- * Precedence (highest first):
- *   1. Process-global cache (set on first successful resolution).
- *   2. Persistent setting (`dev.autoqa.consent` on the supplied `Settings`).
- *   3. Persistent setting on the registered host `Settings`.
- *   4. Consent handler popup (single-flight; persists the answer).
- *   5. Default-deny when no handler is registered.
- *
- * Never throws — handler errors degrade to "denied for this call" without
- * caching, so a subsequent invocation can re-prompt instead of being
- * permanently locked into the false branch.
+ * Priority:
+ * 1. module cache (`cachedConsent`) — process-global, survives subagent boundaries
+ * 2. persisted setting on the caller's `Settings`
+ * 3. persisted setting on the registered persistent settings instance
+ * 4. registered UI handler (single-flight)
+ * 5. default `false` (no handler / non-interactive)
  */
 export async function resolveAutoQaConsent(settings: Settings | undefined): Promise<boolean> {
 	if (cachedConsent !== null) return cachedConsent;
-	const persisted = readPersistedConsent(settings) ?? readPersistedConsent(persistentConsentSettings ?? undefined);
-	if (persisted !== null) {
-		cachedConsent = persisted;
-		return persisted;
+	const localPersisted = readPersistedConsent(settings);
+	if (localPersisted !== null) {
+		cachedConsent = localPersisted;
+		return localPersisted;
+	}
+	const globalPersisted =
+		persistentConsentSettings && persistentConsentSettings !== settings
+			? readPersistedConsent(persistentConsentSettings)
+			: null;
+	if (globalPersisted !== null) {
+		cachedConsent = globalPersisted;
+		return globalPersisted;
 	}
 	if (!consentHandler) return false;
 	if (consentInFlight) return consentInFlight;
-	const handler = consentHandler;
 	consentInFlight = (async () => {
 		try {
-			const granted = await handler();
-			if (granted === null) {
-				// User dismissed the dialog (ESC) without picking. Treat as
-				// "skip this call" but don't cache or persist — the next
-				// invocation gets to re-prompt so a stray ESC isn't a
-				// permanent opt-out.
-				return false;
-			}
-			cachedConsent = granted;
-			persistConsent(settings, granted);
-			return granted;
-		} catch (error) {
-			logger.warn("autoqa consent handler threw", { error: String(error) });
+			const result = await consentHandler!();
+			if (result === null) return false;
+			cachedConsent = result;
+			persistConsent(settings, result);
+			return result;
+		} catch {
+			// Transient failure (e.g. dialog crashed) — don't cache; allow re-prompt.
 			return false;
 		} finally {
 			consentInFlight = null;
@@ -187,49 +233,32 @@ let cachedDb: Database | null = null;
 
 /**
  * Open (or return the cached handle for) the auto-QA SQLite database at
- * `~/.omp/agent/autoqa.db`. Idempotently runs schema creation, the
- * `pushed`-column migration, and index setup so every consumer — tool
- * execute path, manual `omp grievances push`, future debug scripts —
- * sees the same prepared schema. Returns `null` only on a hard open
- * failure (filesystem permissions, etc.); a missing file is created.
- *
- * Exported because the `omp grievances` CLI handlers need the migrated
- * handle too — having a second `openDb` in the CLI led to the column
- * never being added on the manual-push path.
+ * `~/.omp/agent/autoqa.db`, creating the schema lazily. Returns `null` when
+ * the agent data dir cannot be resolved.
  */
 export function openAutoQaDb(): Database | null {
 	if (cachedDb) return cachedDb;
+	const dir = getAutoQaDbDir();
+	if (!dir) return null;
 	try {
-		const db = new Database(getAutoQaDbDir());
-		// Install the busy handler BEFORE any lock-taking statement. See #2421.
-		db.run("PRAGMA busy_timeout = 5000");
-		db.run(`
-			PRAGMA journal_mode=WAL;
-			PRAGMA synchronous=NORMAL;
+		const db = new Database(`${dir}/autoqa.db`, { create: true });
+		db.exec(`
 			CREATE TABLE IF NOT EXISTS grievances (
 				id INTEGER PRIMARY KEY AUTOINCREMENT,
 				model TEXT NOT NULL,
 				version TEXT NOT NULL,
 				tool TEXT NOT NULL,
 				report TEXT NOT NULL,
+				created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
 				pushed INTEGER NOT NULL DEFAULT 0
 			);
+			CREATE INDEX IF NOT EXISTS grievances_pushed_created_at_idx
+			ON grievances (pushed, created_at, id);
 		`);
-		// Migration: pre-`pushed` databases get the column tacked on. Existing
-		// rows default to `0` (unpushed), so legacy grievances from before the
-		// consent + push pipeline went live get swept up by the next flush —
-		// exactly the behaviour we want for users who just granted consent.
-		const cols = db.prepare("PRAGMA table_info(grievances)").all() as Array<{ name: string }>;
-		if (!cols.some(c => c.name === "pushed")) {
-			db.run("ALTER TABLE grievances ADD COLUMN pushed INTEGER NOT NULL DEFAULT 0");
-		}
-		// Speed up the per-batch `WHERE pushed = 0` scan that drives the flush
-		// loop. Without the index every batch becomes a full table scan once
-		// pushed rows dominate the table.
-		db.run("CREATE INDEX IF NOT EXISTS grievances_pushed_idx ON grievances(pushed, id)");
 		cachedDb = db;
 		return db;
-	} catch {
+	} catch (error) {
+		logger.warn("Failed to open auto-QA database", { error: String(error) });
 		return null;
 	}
 }
@@ -247,14 +276,14 @@ export interface FlushResult {
 /**
  * Optional per-flush controls. Used by `omp grievances push` to surface
  * progress to a TTY and to skip the user-facing consent gate (manual
- * pushes are the user's explicit intent, not a side effect of a tool call).
+ * pushes are the user's explicit intent, not a side effect of a device write).
  */
 export interface FlushOptions {
 	/**
 	 * Skip the `dev.autoqa.consent === "granted"` gate in
 	 * {@link resolvePushConfig}. Endpoint configuration is still required.
 	 * Reserved for explicit user-driven pushes (CLI `grievances push`,
-	 * future debug recipes); never set from the tool's auto-flush path.
+	 * future debug recipes); never set from the device's auto-flush path.
 	 */
 	bypassConsent?: boolean;
 	/**
@@ -357,8 +386,7 @@ async function performFlush(db: Database, config: PushConfig, options: FlushOpti
 			installId: getInstallId(),
 			// Coarse host fingerprint for triage — `darwin`/`linux`/`win32` +
 			// `arm64`/`x64`. Useful for "is this bug arch-specific?" without
-			// leaking the user's machine name (the old payload sent
-			// `os.hostname()` verbatim, which trivially deanonymises users).
+			// leaking the user's machine name.
 			platform: process.platform,
 			arch: process.arch,
 			entries: rows,
@@ -396,27 +424,16 @@ async function performFlush(db: Database, config: PushConfig, options: FlushOpti
 			return { pushed: totalPushed, ok: false };
 		}
 
-		// Mark just this batch — never touch ids the SELECT didn't return so a
-		// concurrent insert that landed mid-flight isn't claimed-as-shipped on
-		// our behalf. `id IN (?, ?, …)` rather than a range so a non-contiguous
-		// batch (after partial fills, retries, etc.) still flips exactly what
-		// we sent.
 		const ids = rows.map(r => r.id);
 		const placeholders = ids.map(() => "?").join(",");
 		db.prepare(`UPDATE grievances SET pushed = 1 WHERE id IN (${placeholders})`).run(...ids);
 		totalPushed += rows.length;
 		options.onProgress?.(totalPushed);
-		// Loop continues; the next SELECT picks up the next batch (or returns
-		// empty, exiting the loop).
 	}
 }
 
 /**
  * Flush queued grievances to the configured backend.
- *
- * Single-flight: concurrent callers share the in-flight promise. After a
- * failed push, retries are skipped for {@link FAILURE_COOLDOWN_MS} ms.
- * Never throws — all errors are caught and routed to the logger.
  */
 export async function flushGrievances(
 	db?: Database,
@@ -426,9 +443,6 @@ export async function flushGrievances(
 	const config = resolvePushConfig(settings, options.bypassConsent === true);
 	if (!config) return { pushed: 0, ok: false, skipped: true };
 
-	// `bypassConsent` is the user's explicit "ship NOW" intent — skip the
-	// 30s cooldown window so they're not stuck looking at "skipped" after a
-	// transient failure. Auto-flush calls still cool off.
 	const bypass = options.bypassConsent === true;
 	if (!bypass && inFlightFlush) return inFlightFlush;
 
@@ -457,74 +471,47 @@ export async function flushGrievances(
 	}
 }
 
-export function createReportToolIssueTool(session: ToolSession, activeBuiltinNames: readonly string[] = []): AgentTool {
-	const getModel = () => session.getActiveModelString?.() ?? "unknown";
-	// Snapshotted at construction time. The model's enum is built from the same
-	// snapshot; mid-session drift (extensions registering later, etc.) is caught
-	// by the silent-drop guard below.
-	const allowedToolNames = new Set(activeBuiltinNames);
+/** Record a grievance row and trigger the background consent/flush pipeline. */
+async function recordToolIssue(session: ToolSession, tool: string, report: string): Promise<void> {
+	const canonicalTool = tool.startsWith("proxy_") ? tool.slice("proxy_".length) : tool;
+	const db = openAutoQaDb();
+	if (!db) return;
+	db.prepare("INSERT INTO grievances (model, version, tool, report) VALUES (?, ?, ?, ?)").run(
+		session.getActiveModelString?.() ?? "unknown",
+		VERSION,
+		canonicalTool,
+		report,
+	);
+	void (async () => {
+		try {
+			await resolveAutoQaConsent(session.settings);
+			await flushGrievances(db, session.settings);
+		} catch (error) {
+			logger.debug("autoqa post-insert pipeline failed", { error: String(error) });
+		}
+	})();
+}
 
+/**
+ * Execute `write xd://report_issue`. `text` must be either:
+ * - `<tool>: <concise description>` on one line, or
+ * - tool name on the first line with the report body below.
+ */
+export async function dispatchReportIssueDevice(
+	session: ToolSession,
+	text: string,
+): Promise<{ result: AgentToolResult<unknown>; xdev: XdevDispatch }> {
+	try {
+		if (isAutoQaEnabled(session.settings)) {
+			const { tool, report } = parseReportIssueBody(text);
+			await recordToolIssue(session, tool, report);
+		}
+	} catch (error) {
+		if (error instanceof ToolError) throw error;
+		logger.error("Failed to record tool issue", { error });
+	}
 	return {
-		name: "report_tool_issue",
-		label: "Report Tool Issue",
-		strict: false,
-		approval: "write",
-		description: "Report unexpected tool behavior for automated QA tracking.",
-		parameters: buildReportToolIssueParams(activeBuiltinNames),
-		intent: "omit",
-		async execute(_toolCallId, rawParams) {
-			// Save is unconditional: the row lives in the user's own SQLite
-			// at ~/.omp/agent/autoqa.db regardless of consent — they always
-			// own their local data and can inspect or wipe it via `omp grievances`.
-			// Consent only gates whether the row is *shipped* to the shared
-			// backend; that decision rides on `dev.autoqa.consent` and is
-			// enforced inside `flushGrievances` via `resolvePushConfig`.
-			try {
-				const params = rawParams as { tool: string; report: string };
-				// Some models emit `proxy_<name>` for tools routed through a
-				// passthrough wrapper. Strip the prefix before allowlist check so
-				// `proxy_read` lands as a report against `read`, not a silent drop.
-				const canonicalTool = params.tool.startsWith("proxy_") ? params.tool.slice("proxy_".length) : params.tool;
-				// Silently drop reports targeting tools that aren't shipped built-ins
-				// (MCP servers, extensions that overrode a built-in name, typos).
-				// Not the model's fault — no error, no DB row, just acknowledge.
-				// Empty allowlist means the factory was called without a known active
-				// set, so behave as before and record everything.
-				if (allowedToolNames.size > 0 && !allowedToolNames.has(canonicalTool)) {
-					return { content: [{ type: "text", text: "Noted, thanks!" }] };
-				}
-				const db = openAutoQaDb();
-				if (db) {
-					db.prepare("INSERT INTO grievances (model, version, tool, report) VALUES (?, ?, ?, ?)").run(
-						getModel(),
-						VERSION,
-						canonicalTool,
-						params.report,
-					);
-					// Fire-and-forget background pipeline:
-					//   1. Trigger the consent popup if it hasn't been answered
-					//      (single-flight inside `resolveAutoQaConsent`; subagents
-					//      share the same module-level state).
-					//   2. Attempt a flush — `resolvePushConfig` no-ops when consent
-					//      isn't granted, so a "no" leaves the row local for later
-					//      `omp grievances push` or a future consent change.
-					// Tool execution returns immediately; the model never waits
-					// on the dialog.
-					void (async () => {
-						try {
-							await resolveAutoQaConsent(session.settings);
-							await flushGrievances(db, session.settings);
-						} catch (error) {
-							logger.debug("autoqa post-insert pipeline failed", { error: String(error) });
-						}
-					})();
-				}
-			} catch (error) {
-				logger.error("Failed to record tool issue", { error });
-			}
-			return {
-				content: [{ type: "text", text: "Noted, thanks!" }],
-			};
-		},
+		result: { content: [{ type: "text", text: "Noted, thanks!" }] },
+		xdev: { tool: REPORT_ISSUE_DEVICE_NAME, mode: "execute", args: { report: text.trim() } },
 	};
 }
diff --git a/packages/coding-agent/src/tools/resolve.ts b/packages/coding-agent/src/tools/resolve.ts
index 2a02f85b7..9cc27cee1 100644
--- a/packages/coding-agent/src/tools/resolve.ts
+++ b/packages/coding-agent/src/tools/resolve.ts
@@ -1,38 +1,140 @@
-import type {
-	AgentTool,
-	AgentToolContext,
-	AgentToolResult,
-	AgentToolUpdateCallback,
-	CustomMessage,
-} from "@oh-my-pi/pi-agent-core";
+/**
+ * Resolution devices: staged work is finalized through plain-text writes to
+ * always-available `xd://` URLs — no tool schema, no JSON protocol.
+ *
+ *   write xd://resolve   reason text  → APPLY the pending staged preview
+ *   write xd://reject    reason text  → DISCARD the pending staged preview
+ *   write xd://propose   plan <slug>  → submit the plan for approval (plan mode)
+ *
+ * Nothing rides the system prompt: the flows that stage work teach the call
+ * shape at the moment it becomes relevant (the preview reminder for
+ * resolve/reject, the plan-mode prompt for propose).
+ *
+ * Rendering rides the write tool's xd:// delegation: renderers.ts keys the
+ * resolve renderer under `resolve` and `reject` so device writes and legacy
+ * `resolve` tool transcripts draw the same block.
+ */
+import type { AgentToolResult, CustomMessage } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { parseXdUrl, XD_URL_PREFIX } from "../internal-urls/xd-protocol";
 import type { Theme } from "../modes/theme/theme";
-import resolveDescription from "../prompts/tools/resolve.md" with { type: "text" };
+import resolveReminderPrompt from "../prompts/system/resolve-device-reminder.md" with { type: "text" };
 import { Ellipsis, padToWidth, renderStatusLine, truncateToWidth } from "../tui";
 import type { ToolSession } from ".";
 import { replaceTabs } from "./render-utils";
 import { ToolError } from "./tool-errors";
+import type { XdevDispatch } from "./xdev";
 
-const resolveSchema = type({
-	action: "'apply' | 'discard'",
-	reason: type("string").describe("reason for action"),
-	"extra?": type("Record<string, unknown>").describe("free-form metadata"),
-});
+export const RESOLVE_DEVICE_NAME = "resolve";
+export const REJECT_DEVICE_NAME = "reject";
+export const PROPOSE_DEVICE_NAME = "propose";
 
-type ResolveParams = typeof resolveSchema.infer;
+/** The plain-text resolution device URLs (`xd://resolve`, …). */
+export const RESOLVE_DEVICE_PATH = `${XD_URL_PREFIX}${RESOLVE_DEVICE_NAME}`;
+export const REJECT_DEVICE_PATH = `${XD_URL_PREFIX}${REJECT_DEVICE_NAME}`;
+export const PROPOSE_DEVICE_PATH = `${XD_URL_PREFIX}${PROPOSE_DEVICE_NAME}`;
 
-export interface ResolveToolDetails {
-	action: "apply" | "discard";
+export type ResolutionDeviceName = typeof RESOLVE_DEVICE_NAME | typeof REJECT_DEVICE_NAME | typeof PROPOSE_DEVICE_NAME;
+
+/** Whether an xd:// device name is one of the plain-text resolution devices. */
+export function isResolutionDeviceName(name: string): name is ResolutionDeviceName {
+	return name === RESOLVE_DEVICE_NAME || name === REJECT_DEVICE_NAME || name === PROPOSE_DEVICE_NAME;
+}
+
+/** One-line usage string returned by `read xd://<device>` — the only "docs" these devices carry. */
+export function resolutionDeviceUsage(device: ResolutionDeviceName): string {
+	switch (device) {
+		case RESOLVE_DEVICE_NAME:
+			return `Write a one-sentence reason as plain text to ${RESOLVE_DEVICE_PATH} to APPLY the pending staged action (e.g. a tool preview).`;
+		case REJECT_DEVICE_NAME:
+			return `Write a one-sentence reason as plain text to ${REJECT_DEVICE_PATH} to DISCARD the pending staged action (e.g. a tool preview).`;
+		case PROPOSE_DEVICE_NAME:
+			return `Write your plan's <slug> (matching local://<slug>-plan.md) as plain text to ${PROPOSE_DEVICE_PATH} to submit the plan for approval. Valid only while plan mode is active.`;
+	}
+}
+
+/** Path of a (possibly partial) write tool call, or undefined. */
+function toolCallWritePath(toolCall: { name: string; arguments?: Record<string, unknown> }): string | undefined {
+	if (toolCall.name !== "write") return undefined;
+	const args = toolCall.arguments;
+	return typeof args?.path === "string" ? args.path : typeof args?.file_path === "string" ? args.file_path : undefined;
+}
+
+/**
+ * Whether an assistant tool call is a `write` targeting `xd://resolve` or
+ * `xd://reject`. Used as the SoftToolRequirement compliance check while a
+ * preview is pending — a plain `write` elsewhere resolves nothing.
+ */
+export function isPreviewResolutionToolCall(toolCall: { name: string; arguments?: Record<string, unknown> }): boolean {
+	const path = toolCallWritePath(toolCall);
+	if (path === undefined) return false;
+	const device = parseXdUrl(path)?.name;
+	return device === RESOLVE_DEVICE_NAME || device === REJECT_DEVICE_NAME;
+}
+
+/** Whether an assistant tool call is a `write` targeting `xd://propose` (plan-mode decision detection). */
+export function isProposeToolCall(toolCall: { name: string; arguments?: Record<string, unknown> }): boolean {
+	const path = toolCallWritePath(toolCall);
+	return path !== undefined && parseXdUrl(path)?.name === PROPOSE_DEVICE_NAME;
+}
+
+/**
+ * The XdevDispatch metadata carried on a completed `write` execution result, or
+ * `undefined` when the execution was not a device dispatch. Consumers check
+ * `.tool` (e.g. `PROPOSE_DEVICE_NAME` for plan-mode decision tracking and the
+ * event-controller's plan-approval hook).
+ */
+export function writeDeviceDispatch(toolName: string, result: unknown): XdevDispatch | undefined {
+	if (toolName !== "write") return undefined;
+	if (!result || typeof result !== "object" || !("details" in result)) return undefined;
+	const details = result.details;
+	if (!details || typeof details !== "object" || !("xdev" in details)) return undefined;
+	const xdev = details.xdev;
+	if (!xdev || typeof xdev !== "object" || !("tool" in xdev) || !("mode" in xdev)) return undefined;
+	// Envelope verified above; the write tool stored a real XdevDispatch here.
+	return xdev as XdevDispatch;
+}
+
+/** Handler installed by plan mode; `xd://propose` dispatches the written plan title to it. */
+export type PlanProposalHandler = (title: string) => Promise<AgentToolResult<unknown>>;
+
+type ResolveAction = "apply" | "discard";
+
+/** Details payload carried on a resolve/reject dispatch result (`XdevDispatch.inner`). */
+export interface ResolveDetails {
+	action: ResolveAction;
 	reason: string;
-	extra?: Record<string, unknown>;
 	sourceToolName?: string;
 	label?: string;
 	sourceResultDetails?: unknown;
 }
+/** Parse a completed `write` dispatch targeting `xd://resolve` or `xd://reject`. */
+export function resolveDispatchDetails(toolName: string, result: unknown): ResolveDetails | undefined {
+	const dispatch = writeDeviceDispatch(toolName, result);
+	if (!dispatch || (dispatch.tool !== RESOLVE_DEVICE_NAME && dispatch.tool !== REJECT_DEVICE_NAME)) return undefined;
+	const inner = dispatch.inner;
+	if (!inner || typeof inner !== "object") return undefined;
+	const action = "action" in inner ? inner.action : undefined;
+	const reason = "reason" in inner ? inner.reason : undefined;
+	if ((action !== "apply" && action !== "discard") || typeof reason !== "string") return undefined;
+	return {
+		action,
+		reason,
+		...("sourceToolName" in inner && typeof inner.sourceToolName === "string"
+			? { sourceToolName: inner.sourceToolName }
+			: {}),
+		...("label" in inner && typeof inner.label === "string" ? { label: inner.label } : {}),
+		...("sourceResultDetails" in inner ? { sourceResultDetails: inner.sourceResultDetails } : {}),
+	};
+}
+
+/** Invoker input for queued pending-preview handlers. */
+interface ResolveInvocation {
+	action: ResolveAction;
+	reason: string;
+}
 
 /** Monotonic suffix making each staged preview's pending-invoker id UNIQUE, so
  *  stacked previews never clobber one another by label. */
@@ -40,24 +142,25 @@ let pendingPreviewSeq = 0;
 
 /**
  * Register a non-forcing resolve-protocol handler for a staged preview. Wraps the
- * caller's apply/reject into an onInvoked closure (matching the resolve schema) and
- * stores it on the tool-choice queue's pending-invoker registry under a UNIQUE id.
- * The `resolve` tool dispatches to it; the agent-loop's SoftToolRequirement
- * lifecycle injects the preview reminder and escalates to a forced `resolve` only
+ * caller's apply/reject into an onInvoked closure and stores it on the tool-choice
+ * queue's pending-invoker registry under a UNIQUE id. A `write` to `xd://resolve`
+ * or `xd://reject` dispatches to it; the agent-loop's SoftToolRequirement
+ * lifecycle injects the preview reminder and escalates to a forced `write` only
  * if the model declines — so a compliant turn pays ZERO tool_choice change (no
  * prompt-cache messages-cache invalidation).
  *
  * This is the canonical entry point for any tool that wants preview/apply
  * semantics. No session-level abstraction is needed: callers pass their
- * apply/reject functions directly.
+ * apply/reject functions directly. Resolution requires the `write` tool to be
+ * active — the session's soft requirement names it.
  */
 export function queueResolveHandler(
 	session: ToolSession,
 	options: {
 		label: string;
 		sourceToolName: string;
-		apply(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
-		reject?(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown> | undefined>;
+		apply(reason: string): Promise<AgentToolResult<unknown>>;
+		reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
 	},
 ): void {
 	const queue = session.getToolChoiceQueue?.();
@@ -67,14 +170,14 @@ export function queueResolveHandler(
 	const id = `pending-action:${options.sourceToolName}:${pendingPreviewSeq++}`;
 
 	const onInvoked = async (input: unknown): Promise<AgentToolResult<unknown>> => {
-		const result = await runResolveInvocation(input as ResolveParams, {
+		const result = await runResolveInvocation(input as ResolveInvocation, {
 			sourceToolName: options.sourceToolName,
 			label: options.label,
 			apply: options.apply,
 			reject: options.reject,
 			onApplyError: () => {
 				// Apply threw (e.g. ast_edit overlapping replacements). Keep the preview
-				// pending under the SAME id so the model can `discard` or fix-and-retry;
+				// pending under the SAME id so the model can reject or fix-and-retry;
 				// runResolveInvocation rethrows, so the success-path removal below is skipped.
 				queue.registerPendingInvoker(id, options.sourceToolName, onInvoked);
 			},
@@ -84,9 +187,10 @@ export function queueResolveHandler(
 		return result;
 	};
 
-	// NON-FORCING: register so `resolve` can dispatch here WITHOUT changing
-	// tool_choice. The agent-loop injects the reminder (from the SoftToolRequirement
-	// the session builds) and forces a resolve turn only on non-compliance.
+	// NON-FORCING: register so a resolution-device write can dispatch here WITHOUT
+	// changing tool_choice. The agent-loop injects the reminder (from the
+	// SoftToolRequirement the session builds) and forces a `write` turn only on
+	// non-compliance.
 	queue.registerPendingInvoker(id, options.sourceToolName, onInvoked);
 }
 
@@ -100,11 +204,7 @@ export function buildResolveReminderMessage(sourceToolName: string): CustomMessa
 	return {
 		role: "custom",
 		customType: "resolve-reminder",
-		content: [
-			"<system-reminder>",
-			"This is a preview. Call the `resolve` tool to apply or discard these changes.",
-			"</system-reminder>",
-		].join("\n"),
+		content: resolveReminderPrompt.trim(),
 		display: false,
 		details: { toolName: sourceToolName },
 		attribution: "agent",
@@ -113,37 +213,35 @@ export function buildResolveReminderMessage(sourceToolName: string): CustomMessa
 }
 
 /**
- * Shared invocation runner used by both queued (in-flight) handlers and
- * standing handlers (e.g. plan-mode approval). Discriminates on action,
- * routes through the caller's apply/reject, and wraps the resulting tool
- * payload with `ResolveToolDetails` so the renderer and event-controller
- * see a consistent shape.
+ * Invocation runner for queued pending-preview handlers. Discriminates on
+ * action, routes through the caller's apply/reject, and wraps the resulting
+ * tool payload with `ResolveDetails` so the renderer and event-controller see
+ * a consistent shape.
  */
-export async function runResolveInvocation(
-	params: ResolveParams,
+async function runResolveInvocation(
+	params: ResolveInvocation,
 	options: {
 		sourceToolName: string;
 		label: string;
-		apply(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
-		reject?(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown> | undefined>;
+		apply(reason: string): Promise<AgentToolResult<unknown>>;
+		reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
 		/** Invoked synchronously when `apply()` throws, before the error is rethrown.
-		 *  The queued caller uses this to re-push the resolve directive so the
+		 *  The queued caller uses this to re-push the pending invoker so the
 		 *  pending preview survives a failed apply (e.g. overlapping ast_edit
-		 *  replacements) and the model can `discard` or fix-and-retry. */
+		 *  replacements) and the model can reject or fix-and-retry. */
 		onApplyError?(error: unknown): void;
 	},
-): Promise<AgentToolResult<ResolveToolDetails>> {
-	const baseDetails: ResolveToolDetails = {
+): Promise<AgentToolResult<ResolveDetails>> {
+	const baseDetails: ResolveDetails = {
 		action: params.action,
 		reason: params.reason,
 		sourceToolName: options.sourceToolName,
 		label: options.label,
-		...(params.extra != null ? { extra: params.extra } : {}),
 	};
 	if (params.action === "apply") {
 		let result: AgentToolResult<unknown>;
 		try {
-			result = await options.apply(params.reason, params.extra);
+			result = await options.apply(params.reason);
 		} catch (error) {
 			try {
 				options.onApplyError?.(error);
@@ -162,8 +260,8 @@ export async function runResolveInvocation(
 			},
 		};
 	}
-	if (params.action === "discard" && options.reject != null) {
-		const result = await options.reject(params.reason, params.extra);
+	if (options.reject != null) {
+		const result = await options.reject(params.reason);
 		if (result != null) {
 			return {
 				...result,
@@ -180,63 +278,77 @@ export async function runResolveInvocation(
 	};
 }
 
-export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolDetails> {
-	readonly name = "resolve";
-	readonly approval = "read" as const;
-	readonly label = "Resolve";
-	readonly hidden = true;
-	readonly description: string;
-	readonly parameters = resolveSchema;
-	readonly strict = true;
-	readonly intent = (args: Partial<ResolveParams>) => {
-		if (args.action === "discard") {
-			return args.reason ? `discarding: ${args.reason}` : "discarding changes";
+/**
+ * Execute a resolution-device write. `text` is the raw plain-text body:
+ * - `xd://resolve` / `xd://reject` → the reason; dispatches to the pending
+ *   preview invoker (in-flight queue directive first).
+ * - `xd://propose` → the plan title; dispatches to the plan-proposal handler
+ *   installed by plan mode.
+ */
+export async function dispatchResolutionDevice(
+	session: ToolSession,
+	device: ResolutionDeviceName,
+	text: string,
+): Promise<{ result: AgentToolResult<unknown>; xdev: XdevDispatch }> {
+	const body = text.trim();
+	if (device === PROPOSE_DEVICE_NAME) {
+		const handler = session.peekPlanProposalHandler?.();
+		if (!handler) {
+			throw new ToolError(
+				`No plan is awaiting approval — ${PROPOSE_DEVICE_PATH} only accepts a plan title while plan mode is active.`,
+			);
 		}
-		return args.reason ? `accepting: ${args.reason}` : "accepting changes";
-	};
-
-	constructor(private readonly session: ToolSession) {
-		this.description = prompt.render(resolveDescription);
+		const result = await handler(body);
+		return { result, xdev: { tool: device, mode: "execute", args: { title: body }, inner: result.details } };
 	}
 
-	async execute(
-		_toolCallId: string,
-		params: ResolveParams,
-		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<ResolveToolDetails>,
-		_context?: AgentToolContext,
-	): Promise<AgentToolResult<ResolveToolDetails>> {
-		return untilAborted(signal, async () => {
-			const invoker =
-				this.session.peekQueueInvoker?.() ??
-				this.session.peekPendingInvoker?.() ??
-				this.session.peekStandingResolveHandler?.();
-			if (!invoker) {
-				this.session.clearPendingInvokers?.();
-				// `discard` is a request to cancel/abort a staged action. When nothing is
-				// pending, the desired end-state (no staged change) already holds, so honor
-				// it as a successful cancellation instead of surfacing a hard error to the
-				// model. `apply` still errors — there is nothing to apply.
-				if (params.action === "discard") {
-					return {
-						content: [{ type: "text" as const, text: "Nothing to discard; no pending action remains." }],
-						details: {
-							action: "discard",
-							reason: params.reason,
-							...(params.extra != null ? { extra: params.extra } : {}),
-						},
-					};
-				}
-				throw new ToolError("No pending action to resolve. Nothing to apply or discard.");
-			}
-			const result = (await invoker(params)) as AgentToolResult<ResolveToolDetails>;
-			return result;
-		});
+	const action: ResolveAction = device === RESOLVE_DEVICE_NAME ? "apply" : "discard";
+	const xdevBase: XdevDispatch = { tool: device, mode: "execute", args: { reason: body } };
+	const invoker = session.peekQueueInvoker?.() ?? session.peekPendingInvoker?.();
+	if (!invoker) {
+		session.clearPendingInvokers?.();
+		const proposeHint = session.peekPlanProposalHandler?.()
+			? ` To submit the plan for approval, write its title to ${PROPOSE_DEVICE_PATH} instead.`
+			: "";
+		// Rejecting is a request to reach the "no staged change" end-state, which
+		// already holds when nothing is pending — honor it as a successful
+		// cancellation instead of surfacing a hard error. Apply still errors.
+		if (action === "discard") {
+			const details: ResolveDetails = { action, reason: body };
+			return {
+				result: {
+					content: [{ type: "text", text: `Nothing to reject; no pending action remains.${proposeHint}` }],
+					details,
+				},
+				xdev: { ...xdevBase, inner: details },
+			};
+		}
+		throw new ToolError(
+			`No pending action to apply — ${RESOLVE_DEVICE_PATH} is only valid while a staged preview is pending.${proposeHint}`,
+		);
 	}
+	const invocation: ResolveInvocation = { action, reason: body };
+	const result = (await invoker(invocation)) as AgentToolResult<ResolveDetails>;
+	return { result, xdev: { ...xdevBase, inner: result.details } };
 }
 
-export const resolveToolRenderer = {
-	renderCall(args: ResolveParams, _options: RenderResultOptions, uiTheme: Theme): Component {
+/** Streaming-safe call preview for a resolution-device write: `Resolve/Reject/Propose: <text>`. */
+export function renderResolutionDeviceCall(device: ResolutionDeviceName, content: unknown, uiTheme: Theme): Component {
+	const body = typeof content === "string" ? replaceTabs(content.trim().split("\n")[0] ?? "") : "";
+	const title = device === PROPOSE_DEVICE_NAME ? "Propose" : device === REJECT_DEVICE_NAME ? "Reject" : "Resolve";
+	const text = renderStatusLine(
+		{
+			icon: "pending",
+			title,
+			description: body ? truncateToWidth(body, 72, Ellipsis.Omit) : undefined,
+		},
+		uiTheme,
+	);
+	return new Text(text, 0, 0);
+}
+
+export const resolveRenderer = {
+	renderCall(args: Partial<ResolveInvocation>, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const reasonTrimmed = args.reason?.trim();
 		const reason = reasonTrimmed ? truncateToWidth(reasonTrimmed, 72, Ellipsis.Omit) : undefined;
 		const text = renderStatusLine(
@@ -256,7 +368,7 @@ export const resolveToolRenderer = {
 	},
 
 	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: ResolveToolDetails; isError?: boolean },
+		result: { content: Array<{ type: string; text?: string }>; details?: ResolveDetails; isError?: boolean },
 		_options: RenderResultOptions,
 		uiTheme: Theme,
 	): Component {
diff --git a/packages/coding-agent/src/tools/review.ts b/packages/coding-agent/src/tools/review.ts
index ca00a55a9..932800f9a 100644
--- a/packages/coding-agent/src/tools/review.ts
+++ b/packages/coding-agent/src/tools/review.ts
@@ -1,22 +1,14 @@
 /**
- * Legacy hidden review-finding tool for agents that have not migrated to
- * incremental `yield` sections.
+ * Review-finding shapes and priority helpers.
  *
- * Hidden by default - only enabled when explicitly listed in an agent's tools.
- * Reviewers now finish via incremental `yield`; this tool remains for
- * compatibility with older or custom review agents.
+ * The `report_finding` tool was removed; reviewers now record findings through
+ * incremental `yield` sections (`type: ["findings"]`). These parsers and
+ * priority-display helpers back the reviewer render path in `task/render.ts`.
  */
 // ─────────────────────────────────────────────────────────────────────────────
 
-import path from "node:path";
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { Component } from "@oh-my-pi/pi-tui";
-import { Container, Text } from "@oh-my-pi/pi-tui";
 import { isRecord } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
-import type { Theme, ThemeColor } from "../modes/theme/theme";
-import { subprocessToolRegistry } from "../task/subprocess-tool-registry";
-import type { ReviewFinding } from "../task/types";
+import type { ThemeColor } from "../modes/theme/theme";
 export type FindingPriority = "P0" | "P1" | "P2" | "P3";
 
 export interface FindingPriorityInfo {
@@ -41,33 +33,7 @@ export function isFindingPriority(value: unknown): value is FindingPriority {
 export function getPriorityInfo(priority: FindingPriority): FindingPriorityInfo {
 	return PRIORITY_INFO[priority] ?? { ord: 3, symbol: "status.info", color: "muted" };
 }
-
-function getPriorityDisplay(
-	priority: FindingPriority,
-	theme: Theme,
-): { label: string; icon: string; color: ThemeColor } {
-	const label = priority;
-	const meta = PRIORITY_INFO[priority] ?? { symbol: "status.info", color: "muted" as const };
-	return {
-		label,
-		icon: theme.styledSymbol(meta.symbol, meta.color),
-		color: meta.color,
-	};
-}
-
-// report_finding schema
-// report_finding schema
-const ReportFindingParams = type({
-	title: type("string").describe("prefixed imperative title"),
-	body: type("string").describe("problem explanation"),
-	priority: type("'P0' | 'P1' | 'P2' | 'P3'").describe("priority 0-3"),
-	confidence: type("number >= 0 & number <= 1").describe("confidence score"),
-	file_path: type("string").describe("file path"),
-	line_start: type("number").describe("start line"),
-	line_end: type("number").describe("end line"),
-});
-
-interface ReportFindingDetails {
+interface FindingDetails {
 	title: string;
 	body: string;
 	priority: FindingPriority;
@@ -86,7 +52,7 @@ function normalizeFindingPriority(value: unknown): FindingPriority | undefined {
 	return undefined;
 }
 
-export function parseReportFindingDetails(value: unknown): ReportFindingDetails | undefined {
+export function parseFindingDetails(value: unknown): FindingDetails | undefined {
 	if (!isRecord(value)) return undefined;
 
 	const title = typeof value.title === "string" ? value.title : undefined;
@@ -126,67 +92,6 @@ export function parseReportFindingDetails(value: unknown): ReportFindingDetails
 		line_end: lineEnd,
 	};
 }
-
-export const reportFindingTool: AgentTool<typeof ReportFindingParams, ReportFindingDetails, Theme> = {
-	name: "report_finding",
-	label: "Report Finding",
-	approval: "read",
-	description: "Report a code review finding. Use this for each issue found. Call yield when done.",
-	parameters: ReportFindingParams,
-	intent: "omit",
-	async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-		const { title, body, priority, confidence, file_path, line_start, line_end } = params;
-		const location = `${file_path}:${line_start}${line_end !== line_start ? `-${line_end}` : ""}`;
-
-		return {
-			content: [
-				{
-					type: "text",
-					text: `Finding recorded: ${priority} ${title}\nLocation: ${location}\nConfidence: ${(
-						confidence * 100
-					).toFixed(0)}%`,
-				},
-			],
-			details: { title, body, priority, confidence, file_path, line_start, line_end },
-		};
-	},
-
-	renderCall(args, _options, theme): Component {
-		const { label, icon, color } = getPriorityDisplay(args.priority, theme);
-		const titleText = String(args.title).replace(/^\[P\d\]\s*/, "");
-		return new Text(
-			`${theme.fg("toolTitle", theme.bold("report_finding "))}${icon} ${theme.fg(color, `[${label}]`)} ${theme.fg(
-				"dim",
-				titleText,
-			)}`,
-			0,
-			0,
-		);
-	},
-
-	renderResult(result, _options, theme): Component {
-		const { details } = result;
-		if (!details) {
-			const text = result.content[0];
-			return new Text(text?.type === "text" ? text.text : "", 0, 0);
-		}
-
-		const { label, icon, color } = getPriorityDisplay(details.priority, theme);
-		const location = `${details.file_path}:${details.line_start}${
-			details.line_end !== details.line_start ? `-${details.line_end}` : ""
-		}`;
-
-		return new Text(
-			`${theme.styledSymbol("tool.review", "accent")} ${icon} ${theme.fg(color, `[${label}]`)} ${theme.fg(
-				"dim",
-				location,
-			)}`,
-			0,
-			0,
-		);
-	},
-};
-
 /** SubmitReviewDetails - used for rendering review results from yield tool */
 export interface SubmitReviewDetails {
 	overall_correctness: "correct" | "incorrect";
@@ -194,68 +99,5 @@ export interface SubmitReviewDetails {
 	confidence: number;
 }
 
-// Re-export types for external use
-export type { ReportFindingDetails };
-/**
- * Coerce a tool-side `ReportFindingDetails` into the cross-boundary
- * `ReviewFinding` shape consumed by the reviewer agent's JTD output schema.
- *
- * The `report_finding` tool exposes `priority` as a string enum (`"P0".."P3"`)
- * for ergonomics, but the bundled reviewer schema (and every custom review
- * agent that mirrors it) declares `priority: number`. Without this coercion
- * the auto-populated `findings[]` fails JTD validation and every review run
- * that surfaces a finding is rejected with `findings.0.priority: expected
- * number, received string`.
- */
-export function toReviewFinding(details: ReportFindingDetails): ReviewFinding {
-	return {
-		title: details.title,
-		body: details.body,
-		priority: getPriorityInfo(details.priority).ord,
-		confidence: details.confidence,
-		file_path: details.file_path,
-		line_start: details.line_start,
-		line_end: details.line_end,
-	};
-}
-
-// Register report_finding handler
-subprocessToolRegistry.register<ReportFindingDetails>("report_finding", {
-	extractData: event => {
-		if (event.isError) return undefined;
-		return parseReportFindingDetails(event.result?.details);
-	},
-
-	renderInline: (data, theme) => {
-		const { label, icon, color } = getPriorityDisplay(data.priority, theme);
-		const titleText = data.title.replace(/^\[P\d\]\s*/, "");
-		const loc = `${path.basename(data.file_path)}:${data.line_start}`;
-		return new Text(`${icon} ${theme.fg(color, `[${label}]`)} ${titleText} ${theme.fg("dim", loc)}`, 0, 0);
-	},
-
-	renderFinal: (allData, theme, expanded) => {
-		const container = new Container();
-		const displayCount = expanded ? allData.length : Math.min(3, allData.length);
-
-		for (let i = 0; i < displayCount; i++) {
-			const data = allData[i];
-			const { label, icon, color } = getPriorityDisplay(data.priority, theme);
-			const titleText = data.title.replace(/^\[P\d\]\s*/, "");
-			const loc = `${path.basename(data.file_path)}:${data.line_start}`;
-
-			container.addChild(
-				new Text(`  ${icon} ${theme.fg(color, `[${label}]`)} ${titleText} ${theme.fg("dim", loc)}`, 0, 0),
-			);
-
-			if (expanded && data.body) {
-				container.addChild(new Text(`    ${theme.fg("dim", data.body)}`, 0, 0));
-			}
-		}
-
-		if (allData.length > displayCount) {
-			container.addChild(new Text(theme.fg("dim", `  … ${allData.length - displayCount} more findings`), 0, 0));
-		}
-
-		return container;
-	},
-});
+// Re-export the finding shape for the reviewer render path.
+export type { FindingDetails };
diff --git a/packages/coding-agent/src/tools/search-tool-bm25.ts b/packages/coding-agent/src/tools/search-tool-bm25.ts
deleted file mode 100644
index f4ef7803a..000000000
--- a/packages/coding-agent/src/tools/search-tool-bm25.ts
+++ /dev/null
@@ -1,351 +0,0 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import type { Component } from "@oh-my-pi/pi-tui";
-import { Text } from "@oh-my-pi/pi-tui";
-import { prompt } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
-import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import type { Theme } from "../modes/theme/theme";
-import searchToolBm25Description from "../prompts/tools/search-tool-bm25.md" with { type: "text" };
-import { resolveEffectiveToolDiscoveryMode } from "../tool-discovery/mode";
-import {
-	buildDiscoverableToolSearchIndex,
-	type DiscoverableTool,
-	type DiscoverableToolSearchIndex,
-	filterBySource,
-	formatDiscoverableToolServerSummary,
-	searchDiscoverableTools,
-	summarizeDiscoverableTools,
-} from "../tool-discovery/tool-index";
-import { framedBlock, renderStatusLine, truncateToWidth } from "../tui";
-import type { ToolSession } from ".";
-import { formatCount, formatExpandHint, formatMoreItems, replaceTabs, TRUNCATE_LENGTHS } from "./render-utils";
-import { ToolError } from "./tool-errors";
-
-const DEFAULT_LIMIT = 8;
-const TOOL_DISCOVERY_TITLE = "Tool Discovery";
-const COLLAPSED_MATCH_LIMIT = 5;
-const MATCH_LABEL_LEN = 72;
-const MATCH_DESCRIPTION_LEN = 96;
-
-const searchToolBm25Schema = type({
-	query: type("string").describe("tool search query"),
-	"limit?": type("number>0").describe("max matches"),
-});
-
-type SearchToolBm25Params = typeof searchToolBm25Schema.infer;
-
-interface SearchToolBm25Match {
-	name: string;
-	label: string;
-	description: string;
-	server_name?: string;
-	mcp_tool_name?: string;
-	schema_keys: string[];
-	score: number;
-}
-
-export interface SearchToolBm25Details {
-	query: string;
-	limit: number;
-	total_tools: number;
-	activated_tools: string[];
-	active_selected_tools: string[];
-	tools: SearchToolBm25Match[];
-}
-
-function formatMatch(tool: DiscoverableTool, score: number): SearchToolBm25Match {
-	return {
-		name: tool.name,
-		label: tool.label,
-		description: tool.summary,
-		server_name: tool.serverName,
-		mcp_tool_name: tool.mcpToolName,
-		schema_keys: tool.schemaKeys,
-		score: Number(score.toFixed(6)),
-	};
-}
-
-function buildSearchToolBm25Content(details: SearchToolBm25Details): string {
-	return JSON.stringify({
-		query: details.query,
-		activated_tools: details.activated_tools,
-		match_count: details.tools.length,
-		total_tools: details.total_tools,
-	});
-}
-
-/** Get discoverable tools for description rendering. Falls back to empty array on error. */
-function getDiscoverableToolsForDescription(session: ToolSession): DiscoverableTool[] {
-	try {
-		return session.getDiscoverableTools?.() ?? [];
-	} catch {
-		return [];
-	}
-}
-
-function getDiscoverableToolSearchIndexForExecution(session: ToolSession): DiscoverableToolSearchIndex {
-	try {
-		const cached = session.getDiscoverableToolSearchIndex?.();
-		if (cached) return cached;
-	} catch {}
-	return buildDiscoverableToolSearchIndex(getDiscoverableToolsForDescription(session));
-}
-
-/** Resolve the effective selected tool names (generic or legacy MCP). */
-function getSelectedToolNames(session: ToolSession): string[] {
-	if (session.getSelectedDiscoveredToolNames) {
-		return session.getSelectedDiscoveredToolNames();
-	}
-	return session.getSelectedMCPToolNames?.() ?? [];
-}
-
-/** Activate tools (generic or legacy MCP fallback). */
-async function activateTools(session: ToolSession, toolNames: string[]): Promise<string[]> {
-	if (session.activateDiscoveredTools) {
-		return session.activateDiscoveredTools(toolNames);
-	}
-	if (session.activateDiscoveredMCPTools) {
-		return session.activateDiscoveredMCPTools(toolNames);
-	}
-	return [];
-}
-
-type DiscoveryExecutionSession = ToolSession & {
-	_supportsDiscoveryExecution: true;
-};
-
-function supportsToolDiscoveryExecution(session: ToolSession): session is DiscoveryExecutionSession {
-	// Supports generic discovery
-	if (
-		typeof session.isToolDiscoveryEnabled === "function" &&
-		typeof session.getSelectedDiscoveredToolNames === "function" &&
-		typeof session.activateDiscoveredTools === "function"
-	) {
-		return true;
-	}
-	// Supports legacy MCP discovery
-	if (
-		typeof session.isMCPDiscoveryEnabled === "function" &&
-		typeof session.getSelectedMCPToolNames === "function" &&
-		typeof session.activateDiscoveredMCPTools === "function"
-	) {
-		return true;
-	}
-	return false;
-}
-
-function isDiscoveryEnabled(session: ToolSession): boolean {
-	if (typeof session.isToolDiscoveryEnabled === "function") {
-		return session.isToolDiscoveryEnabled();
-	}
-	return session.isMCPDiscoveryEnabled?.() ?? false;
-}
-
-export function renderSearchToolBm25Description(discoverableTools: DiscoverableTool[] = []): string {
-	const summary = summarizeDiscoverableTools(discoverableTools);
-	const builtinToolNames = filterBySource(discoverableTools, "builtin")
-		.map(t => t.name)
-		.sort();
-	return prompt.render(searchToolBm25Description, {
-		discoverableToolCount: summary.toolCount,
-		discoverableMCPServerSummaries: summary.servers.map(formatDiscoverableToolServerSummary),
-		hasDiscoverableMCPServers: summary.servers.length > 0,
-		discoverableBuiltinToolNames: builtinToolNames,
-		hasDiscoverableBuiltinTools: builtinToolNames.length > 0,
-	});
-}
-
-function renderMatchLines(match: SearchToolBm25Match, theme: Theme): string[] {
-	const safeServerName = match.server_name ? replaceTabs(match.server_name) : undefined;
-	const safeLabel = replaceTabs(match.label);
-	const safeDescription = replaceTabs(match.description.trim());
-	const metaParts: string[] = [];
-	if (safeServerName) metaParts.push(theme.fg("muted", safeServerName));
-	metaParts.push(theme.fg("dim", `score ${match.score.toFixed(3)}`));
-	const metaSep = theme.fg("dim", theme.sep.dot);
-	const metaSuffix = metaParts.length > 0 ? ` ${metaParts.join(metaSep)}` : "";
-	const lines = [`${theme.fg("accent", truncateToWidth(safeLabel, MATCH_LABEL_LEN))}${metaSuffix}`];
-	if (safeDescription) {
-		lines.push(theme.fg("muted", truncateToWidth(safeDescription, MATCH_DESCRIPTION_LEN)));
-	}
-	return lines;
-}
-
-function renderMatchBullets(tools: SearchToolBm25Match[], expanded: boolean, theme: Theme): string[] {
-	const shown = expanded ? tools.length : Math.min(tools.length, COLLAPSED_MATCH_LIMIT);
-	const bullet = theme.fg("dim", theme.format.bullet);
-	const lines: string[] = [];
-	for (let i = 0; i < shown; i++) {
-		const itemLines = renderMatchLines(tools[i]!, theme);
-		lines.push(`${bullet} ${itemLines[0]}`);
-		for (let j = 1; j < itemLines.length; j++) {
-			lines.push(`  ${itemLines[j]}`);
-		}
-	}
-	const remaining = tools.length - shown;
-	if (remaining > 0) {
-		const hint = formatExpandHint(theme, expanded, true);
-		lines.push(`${theme.fg("muted", formatMoreItems(remaining, "tool"))}${hint ? ` ${hint}` : ""}`);
-	}
-	return lines;
-}
-
-function renderFallbackResult(text: string, theme: Theme): Component {
-	const header = renderStatusLine({ icon: "warning", title: TOOL_DISCOVERY_TITLE }, theme);
-	const bodyLines = (text || "Tool discovery completed")
-		.split("\n")
-		.map(line => theme.fg("dim", truncateToWidth(replaceTabs(line), TRUNCATE_LENGTHS.LINE)));
-	return new Text([header, ...bodyLines].join("\n"), 0, 0);
-}
-
-/**
- * SearchToolsTool — wire name `search_tool_bm25` (preserved for persisted session back-compat).
- *
- * When tools.discoveryMode === "all", this covers both MCP tools and built-in discoverable tools.
- * When tools.discoveryMode === "mcp-only" or mcp.discoveryMode === true, only MCP tools are searched.
- */
-export class SearchToolBm25Tool implements AgentTool<typeof searchToolBm25Schema, SearchToolBm25Details> {
-	readonly name = "search_tool_bm25";
-	readonly approval = "read" as const;
-	readonly label = "SearchTools";
-	readonly loadMode = "essential";
-	get description(): string {
-		return renderSearchToolBm25Description(getDiscoverableToolsForDescription(this.session));
-	}
-	readonly parameters = searchToolBm25Schema;
-	readonly strict = true;
-
-	constructor(private readonly session: ToolSession) {}
-
-	static createIf(session: ToolSession): SearchToolBm25Tool | null {
-		// Direct createTools() calls do not know the final MCP/extension catalog yet, so
-		// auto mode is activated later by createAgentSession after the full registry exists.
-		if (resolveEffectiveToolDiscoveryMode(session.settings, 0) === "off") return null;
-		return supportsToolDiscoveryExecution(session) ? new SearchToolBm25Tool(session) : null;
-	}
-
-	async execute(
-		_toolCallId: string,
-		params: SearchToolBm25Params,
-		_signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<SearchToolBm25Details>,
-		_context?: AgentToolContext,
-	): Promise<AgentToolResult<SearchToolBm25Details>> {
-		if (!supportsToolDiscoveryExecution(this.session)) {
-			throw new ToolError("Tool discovery is unavailable in this session.");
-		}
-		if (!isDiscoveryEnabled(this.session)) {
-			throw new ToolError(
-				"Tool discovery is disabled. Enable tools.discoveryMode or mcp.discoveryMode to use search_tool_bm25.",
-			);
-		}
-
-		const query = params.query.trim();
-		if (query.length === 0) {
-			throw new ToolError("Query is required and must not be empty.");
-		}
-		const limit = params.limit ?? DEFAULT_LIMIT;
-		if (!Number.isInteger(limit) || limit <= 0) {
-			throw new ToolError("Limit must be a positive integer.");
-		}
-
-		const searchIndex = getDiscoverableToolSearchIndexForExecution(this.session);
-		const selectedToolNames = new Set(getSelectedToolNames(this.session));
-		let ranked: Array<{ tool: DiscoverableTool; score: number }> = [];
-		try {
-			ranked = searchDiscoverableTools(searchIndex, query, searchIndex.documents.length)
-				.filter(result => !selectedToolNames.has(result.tool.name))
-				.slice(0, limit);
-		} catch (error) {
-			if (error instanceof Error) {
-				throw new ToolError(error.message);
-			}
-			throw error;
-		}
-		const activated =
-			ranked.length > 0
-				? await activateTools(
-						this.session,
-						ranked.map(result => result.tool.name),
-					)
-				: [];
-
-		const details: SearchToolBm25Details = {
-			query,
-			limit,
-			total_tools: searchIndex.documents.length,
-			activated_tools: activated,
-			active_selected_tools: getSelectedToolNames(this.session),
-			tools: ranked.map(result => formatMatch(result.tool, result.score)),
-		};
-
-		return {
-			content: [{ type: "text", text: buildSearchToolBm25Content(details) }],
-			details,
-		};
-	}
-}
-
-export const searchToolBm25Renderer = {
-	renderCall(args: SearchToolBm25Params, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const query = typeof args.query === "string" ? replaceTabs(args.query.trim()) : "";
-		const meta = args.limit ? [`limit:${args.limit}`] : [];
-		const header = renderStatusLine(
-			{ icon: "pending", title: TOOL_DISCOVERY_TITLE, description: query || "(empty query)", meta },
-			uiTheme,
-		);
-		return new Text(header, 0, 0);
-	},
-
-	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: SearchToolBm25Details; isError?: boolean },
-		options: RenderResultOptions,
-		uiTheme: Theme,
-	): Component {
-		if (!result.details) {
-			const fallbackText = result.content
-				.filter(part => part.type === "text")
-				.map(part => part.text)
-				.filter((text): text is string => typeof text === "string" && text.length > 0)
-				.join("\n");
-			return renderFallbackResult(fallbackText, uiTheme);
-		}
-
-		const { details } = result;
-		const meta = [
-			formatCount("match", details.tools.length),
-			`${details.active_selected_tools.length} active`,
-			`${details.total_tools} total`,
-			`limit:${details.limit}`,
-		];
-		const safeQuery = replaceTabs(details.query);
-		const header = renderStatusLine(
-			{
-				...(details.tools.length > 0
-					? { iconOverride: uiTheme.fg("accent", uiTheme.symbol("icon.search")) }
-					: { icon: "warning" as const }),
-				title: TOOL_DISCOVERY_TITLE,
-				description: truncateToWidth(safeQuery, MATCH_LABEL_LEN),
-				meta,
-			},
-			uiTheme,
-		);
-		if (details.tools.length === 0) {
-			const emptyMessage =
-				details.total_tools === 0 ? "No discoverable tools are currently loaded." : "No matching tools found.";
-			return new Text(`${header}\n${uiTheme.fg("muted", emptyMessage)}`, 0, 0);
-		}
-
-		return framedBlock(uiTheme, width => ({
-			header,
-			sections: [{ lines: renderMatchBullets(details.tools, options.expanded ?? false, uiTheme) }],
-			state: "success",
-			borderColor: "borderMuted",
-			applyBg: false,
-			width,
-		}));
-	},
-
-	mergeCallAndResult: true,
-	inline: true,
-};
diff --git a/packages/coding-agent/src/tools/ssh.ts b/packages/coding-agent/src/tools/ssh.ts
deleted file mode 100644
index 5540d4a65..000000000
--- a/packages/coding-agent/src/tools/ssh.ts
+++ /dev/null
@@ -1,404 +0,0 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import type { ToolExample } from "@oh-my-pi/pi-ai";
-import type { Component } from "@oh-my-pi/pi-tui";
-import { prompt } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
-import type { SSHHost } from "../capability/ssh";
-import { sshCapability } from "../capability/ssh";
-import { loadCapability } from "../discovery";
-import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import type { Theme } from "../modes/theme/theme";
-import sshDescriptionBase from "../prompts/tools/ssh.md" with { type: "text" };
-import { DEFAULT_MAX_BYTES, streamTailUpdates, TailBuffer } from "../session/streaming-output";
-import type { SSHHostInfo } from "../ssh/connection-manager";
-import { ensureHostInfo, getCachedHostInfoSync } from "../ssh/connection-manager";
-import { executeSSH } from "../ssh/ssh-executor";
-import { renderStatusLine } from "../tui";
-import { CachedOutputBlock, markFramedBlockComponent } from "../tui/output-block";
-import type { ToolSession } from ".";
-import { truncateForPrompt } from "./approval";
-import { formatStyledTruncationWarning, type OutputMeta, stripOutputNotice } from "./output-meta";
-import { capPreviewLines, replaceTabs } from "./render-utils";
-import { ToolError } from "./tool-errors";
-import { toolResult } from "./tool-result";
-import { clampTimeout } from "./tool-timeouts";
-
-const sshSchema = type({
-	host: type("string").describe("ssh host"),
-	command: type("string").describe("remote command"),
-	"cwd?": type("string").describe("remote working directory; omit unless required, never ~ or ~/..."),
-	"timeout?": type("number").describe("timeout in seconds"),
-});
-
-export interface SSHToolDetails {
-	meta?: OutputMeta;
-}
-
-function formatHostEntry(host: SSHHost): string {
-	const info = getCachedHostInfoSync(host);
-
-	let shell: string;
-	if (!info) {
-		shell = "detecting...";
-	} else if (info.os === "windows") {
-		if (info.compatEnabled) {
-			const compatShell = info.compatShell || "bash";
-			shell = `windows/${compatShell}`;
-		} else if (info.shell === "powershell") {
-			shell = "windows/powershell";
-		} else {
-			shell = "windows/cmd";
-		}
-	} else if (info.os === "linux") {
-		shell = `linux/${info.shell}`;
-	} else if (info.os === "macos") {
-		shell = `macos/${info.shell}`;
-	} else {
-		shell = `unknown/${info.shell}`;
-	}
-
-	return `- ${host.name} (${host.host}) | ${shell}`;
-}
-
-function formatDescription(hosts: SSHHost[]): string {
-	const baseDescription = prompt.render(sshDescriptionBase);
-	if (hosts.length === 0) {
-		return baseDescription;
-	}
-	const hostList = hosts.map(formatHostEntry).join("\n");
-	return `${baseDescription}\n\nAvailable hosts:\n${hostList}`;
-}
-
-function quoteRemotePath(value: string): string {
-	if (value.length === 0) {
-		return "''";
-	}
-	const escaped = value.replace(/'/g, "'\\''");
-	return `'${escaped}'`;
-}
-
-function quotePowerShellPath(value: string): string {
-	if (value.length === 0) {
-		return "''";
-	}
-	const escaped = value.replace(/'/g, "''");
-	return `'${escaped}'`;
-}
-
-function quoteCmdPath(value: string): string {
-	const escaped = value.replace(/"/g, '""');
-	return `"${escaped}"`;
-}
-function assertValidSshCwd(cwd: string | undefined): void {
-	if (!cwd) return;
-	if (cwd === "~" || cwd.startsWith("~/")) {
-		throw new ToolError("SSH cwd must be an absolute remote path; omit cwd instead of using ~.");
-	}
-}
-
-function buildRemoteCommand(command: string, cwd: string | undefined, info: SSHHostInfo): string {
-	if (!cwd) return command;
-
-	if (info.os === "windows" && !info.compatEnabled) {
-		if (info.shell === "powershell") {
-			return `Set-Location -Path ${quotePowerShellPath(cwd)}; ${command}`;
-		}
-		return `cd /d ${quoteCmdPath(cwd)} && ${command}`;
-	}
-
-	return `cd -- ${quoteRemotePath(cwd)} && ${command}`;
-}
-
-async function loadHosts(session: ToolSession): Promise<{
-	hostNames: string[];
-	hostsByName: Map<string, SSHHost>;
-}> {
-	const result = await loadCapability<SSHHost>(sshCapability.id, { cwd: session.cwd });
-	const hostsByName = new Map<string, SSHHost>();
-	for (const host of result.items) {
-		if (!hostsByName.has(host.name)) {
-			hostsByName.set(host.name, host);
-		}
-	}
-	const hostNames = Array.from(hostsByName.keys()).sort();
-	return { hostNames, hostsByName };
-}
-
-type SshToolParams = typeof sshSchema.infer;
-
-export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
-	readonly name = "ssh";
-	readonly approval = "exec" as const;
-	readonly formatApprovalDetails = (args: unknown): string[] => {
-		const params = args as Partial<SshToolParams>;
-		const host = typeof params.host === "string" ? params.host : "(missing)";
-		const command = typeof params.command === "string" ? params.command : "(missing)";
-		return [`Host: ${truncateForPrompt(host)}`, `Command: ${truncateForPrompt(command)}`];
-	};
-	readonly summary = "Execute a command on a remote host over SSH";
-	readonly loadMode = "discoverable";
-	readonly label = "SSH";
-	readonly parameters = sshSchema;
-	readonly concurrency = "exclusive";
-	readonly strict = true;
-
-	readonly examples: readonly ToolExample<SshToolParams>[] = [
-		{
-			caption: "List files: Linux (on server1 (10.0.0.1) | linux/bash)",
-			call: { host: "server1", command: "ls -la /home/user" },
-		},
-		{
-			caption: "Show running processes: Windows cmd (on winbox (192.168.1.5) | windows/cmd)",
-			call: { host: "winbox", command: "tasklist /v" },
-		},
-		{
-			caption: "Get system info: macOS (on macbook (10.0.0.20) | macos/zsh)",
-			call: { host: "macbook", command: "uname -a && sw_vers" },
-		},
-	];
-
-	readonly #allowedHosts: Set<string>;
-
-	constructor(
-		private readonly session: ToolSession,
-		private readonly hostNames: string[],
-		private readonly hostsByName: Map<string, SSHHost>,
-		readonly description: string,
-	) {
-		this.#allowedHosts = new Set(this.hostNames);
-	}
-
-	async execute(
-		_toolCallId: string,
-		{ host, command, cwd, timeout: rawTimeout = 60 }: SshToolParams,
-		signal?: AbortSignal,
-		onUpdate?: AgentToolUpdateCallback<SSHToolDetails>,
-		_ctx?: AgentToolContext,
-	): Promise<AgentToolResult<SSHToolDetails>> {
-		if (!this.#allowedHosts.has(host)) {
-			throw new ToolError(`Unknown SSH host: ${host}. Available hosts: ${this.hostNames.join(", ")}`);
-		}
-
-		const hostConfig = this.hostsByName.get(host);
-		if (!hostConfig) {
-			throw new ToolError(`SSH host not loaded: ${host}`);
-		}
-		assertValidSshCwd(cwd);
-
-		const hostInfo = await ensureHostInfo(hostConfig);
-		const remoteCommand = buildRemoteCommand(command, cwd, hostInfo);
-
-		// Clamp to reasonable range: 1s - 3600s (1 hour)
-		const timeoutSec = clampTimeout("ssh", rawTimeout);
-		const timeoutMs = timeoutSec * 1000;
-
-		const tailBuffer = new TailBuffer(DEFAULT_MAX_BYTES);
-		const { path: artifactPath, id: artifactId } = (await this.session.allocateOutputArtifact?.("ssh")) ?? {};
-
-		const result = await executeSSH(hostConfig, remoteCommand, {
-			timeout: timeoutMs,
-			signal,
-			compatEnabled: hostInfo.compatEnabled,
-			artifactPath,
-			artifactId,
-			onChunk: streamTailUpdates(tailBuffer, onUpdate),
-		});
-
-		if (result.cancelled) {
-			throw new ToolError(result.output || "Command aborted");
-		}
-
-		const outputText = result.output || "(no output)";
-		const details: SSHToolDetails = {};
-		const resultBuilder = toolResult(details).text(outputText).truncationFromSummary(result, { direction: "tail" });
-
-		if (result.exitCode !== 0 && result.exitCode !== undefined) {
-			throw new ToolError(`${outputText}\n\nCommand exited with code ${result.exitCode}`);
-		}
-
-		return resultBuilder.done();
-	}
-}
-
-export async function loadSshTool(session: ToolSession): Promise<SshTool | null> {
-	const { hostNames, hostsByName } = await loadHosts(session);
-	if (hostNames.length === 0) {
-		return null;
-	}
-
-	const descriptionHosts = hostNames
-		.map(name => hostsByName.get(name))
-		.filter((host): host is SSHHost => host !== undefined);
-	const description = formatDescription(descriptionHosts);
-
-	return new SshTool(session, hostNames, hostsByName, description);
-}
-
-// =============================================================================
-// TUI Renderer
-// =============================================================================
-
-interface SshRenderArgs {
-	host?: string;
-	command?: string;
-	timeout?: number;
-}
-
-/** Whether the painted call args still carry the streamed raw-JSON buffer —
- *  the shape that renders the `⏳ SSH: […]` / `$ …` placeholder. */
-function hasStreamedRenderArgs(args: unknown): boolean {
-	if (args == null || typeof args !== "object" || !("__partialJson" in args)) return false;
-	return typeof args.__partialJson === "string";
-}
-
-interface SshRenderContext {
-	/** Visual lines for truncated output (pre-computed by tool-execution) */
-	visualLines?: string[];
-	/** Number of lines skipped */
-	skippedCount?: number;
-	/** Total visual lines */
-	totalVisualLines?: number;
-}
-
-function formatSshCommandLines(command: string, uiTheme: Theme): string[] {
-	const sanitized = replaceTabs(command);
-	const rawLines = sanitized.length > 0 ? sanitized.split("\n") : ["…"];
-	const prefix = uiTheme.fg("dim", "$ ");
-	return rawLines.map((line, i) => (i === 0 ? `${prefix}${line}` : line));
-}
-
-export const sshToolRenderer = {
-	animatedPendingPreview: true,
-	renderCall(args: SshRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
-		const host = args.host || "…";
-		const command = args.command ?? "";
-		const cmdLines = formatSshCommandLines(command, uiTheme);
-		const outputBlock = new CachedOutputBlock();
-		return markFramedBlockComponent({
-			render: (width: number): readonly string[] => {
-				const header = renderStatusLine(
-					{
-						icon: options.spinnerFrame !== undefined ? "running" : "pending",
-						spinnerFrame: options.spinnerFrame,
-						title: "SSH",
-						description: `[${host}]`,
-					},
-					uiTheme,
-				);
-				return outputBlock.render(
-					{
-						header,
-						state: options.spinnerFrame !== undefined ? "running" : "pending",
-						sections: [{ lines: capPreviewLines(cmdLines, uiTheme, { expanded: options.expanded }) }],
-						width,
-					},
-					uiTheme,
-				);
-			},
-			invalidate: () => {
-				outputBlock.invalidate();
-			},
-		});
-	},
-
-	renderResult(
-		result: {
-			content: Array<{ type: string; text?: string }>;
-			details?: SSHToolDetails;
-			isError?: boolean;
-		},
-		options: RenderResultOptions & { renderContext?: SshRenderContext },
-		uiTheme: Theme,
-		args?: SshRenderArgs,
-	): Component {
-		const details = result.details;
-		const host = args?.host || "…";
-		const command = args?.command ?? "";
-		const isError = result.isError === true;
-		const isPartial = options.isPartial === true;
-		const header = renderStatusLine(
-			isPartial
-				? { icon: "pending", title: "SSH", description: `[${host}]` }
-				: isError
-					? { icon: "error", title: "SSH", description: `[${host}]` }
-					: { iconOverride: uiTheme.styledSymbol("tool.ssh", "accent"), title: "SSH", description: `[${host}]` },
-			uiTheme,
-		);
-		const cmdLines = formatSshCommandLines(command, uiTheme);
-		const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
-		const outputBlock = new CachedOutputBlock();
-
-		return markFramedBlockComponent({
-			render: (width: number): readonly string[] => {
-				// REACTIVE: read mutable options at render time
-				const { expanded, renderContext } = options;
-				// Strip LLM-facing notice so we don't echo it next to the styled warning.
-				const output = stripOutputNotice(textContent, details?.meta).trimEnd();
-				const outputLines: string[] = [];
-
-				if (output) {
-					if (expanded) {
-						outputLines.push(...output.split("\n").map(line => uiTheme.fg("toolOutput", line)));
-					} else if (renderContext?.visualLines) {
-						const { visualLines, skippedCount = 0, totalVisualLines = visualLines.length } = renderContext;
-						if (skippedCount > 0) {
-							outputLines.push(
-								uiTheme.fg(
-									"dim",
-									`… (${skippedCount} earlier lines, showing ${visualLines.length} of ${totalVisualLines}) (ctrl+o to expand)`,
-								),
-							);
-						}
-						const styledVisual = visualLines.map(line =>
-							line.includes("\x1b[") ? line : uiTheme.fg("toolOutput", line),
-						);
-						outputLines.push(...styledVisual);
-					} else {
-						const outputLinesRaw = output.split("\n");
-						const maxLines = 5;
-						const displayLines = outputLinesRaw.slice(0, maxLines);
-						const remaining = outputLinesRaw.length - maxLines;
-						outputLines.push(...displayLines.map(line => uiTheme.fg("toolOutput", line)));
-						if (remaining > 0) {
-							outputLines.push(uiTheme.fg("dim", `… (${remaining} more lines) (ctrl+o to expand)`));
-						}
-					}
-				}
-
-				if (details?.meta?.truncation) {
-					const warning = formatStyledTruncationWarning(details.meta, uiTheme);
-					if (warning) outputLines.push(warning);
-				}
-
-				return outputBlock.render(
-					{
-						header,
-						state: isPartial ? "pending" : isError ? "error" : "success",
-						sections: [
-							{
-								// Viewport-sized tail window in every state — streaming and final
-								// render identically; only ctrl+o uncaps.
-								lines: capPreviewLines(cmdLines, uiTheme, { expanded }),
-							},
-							{ label: uiTheme.fg("toolTitle", "Output"), lines: outputLines },
-						],
-						width,
-					},
-					uiTheme,
-				);
-			},
-			invalidate: () => {
-				outputBlock.invalidate();
-			},
-		});
-	},
-	mergeCallAndResult: true,
-	// Streamed args can initially render the SSH placeholder (`⏳ SSH: […]` /
-	// `$ …`), then the first partial result inserts the `Output` section and
-	// re-anchors the frame. Force a full repaint only at that streamed-placeholder
-	// seam so placeholder rows do not survive in viewport/native scrollback.
-	forceFirstResultViewportRepaint: hasStreamedRenderArgs,
-	// The provisional pending-result frame settles into the final `⇄ SSH: [host]`
-	// frame, so clear/replay the viewport at that topology flip too.
-	forceResultViewportRepaintOnSettle: true,
-};
diff --git a/packages/coding-agent/src/tools/write.ts b/packages/coding-agent/src/tools/write.ts
index 657e99d38..856eea986 100644
--- a/packages/coding-agent/src/tools/write.ts
+++ b/packages/coding-agent/src/tools/write.ts
@@ -10,7 +10,7 @@ import type {
 	AgentToolUpdateCallback,
 	ToolTier,
 } from "@oh-my-pi/pi-agent-core";
-import type { Component } from "@oh-my-pi/pi-tui";
+import { type Component, Text } from "@oh-my-pi/pi-tui";
 import { isEnoent, isRecord, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type } from "arktype";
 
@@ -19,6 +19,7 @@ import { normalizeToLF } from "../edit/normalize";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { InternalUrlRouter } from "../internal-urls";
 import { parseInternalUrl } from "../internal-urls/parse";
+import { couldBecomeXdUrl, parseXdUrl } from "../internal-urls/xd-protocol";
 import { createLspWritethrough, type FileDiagnosticsResult, type WritethroughCallback, writethroughNoop } from "../lsp";
 import { DeferredDiagnostics } from "../lsp/deferred-diagnostics";
 import { getDiagnosticsLedger } from "../lsp/diagnostics-ledger";
@@ -66,6 +67,8 @@ import {
 	TRUNCATE_LENGTHS,
 	truncateToWidth,
 } from "./render-utils";
+import { dispatchReportIssueDevice, REPORT_ISSUE_DEVICE_NAME, renderReportIssueDeviceCall } from "./report-tool-issue";
+import { dispatchResolutionDevice, isResolutionDeviceName, renderResolutionDeviceCall } from "./resolve";
 import {
 	deleteRowByKey,
 	deleteRowByRowId,
@@ -78,6 +81,7 @@ import {
 } from "./sqlite-reader";
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
+import { renderXdevCall, renderXdevResult, type XdevDispatch } from "./xdev";
 
 const LOOSE_HASHLINE_HEADER_RE = /^\s*\[[^#\r\n]+#[^ \t\r\n]*\]\s*$/;
 const EXECUTABLE_NOTICE = "[Notice: Made executable via chmod +x]";
@@ -191,6 +195,8 @@ export interface WriteToolDetails {
 	/** Absolute filesystem path the write resolved to. Used by the renderer to wrap
 	 * the (possibly cwd-relative) header path in an OSC 8 `file://` hyperlink. */
 	resolvedPath?: string;
+	/** Set when the write dispatched an `xd://` tool device; drives renderer delegation. */
+	xdev?: XdevDispatch;
 }
 
 /**
@@ -384,6 +390,18 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		// Unwrap a hashline `[path#TAG]` wrapper first (parity with execute) so a
 		// wrapped `[ssh://h/x#ABCD]` can't dodge scheme detection and the tier checks below.
 		const path = unwrapHashlineHeaderPath(rawPath);
+		// xd:// device writes execute the mounted tool — take its approval tier.
+		// The resolution devices (xd://resolve, xd://reject, xd://propose)
+		// finalize a staged, already-previewed action, so they stay at read tier.
+		const xdevTarget = parseXdUrl(path);
+		if (xdevTarget) {
+			if (xdevTarget.name === REPORT_ISSUE_DEVICE_NAME) return "write";
+			if (xdevTarget.name && isResolutionDeviceName(xdevTarget.name)) return "read";
+			const inst = xdevTarget.name ? this.session.xdevRegistry?.get(xdevTarget.name) : undefined;
+			const decision = typeof inst?.approval === "function" ? undefined : inst?.approval;
+			const tier = typeof decision === "object" ? decision?.tier : decision;
+			return tier ?? "exec";
+		}
 		// Remote SSH writes open an outbound connection and run a remote shell —
 		// gate them like the exec-tier `ssh` tool, ahead of the handler-write
 		// logic. Substring match also covers selector-suffixed targets.
@@ -956,22 +974,70 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 				const scheme = parsed.protocol.replace(/:$/, "").toLowerCase();
 				const handler = internalRouter.getHandler(scheme);
 				if (handler?.write) {
-					// Handler-owned writes (vault:// notes, host URIs) mutate user
-					// data outside the local sandbox — plan mode must reject them.
-					enforcePlanModeWrite(this.session, path, { op: "update" });
-					emitWriteProgress(onUpdate, cleanContent, path);
-					await handler.write(parsed, cleanContent, { cwd: this.session.cwd, signal });
+					// Handler-owned writes mutate user data outside the local
+					// sandbox. xd:// dispatches retain each wrapped tool's tier.
+					if (scheme !== "xd") {
+						enforcePlanModeWrite(this.session, path, { op: "update" });
+						emitWriteProgress(onUpdate, cleanContent, path);
+					}
+					let xdResult: AgentToolResult<WriteToolDetails> | undefined;
+					await internalRouter.write(path, cleanContent, {
+						cwd: this.session.cwd,
+						signal,
+						xd: {
+							write: async (name, deviceContent) => {
+								if (name === REPORT_ISSUE_DEVICE_NAME) {
+									const { result, xdev } = await dispatchReportIssueDevice(this.session, deviceContent);
+									xdResult = {
+										content: result.content,
+										details: { xdev },
+										isError: result.isError,
+										useless: result.useless,
+									};
+									return;
+								}
+								if (name && isResolutionDeviceName(name)) {
+									const { result, xdev } = await dispatchResolutionDevice(this.session, name, deviceContent);
+									xdResult = {
+										content: result.content,
+										details: { xdev },
+										isError: result.isError,
+										useless: result.useless,
+									};
+									return;
+								}
+								const registry = this.session.xdevRegistry;
+								if (!registry || registry.size === 0) {
+									throw new ToolError("xd:// is not mounted in this session.");
+								}
+								if (!name) {
+									throw new ToolError(`Cannot write to xd:// itself — pick a device:\n${registry.listing()}`);
+								}
+								const { result, xdev } = await registry.dispatch(
+									name,
+									deviceContent,
+									_toolCallId,
+									signal,
+									onUpdate as AgentToolUpdateCallback,
+									context,
+								);
+								xdResult = {
+									content: result.content,
+									details: { xdev },
+									isError: result.isError,
+									useless: result.useless,
+								};
+							},
+						},
+					});
+					if (xdResult) return xdResult;
 					let resultText = `Successfully wrote ${cleanContent.length} bytes to ${path}`;
 					if (stripped) {
 						resultText += `\nNote: auto-stripped hashline display prefixes from content before writing.`;
 					}
 					return { content: [{ type: "text", text: resultText }], details: {} };
 				}
-				if (scheme !== "local") {
-					throw new ToolError(
-						`${scheme}:// URLs are read-only for write; use the protocol-specific tool for mutations.`,
-					);
-				}
+				if (scheme !== "local") await internalRouter.write(path, cleanContent);
 				// local:// is backed by the session-local artifact sandbox and is
 				// resolved by resolvePlanPath below so write/read share the same root.
 			}
@@ -1254,10 +1320,33 @@ function renderContentPreview(
 	});
 }
 
+/** Render context for the write tool: resolves an `xd://`-mounted tool so its live renderer drives device dispatch previews. */
+export interface WriteRenderContext {
+	resolveXdevMounted?: (name: string) => AgentTool | undefined;
+}
+
 export const writeToolRenderer = {
-	renderCall(args: WriteRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
+	renderCall(
+		args: WriteRenderArgs,
+		options: RenderResultOptions & { renderContext?: WriteRenderContext },
+		uiTheme: Theme,
+	): Component | undefined {
 		const rawPath =
 			typeof args.file_path === "string" ? args.file_path : typeof args.path === "string" ? args.path : "";
+		// Render NOTHING until the streamed path arrives and provably is not an
+		// xd:// device; xd:// writes then delegate to the mounted tool's renderer.
+		// A present-but-malformed path (array/object from a bad provider parse)
+		// is definitively not xd:// — fall through to the legacy frame.
+		if (args.path === undefined && args.file_path === undefined) return undefined;
+		if (rawPath && couldBecomeXdUrl(rawPath)) {
+			const xdev = parseXdUrl(rawPath);
+			// The path string is settled once the content field started streaming.
+			const pathSettled = args.content !== undefined;
+			if (!xdev?.name || !pathSettled) return undefined;
+			if (isResolutionDeviceName(xdev.name)) return renderResolutionDeviceCall(xdev.name, args.content, uiTheme);
+			if (xdev.name === REPORT_ISSUE_DEVICE_NAME) return renderReportIssueDeviceCall(args.content, uiTheme);
+			return renderXdevCall(xdev.name, args.content, options, uiTheme, options.renderContext?.resolveXdevMounted);
+		}
 		const filePath = shortenPath(rawPath);
 		const lang = rawPath ? (getLanguageFromPath(rawPath) ?? "text") : "text";
 		const langIcon = uiTheme.fg("muted", uiTheme.getLangIcon(lang));
@@ -1300,10 +1389,18 @@ export const writeToolRenderer = {
 
 	renderResult(
 		result: { content: Array<{ type: string; text?: string }>; details?: WriteToolDetails; isError?: boolean },
-		options: RenderResultOptions,
+		options: RenderResultOptions & { renderContext?: WriteRenderContext },
 		uiTheme: Theme,
 		args?: WriteRenderArgs,
 	): Component {
+		// xd:// dispatch results render as the mounted tool's own result.
+		const xdev = result.details?.xdev;
+		if (xdev) {
+			const delegated = renderXdevResult(xdev, result, options, uiTheme, options.renderContext?.resolveXdevMounted);
+			if (delegated) return delegated;
+			const text = result.content?.find(c => c.type === "text")?.text ?? "";
+			return new Text(uiTheme.fg("toolOutput", replaceTabs(text)), 0, 0);
+		}
 		const rawPath =
 			typeof args?.file_path === "string" ? args.file_path : typeof args?.path === "string" ? args.path : "";
 		const filePath = shortenPath(rawPath);
diff --git a/packages/coding-agent/src/tools/xdev.ts b/packages/coding-agent/src/tools/xdev.ts
new file mode 100644
index 000000000..bc496272a
--- /dev/null
+++ b/packages/coding-agent/src/tools/xdev.ts
@@ -0,0 +1,362 @@
+/**
+ * `xd://` virtual tool devices.
+ *
+ * Discoverable built-ins and custom tools are unmounted from the request's
+ * tools array and exposed as internal URLs driven through the `read`/`write`
+ * tools the model already has:
+ *
+ *   read  xd://          → mounted tool listing (discovery)
+ *   read  xd://<tool>    → tool docs + JSON parameter schema
+ *   write xd://<tool>    → execute: `content` is the JSON args object
+ *
+ * Args go through the same machinery as native tool calls: validated with
+ * pi-ai's `validateToolArguments` (the schema is returned on mismatch, so a
+ * malformed call self-corrects without a round trip) and streamed through
+ * the write tool's existing incremental `content` decoding for live render
+ * previews. Compared to a dispatcher def this still costs zero *schema
+ * duplication* — one wire schema per tool instead of one per dispatcher
+ * branch — but full docs + schema for every mounted device are inlined into
+ * the system prompt (`XdevRegistry.docsAll()`) so no discovery `read` is
+ * needed before first use; `read xd://<tool>` remains for on-demand re-fetch.
+ *
+ * Rendering: the write renderer draws NOTHING until the streamed `path` is
+ * known and provably does not target `xd://`; device writes then delegate to
+ * the wrapped tool's own renderer with the decoded inner args.
+ */
+import type { AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolLoadMode } from "@oh-my-pi/pi-agent-core";
+import { type Tool as AiTool, toolWireSchema, validateToolArguments } from "@oh-my-pi/pi-ai";
+import { type Component, Container, Text } from "@oh-my-pi/pi-tui";
+import { parseStreamingJson } from "@oh-my-pi/pi-utils";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { XD_URL_PREFIX } from "../internal-urls/xd-protocol";
+import type { Theme } from "../modes/theme/theme";
+import type { Tool } from "./index";
+import { replaceTabs } from "./render-utils";
+import type { ToolRenderer } from "./renderers";
+import { ToolError } from "./tool-errors";
+
+/**
+ * Discoverable built-ins that must stay top-level even when xdev mounting is
+ * active: `todo` feeds the todo prelude/prewalk machinery, `ask` is the
+ * model's user-interaction affordance, and `grep` is the redirect target of
+ * the bash interceptor rules — each loses its harness integration if hidden
+ * behind dispatch.
+ */
+export const XDEV_KEEP_TOP_LEVEL: Record<string, true> = { todo: true, ask: true, grep: true };
+
+/**
+ * Whether an enabled tool is presented under `xd://` (rather than top-level)
+ * while the `xd://` transport is active. Discoverable tools mount unless they
+ * are pinned top-level by {@link XDEV_KEEP_TOP_LEVEL}; essential tools never do.
+ * The caller gates this on the transport being active (a session-owned
+ * {@link XdevRegistry} existing).
+ */
+export function isMountableUnderXdev(tool: { name: string; loadMode?: ToolLoadMode }): boolean {
+	return tool.loadMode === "discoverable" && !(tool.name in XDEV_KEEP_TOP_LEVEL);
+}
+
+/** Dispatch metadata carried on write-tool details for renderer delegation. */
+export interface XdevDispatch {
+	tool: string;
+	mode: "help" | "execute";
+	/** Validated inner args, kept for renderer delegation on result rebuilds. */
+	args?: Record<string, unknown>;
+	/** Details object returned by the wrapped tool, when executed. */
+	inner?: unknown;
+}
+
+/**
+ * Renderer lookup injected by `renderers.ts` at module init. Kept as a setter
+ * to avoid the xdev → renderers → tool modules → sdk → tools/index → xdev
+ * import cycle.
+ */
+let rendererLookup: ((name: string) => ToolRenderer | undefined) | undefined;
+
+/** Wire the wrapped-renderer lookup. Called once by `renderers.ts`. */
+export function setXdevRendererLookup(lookup: (name: string) => ToolRenderer | undefined): void {
+	rendererLookup = lookup;
+}
+
+/** Whether a wire JSON schema declares a top-level `i` (intent) property. */
+function schemaDeclaresIntentField(schema: unknown): boolean {
+	if (!schema || typeof schema !== "object" || !("properties" in schema)) return false;
+	const props = schema.properties;
+	return !!props && typeof props === "object" && "i" in props;
+}
+
+function renderDocs(inst: Tool, heading = "#"): string {
+	const schema = JSON.stringify(toolWireSchema(inst as AiTool), null, 1);
+	return [
+		`${heading} ${inst.name}${inst.label ? ` — ${inst.label}` : ""}`,
+		"",
+		inst.description ?? "",
+		"",
+		`${heading}# Parameters (JSON schema)`,
+		"```json",
+		schema,
+		"```",
+		`Execute by writing the JSON args object to ${XD_URL_PREFIX}${inst.name}.`,
+	].join("\n");
+}
+
+/**
+ * Parse and validate a device write's JSON `content` against the wrapped
+ * tool's wire schema. Strips a habitual top-level `i` (intent) unless the
+ * schema declares one. Throws ToolError; schema-mismatch errors carry `docs()`
+ * for repair.
+ */
+function parseDeviceArgs(
+	device: AiTool,
+	content: string,
+	toolCallId: string,
+	docs: () => string,
+): Record<string, unknown> {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(content);
+	} catch (error) {
+		throw new ToolError(
+			`${XD_URL_PREFIX}${device.name} expects a JSON args object as content (${error instanceof Error ? error.message : String(error)}). Write \`?\` for docs.`,
+		);
+	}
+	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+		throw new ToolError(
+			`${XD_URL_PREFIX}${device.name} content must be a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}.`,
+		);
+	}
+	// The harness only injects the intent field into top-level schemas; strip a
+	// habitual `i` from inner args unless the wrapped schema really declares it.
+	const args: Record<string, unknown> = { ...(parsed as Record<string, unknown>) };
+	if ("i" in args && !schemaDeclaresIntentField(toolWireSchema(device))) delete args.i;
+	try {
+		return validateToolArguments(device, {
+			type: "toolCall",
+			id: toolCallId,
+			name: device.name,
+			arguments: args,
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new ToolError(`Invalid args for ${XD_URL_PREFIX}${device.name}: ${message}\n\n${docs()}`);
+	}
+}
+
+/** One-line catalog summary for a mounted tool: `summary`, else first description line. */
+function toolSummary(inst: Tool): string {
+	if (inst.summary) return inst.summary;
+	const firstLine = (inst.description ?? "").split("\n").find(line => line.trim().length > 0);
+	return firstLine?.trim() ?? inst.label ?? inst.name;
+}
+
+/** Decode the (possibly partially streamed) inner args JSON string into display args. */
+function decodeInnerArgs(raw: unknown): Record<string, unknown> {
+	if (typeof raw !== "string" || raw.length === 0) return {};
+	const parsed = parseStreamingJson<Record<string, unknown>>(raw);
+	const args: Record<string, unknown> = parsed && typeof parsed === "object" ? { ...parsed } : {};
+	args.__partialJson = raw;
+	return args;
+}
+
+/** Device-write content that requests docs instead of executing: empty, `?`, or `help`. */
+const HELP_CONTENT_RE = /^\s*(\?|help)?\s*$/i;
+
+/**
+ * Registry of tools mounted under `xd://` for one session. `createTools`
+ * mounts discoverable built-ins first; SDK assembly adds custom tools that do
+ * not opt out. `read`/`write` consult it at execute time.
+ */
+export class XdevRegistry {
+	/** Discoverable built-ins mounted at construction; never reconciled away. */
+	#builtins = new Map<string, Tool>();
+	/**
+	 * Dynamic mounts (custom, MCP, extension, autoresearch) — replaced wholesale
+	 * by {@link reconcile} as the active tool set changes, so a deactivated or
+	 * disconnected tool is no longer callable through a stale device.
+	 */
+	#dynamic = new Map<string, Tool>();
+
+	constructor(builtins: Iterable<Tool>) {
+		for (const tool of builtins) this.#builtins.set(tool.name, tool);
+	}
+
+	/**
+	 * Replace the dynamic mount set while preserving the built-in devices. Order
+	 * follows `tools`; names absent from it are dropped. A built-in device is
+	 * never shadowed by a same-named dynamic entry.
+	 */
+	reconcile(tools: Iterable<Tool>): void {
+		const next = new Map<string, Tool>();
+		for (const tool of tools) {
+			if (this.#builtins.has(tool.name)) continue;
+			next.set(tool.name, tool);
+		}
+		this.#dynamic = next;
+	}
+
+	get size(): number {
+		return this.#builtins.size + this.#dynamic.size;
+	}
+
+	/** Mounted tools in catalog order: built-ins first, then dynamic mounts. */
+	list(): readonly Tool[] {
+		return [...this.#builtins.values(), ...this.#dynamic.values()];
+	}
+
+	get(name: string): Tool | undefined {
+		return this.#builtins.get(name) ?? this.#dynamic.get(name);
+	}
+
+	/** `{name, summary}` pairs for prompt templates and /tools display. */
+	entries(): Array<{ name: string; summary: string }> {
+		return this.list().map(tool => ({ name: tool.name, summary: toolSummary(tool) }));
+	}
+
+	/** `read xd://` listing with one device per line. */
+	listing(): string {
+		const rows = this.entries().map(({ name, summary }) => `${XD_URL_PREFIX}${name.padEnd(14)} ${summary}`);
+		return [
+			`${XD_URL_PREFIX} ${this.size} mounted tool devices.`,
+			...rows,
+			"",
+			`Read ${XD_URL_PREFIX}<tool> for docs + JSON schema; write the JSON args object to ${XD_URL_PREFIX}<tool> to execute.`,
+		].join("\n");
+	}
+
+	/** Docs + schema for one device; throws with the listing when unknown. */
+	docs(name: string): string {
+		return renderDocs(this.#resolve(name));
+	}
+
+	/** Full docs + schema for every mounted device, nested under a `##` heading for system-prompt embedding. */
+	docsAll(): string {
+		return this.list()
+			.map(tool => renderDocs(tool, "##"))
+			.join("\n\n");
+	}
+
+	#resolve(name: string): Tool {
+		const inst = this.get(name);
+		if (!inst) {
+			throw new ToolError(
+				`No such tool device: ${XD_URL_PREFIX}${name}. Mounted: ${this.list()
+					.map(tool => tool.name)
+					.join(", ")}.`,
+			);
+		}
+		return inst;
+	}
+
+	/**
+	 * Execute a device write: `content` is the JSON args object (empty, `?`, or
+	 * `help` returns docs). Args validate against the wrapped tool's schema —
+	 * the schema comes back in the error on mismatch.
+	 */
+	async dispatch(
+		name: string,
+		content: string,
+		toolCallId: string,
+		signal?: AbortSignal,
+		onUpdate?: AgentToolUpdateCallback,
+		context?: AgentToolContext,
+	): Promise<{ result: AgentToolResult<unknown>; xdev: XdevDispatch }> {
+		const inst = this.#resolve(name);
+
+		if (HELP_CONTENT_RE.test(content)) {
+			return {
+				result: { content: [{ type: "text", text: renderDocs(inst) }] },
+				xdev: { tool: name, mode: "help" },
+			};
+		}
+
+		const validated = parseDeviceArgs(inst as AiTool, content, toolCallId, () => renderDocs(inst));
+
+		const xdevBase: XdevDispatch = { tool: name, mode: "execute", args: validated };
+		const innerOnUpdate: AgentToolUpdateCallback | undefined = onUpdate
+			? partial =>
+					onUpdate({
+						content: partial.content,
+						details: { xdev: { ...xdevBase, inner: partial.details } },
+						isError: partial.isError,
+					})
+			: undefined;
+		const result = await inst.execute(toolCallId, validated as never, signal, innerOnUpdate, context);
+		return { result, xdev: { ...xdevBase, inner: result.details } };
+	}
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Render delegation (consumed by the write renderer)
+// ═══════════════════════════════════════════════════════════════════════════
+
+/** Renderer for a mounted device: the live mounted tool's own render callbacks
+ *  (custom/MCP/image tools carry them) first, then the static built-in renderer
+ *  map keyed by name. */
+function resolveDeviceRenderer(
+	name: string,
+	resolveMounted: ((name: string) => Tool | undefined) | undefined,
+): Pick<ToolRenderer, "renderCall" | "renderResult" | "mergeCallAndResult"> | undefined {
+	const mounted = resolveMounted?.(name);
+	if (mounted && (mounted.renderCall || mounted.renderResult)) {
+		// A mounted AgentTool exposes the same renderCall/renderResult/mergeCallAndResult
+		// surface as a static ToolRenderer; only the parameter generics differ, so unify
+		// through a single cast rather than fabricating a per-field shape.
+		return mounted as unknown as Pick<ToolRenderer, "renderCall" | "renderResult" | "mergeCallAndResult">;
+	}
+	return rendererLookup?.(name);
+}
+
+/**
+ * Streaming-safe call preview for an `xd://` write: forwards the decoded inner
+ * args to the mounted tool's renderer (session instance first, then the static
+ * map). Returns `undefined` (render nothing) when no renderer produces output.
+ */
+export function renderXdevCall(
+	name: string,
+	content: unknown,
+	options: RenderResultOptions,
+	theme: Theme,
+	resolveMounted?: (name: string) => Tool | undefined,
+): Component | undefined {
+	const renderer = resolveDeviceRenderer(name, resolveMounted);
+	if (renderer?.renderCall) {
+		return renderer.renderCall(decodeInnerArgs(content), options, theme);
+	}
+	return new Text(theme.fg("toolTitle", theme.bold(`${XD_URL_PREFIX}${name}`)), 0, 0);
+}
+
+/** Forward an `xd://` dispatch result to the mounted tool's renderer. */
+export function renderXdevResult(
+	dispatch: XdevDispatch,
+	result: { content: Array<{ type: string; text?: string }>; isError?: boolean },
+	options: RenderResultOptions,
+	theme: Theme,
+	resolveMounted?: (name: string) => Tool | undefined,
+): Component | undefined {
+	const text = result.content
+		.map(block => (block.type === "text" ? block.text : ""))
+		.filter(Boolean)
+		.join("\n");
+	if (dispatch.mode === "help") {
+		return text ? new Text(theme.fg("toolOutput", replaceTabs(text)), 0, 0) : undefined;
+	}
+	const renderer = resolveDeviceRenderer(dispatch.tool, resolveMounted);
+	const innerResult = { content: result.content, details: dispatch.inner, isError: result.isError };
+	if (renderer?.renderResult) {
+		const parts: Component[] = [];
+		// Emulate the unmerged call+result topology inside the write block for
+		// renderers that expect a separate call header.
+		if (!renderer.mergeCallAndResult && renderer.renderCall) {
+			const call = renderer.renderCall(dispatch.args ?? {}, { ...options, isPartial: false }, theme);
+			if (call) parts.push(call);
+		}
+		const rendered = renderer.renderResult(innerResult, options, theme, dispatch.args ?? {});
+		if (rendered) parts.push(rendered);
+		if (parts.length === 1) return parts[0];
+		if (parts.length > 1) {
+			const box = new Container();
+			for (const part of parts) box.addChild(part);
+			return box;
+		}
+	}
+	return text ? new Text(theme.fg("toolOutput", replaceTabs(text)), 0, 0) : undefined;
+}
diff --git a/packages/coding-agent/src/vibe/runtime.ts b/packages/coding-agent/src/vibe/runtime.ts
index 7d55b48c5..08610420c 100644
--- a/packages/coding-agent/src/vibe/runtime.ts
+++ b/packages/coding-agent/src/vibe/runtime.ts
@@ -11,7 +11,7 @@
  *
  * Every turn runs as an AsyncJobManager job, so a completed turn self-delivers
  * into the director's conversation exactly like an async `task` result, and
- * `vibe_wait` can block on the first settling turn with `job`-poll semantics.
+ * `vibe_wait` can block on the first settling turn with `hub`-wait semantics.
  */
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
@@ -357,7 +357,7 @@ export class VibeSessionRegistry {
 
 	/**
 	 * Block until one watched session's in-flight turn settles, the timeout
-	 * elapses, or `signal` aborts — `job` poll semantics. Settled turns are
+	 * elapses, or `signal` aborts — `hub` wait semantics. Settled turns are
 	 * acknowledged against the job manager so their results are not delivered
 	 * a second time as async follow-ups.
 	 */
diff --git a/packages/coding-agent/test/acp-agent.test.ts b/packages/coding-agent/test/acp-agent.test.ts
index 886fedb6c..ba558077b 100644
--- a/packages/coding-agent/test/acp-agent.test.ts
+++ b/packages/coding-agent/test/acp-agent.test.ts
@@ -183,8 +183,6 @@ class FakeAgentSession {
 		// no-op for tests
 	}
 
-	async refreshSshTool(_options?: { activateIfAvailable?: boolean }): Promise<void> {}
-
 	async setModel(model: Model): Promise<void> {
 		this.model = model;
 	}
@@ -316,14 +314,14 @@ class FakeAgentSession {
 		this.planModeState = state;
 	}
 
-	standingResolveHandler: ((input: unknown) => Promise<unknown> | unknown) | undefined;
+	planProposalHandler: ((title: string) => Promise<unknown> | unknown) | undefined;
 
-	setStandingResolveHandler(handler: ((input: unknown) => Promise<unknown> | unknown) | null): void {
-		this.standingResolveHandler = handler ?? undefined;
+	setPlanProposalHandler(handler: ((title: string) => Promise<unknown> | unknown) | null): void {
+		this.planProposalHandler = handler ?? undefined;
 	}
 
-	peekStandingResolveHandler(): ((input: unknown) => Promise<unknown> | unknown) | undefined {
-		return this.standingResolveHandler;
+	peekPlanProposalHandler(): ((title: string) => Promise<unknown> | unknown) | undefined {
+		return this.planProposalHandler;
 	}
 
 	planReferencePath: string | undefined;
@@ -614,20 +612,20 @@ describe("ACP agent", () => {
 				: undefined;
 		expect(currentModeConfig?.currentValue).toBe("plan");
 
-		// Regression for #1869: entering plan mode must wire a standing
-		// resolve handler so the agent's `resolve { action: "apply" }` has a
-		// gate to dispatch to instead of throwing "No pending action".
-		expect(typeof session.standingResolveHandler).toBe("function");
+		// Regression for #1869: entering plan mode must wire a plan-proposal
+		// handler so the agent's `xd://propose` write has a gate to dispatch to
+		// instead of erroring with no approval path.
+		expect(typeof session.planProposalHandler).toBe("function");
 
 		await harness.agent.setSessionMode({ sessionId: created.sessionId, modeId: "default" });
 		expect(session.planModeState).toBeUndefined();
-		expect(session.standingResolveHandler).toBeUndefined();
+		expect(session.planProposalHandler).toBeUndefined();
 
 		harness.abortController.abort();
 		await Bun.sleep(0);
 	});
 
-	it("plan-approval standing handler errors when the plan file is missing", async () => {
+	it("plan-proposal handler errors when the plan file is missing", async () => {
 		const harness = await createHarness();
 		Settings.instance.set("plan.enabled", true);
 
@@ -635,23 +633,21 @@ describe("ACP agent", () => {
 		const session = harness.findSession(created.sessionId)!;
 		await harness.agent.setSessionMode({ sessionId: created.sessionId, modeId: "plan" });
 
-		const handler = session.standingResolveHandler;
+		const handler = session.planProposalHandler;
 		expect(typeof handler).toBe("function");
 
 		// No plan file written → handler surfaces a ToolError telling the
 		// agent to write the plan before requesting approval.
-		await expect(handler!({ action: "apply", reason: "Plan done.", extra: { title: "demo" } })).rejects.toThrow(
-			/Plan file not found/,
-		);
+		await expect(handler!("demo")).rejects.toThrow(/Plan file not found/);
 		// Plan mode must remain active so the agent can recover.
 		expect(session.planModeState?.enabled).toBe(true);
-		expect(typeof session.standingResolveHandler).toBe("function");
+		expect(typeof session.planProposalHandler).toBe("function");
 
 		harness.abortController.abort();
 		await Bun.sleep(0);
 	});
 
-	it("plan-approval standing handler approves the agent-named plan and exits plan mode on apply", async () => {
+	it("plan-proposal handler approves the agent-named plan and exits plan mode on submit", async () => {
 		const harness = await createHarness();
 		Settings.instance.set("plan.enabled", true);
 
@@ -670,26 +666,22 @@ describe("ACP agent", () => {
 		await Bun.write(planPath, "# Words Counter\n\nFile contents.");
 
 		const updatesBefore = harness.updates.length;
-		const handler = session.standingResolveHandler!;
-		const result = (await handler({
-			action: "apply",
-			reason: "Plan complete and self-contained.",
-			extra: { title: "words-counter" },
-		})) as {
+		const handler = session.planProposalHandler!;
+		const result = (await handler("words-counter")) as {
 			content: Array<{ type: string; text: string }>;
-			details: { sourceToolName: string; sourceResultDetails: { planFilePath: string; title: string } };
+			details: { planFilePath: string; title: string; planExists: boolean };
 		};
 
 		// Plan-approval payload is shaped for `event-controller` / ACP renderers.
-		expect(result.details.sourceToolName).toBe("plan_approval");
-		expect(result.details.sourceResultDetails.title).toBe("words-counter");
-		expect(result.details.sourceResultDetails.planFilePath).toBe("local://words-counter-plan.md");
+		expect(result.details.title).toBe("words-counter");
+		expect(result.details.planFilePath).toBe("local://words-counter-plan.md");
+		expect(result.details.planExists).toBe(true);
 		expect(result.content[0]?.text).toMatch(/Plan approved/);
 		// Plan file keeps its agent-chosen name — no rename.
 		expect(await Bun.file(planPath).exists()).toBe(true);
 		// Mode + handler are cleared; the agent regains write tools next turn.
 		expect(session.planModeState).toBeUndefined();
-		expect(session.standingResolveHandler).toBeUndefined();
+		expect(session.planProposalHandler).toBeUndefined();
 		expect(session.planReferencePath).toBe("local://words-counter-plan.md");
 		const approvalUpdates = harness.updates.slice(updatesBefore);
 		// Mode-change notifications reached the client so Zed's UI and config
@@ -716,7 +708,7 @@ describe("ACP agent", () => {
 		await Bun.sleep(0);
 	});
 
-	it("plan-approval standing handler treats dismissed elicitation as refine, never approves", async () => {
+	it("plan-proposal handler treats dismissed elicitation as refine, never approves", async () => {
 		// Regression for the P1 review finding on #1870: when a form-capable
 		// ACP client dismissed/cancelled the elicitation, the handler was
 		// returning the dismissal as approval — silently granting write
@@ -741,20 +733,16 @@ describe("ACP agent", () => {
 		await Bun.write(planPath, "# Words Counter\n\nFile contents.");
 
 		const updatesBefore = harness.updates.length;
-		const handler = session.standingResolveHandler!;
-		const result = (await handler({
-			action: "apply",
-			reason: "Plan complete.",
-			extra: { title: "words-counter" },
-		})) as { content: Array<{ type: string; text: string }> };
+		const handler = session.planProposalHandler!;
+		const result = (await handler("words-counter")) as { content: Array<{ type: string; text: string }> };
 
 		expect(result.content[0]?.text).toMatch(/refinement requested/i);
 		// Plan file stays put; no rename, no write-access grant.
 		expect(await Bun.file(planPath).exists()).toBe(true);
 		expect(await Bun.file(resolveLocalUrlToPath("local://words-counter.md", localOptions)).exists()).toBe(false);
-		// Plan mode + standing handler stay active so the agent can iterate.
+		// Plan mode + proposal handler stay active so the agent can iterate.
 		expect(session.planModeState?.enabled).toBe(true);
-		expect(typeof session.standingResolveHandler).toBe("function");
+		expect(typeof session.planProposalHandler).toBe("function");
 		expect(session.planReferencePath).toBeUndefined();
 		// No mode-exit notifications were emitted.
 		const postDismissUpdates = harness.updates.slice(updatesBefore);
diff --git a/packages/coding-agent/test/acp-builtins.test.ts b/packages/coding-agent/test/acp-builtins.test.ts
index 7d6ff697f..fe92f3b91 100644
--- a/packages/coding-agent/test/acp-builtins.test.ts
+++ b/packages/coding-agent/test/acp-builtins.test.ts
@@ -45,7 +45,6 @@ interface FakeAcpBuiltinSession {
 	getTodoPhases(): Array<{ name: string; tasks: Array<{ content: string; status: string }> }>;
 	setTodoPhases(phases: Array<{ name: string; tasks: Array<{ content: string; status: string }> }>): void;
 	refreshBaseSystemPrompt(): Promise<void>;
-	refreshSshTool(options?: { activateIfAvailable?: boolean }): Promise<void>;
 	getToolByName(name: string): unknown;
 	compact(args?: string): Promise<void>;
 	getContextUsage(): { tokens?: number; contextWindow: number } | undefined;
@@ -153,7 +152,6 @@ function createRuntime() {
 		getContextUsage: () => undefined,
 		getAvailableModels: () => [] as Array<{ provider: string; id: string; contextWindow?: number }>,
 		async setModel(_model: unknown) {},
-		async refreshSshTool(_options?: { activateIfAvailable?: boolean }) {},
 	};
 	const typedSession = session as unknown as AgentSession & FakeAcpBuiltinSession;
 	fakeSessionManager = {
diff --git a/packages/coding-agent/test/acp-lazy-startup.test.ts b/packages/coding-agent/test/acp-lazy-startup.test.ts
index 3bfea3c77..99556211e 100644
--- a/packages/coding-agent/test/acp-lazy-startup.test.ts
+++ b/packages/coding-agent/test/acp-lazy-startup.test.ts
@@ -90,7 +90,6 @@ class LazyFakeSession {
 
 	setThinkingLevel(): void {}
 	setSlashCommands(): void {}
-	async refreshSshTool(): Promise<void> {}
 	async setModel(): Promise<void> {}
 	subscribe(): () => void {
 		return () => {};
diff --git a/packages/coding-agent/test/agent-session-mcp-discovery.test.ts b/packages/coding-agent/test/agent-session-mcp-discovery.test.ts
deleted file mode 100644
index b642b72df..000000000
--- a/packages/coding-agent/test/agent-session-mcp-discovery.test.ts
+++ /dev/null
@@ -1,1072 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "bun:test";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import {
-	Agent,
-	type AgentTool,
-	type AgentToolContext,
-	type AgentToolResult,
-	ThinkingLevel,
-} from "@oh-my-pi/pi-agent-core";
-import { Effort, type Model } from "@oh-my-pi/pi-ai";
-import { buildModel } from "@oh-my-pi/pi-catalog/build";
-import { Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
-import type { CustomTool } from "@oh-my-pi/pi-coding-agent/extensibility/custom-tools/types";
-import { AgentSession } from "@oh-my-pi/pi-coding-agent/session/agent-session";
-import { SessionManager } from "@oh-my-pi/pi-coding-agent/session/session-manager";
-import type { OutputMeta } from "@oh-my-pi/pi-coding-agent/tools/output-meta";
-import { removeSyncWithRetries } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
-
-function createModel(): Model<"openai-responses"> {
-	return buildModel({
-		id: "mock",
-		name: "mock",
-		api: "openai-responses",
-		provider: "openai",
-		baseUrl: "https://example.invalid",
-		reasoning: false,
-		input: ["text"],
-		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-		contextWindow: 8192,
-		maxTokens: 2048,
-	});
-}
-
-function createBasicTool(name: string, label: string): AgentTool {
-	const schema = type({ value: "string" });
-	return {
-		name,
-		label,
-		description: `${label} tool`,
-		parameters: schema,
-		strict: true,
-		async execute() {
-			return { content: [{ type: "text", text: `${name} executed` }] };
-		},
-	};
-}
-
-function createMcpTool(
-	name: string,
-	serverName: string,
-	mcpToolName: string,
-	description: string,
-	schemaKeys: string[],
-): AgentTool {
-	const properties: Record<string, unknown> = {};
-	for (const key of schemaKeys) {
-		properties[key] = "string";
-	}
-	return {
-		name,
-		label: `${serverName}/${mcpToolName}`,
-		description,
-		parameters: type(properties),
-		strict: true,
-		mcpServerName: serverName,
-		mcpToolName,
-		async execute() {
-			return { content: [{ type: "text", text: `${name} executed` }] };
-		},
-	} as AgentTool;
-}
-
-function createMcpCustomTool(
-	name: string,
-	serverName: string,
-	mcpToolName: string,
-	description: string,
-	schemaKeys: string[],
-): CustomTool {
-	const properties: Record<string, unknown> = {};
-	for (const key of schemaKeys) {
-		properties[key] = "string";
-	}
-	return {
-		name,
-		label: `${serverName}/${mcpToolName}`,
-		description,
-		parameters: type(properties),
-		mcpServerName: serverName,
-		mcpToolName,
-		async execute() {
-			return { content: [{ type: "text", text: `${name} executed` }] };
-		},
-	} as CustomTool;
-}
-
-/** MCP custom tool whose execute returns a fixed (large) text payload. */
-function createOversizedMcpTool(name: string, serverName: string, mcpToolName: string, text: string): CustomTool {
-	return {
-		name,
-		label: `${serverName}/${mcpToolName}`,
-		description: `${mcpToolName} dump`,
-		parameters: type("object"),
-		mcpServerName: serverName,
-		mcpToolName,
-		async execute() {
-			return { content: [{ type: "text", text }] };
-		},
-	} as CustomTool;
-}
-
-/**
- * Execute-time context with tiny spill thresholds so a few KB of output trips
- * the artifact spill deterministically. The spill reads `context.settings`, not
- * the session's settings, so the budget lives here.
- */
-function createSpillContext(sessionManager: SessionManager = SessionManager.inMemory()): AgentToolContext {
-	return {
-		sessionManager,
-		settings: Settings.isolated({
-			"tools.artifactSpillThreshold": 1,
-			"tools.artifactHeadBytes": 1,
-			"tools.artifactTailBytes": 1,
-			"tools.artifactTailLines": 5,
-		}),
-		modelRegistry: {} as never,
-		model: undefined,
-		isIdle: () => true,
-		hasQueuedMessages: () => false,
-		abort: () => {},
-	} as unknown as AgentToolContext;
-}
-
-function textOf(result: AgentToolResult): string {
-	return result.content
-		.filter((c): c is { type: "text"; text: string } => c.type === "text")
-		.map(c => c.text)
-		.join("\n");
-}
-
-describe("AgentSession MCP discovery", () => {
-	const sessions: AgentSession[] = [];
-	const tempDirs: string[] = [];
-
-	afterEach(async () => {
-		for (const session of sessions.splice(0)) {
-			await session.dispose();
-		}
-		for (const tempDir of tempDirs.splice(0)) {
-			removeSyncWithRetries(tempDir);
-		}
-	});
-
-	it("caches discoverable MCP search indexes until MCP tools refresh", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const docsSearchTool = createMcpTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]);
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[docsSearchTool.name, docsSearchTool],
-		]);
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: [readTool],
-				messages: [],
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: true,
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		const firstIndex = session.getDiscoverableToolSearchIndex();
-		const secondIndex = session.getDiscoverableToolSearchIndex();
-		expect(secondIndex).toBe(firstIndex);
-		expect(firstIndex.documents.map(document => document.tool.name)).toEqual(["mcp__docs_search"]);
-
-		await session.refreshMCPTools([
-			createMcpCustomTool("mcp__pager_list", "pager", "list", "List pager alerts", ["service"]),
-		]);
-
-		const refreshedIndex = session.getDiscoverableToolSearchIndex();
-		expect(refreshedIndex).not.toBe(firstIndex);
-		expect(refreshedIndex.documents.map(document => document.tool.name)).toEqual(["mcp__pager_list"]);
-	});
-
-	it("reports only currently active MCP tools in non-discovery sessions", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const docsSearchTool = createMcpTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]);
-		const slackSendTool = createMcpTool("mcp__slack_send_message", "slack", "send_message", "Send a Slack message", [
-			"channel",
-			"text",
-		]);
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[docsSearchTool.name, docsSearchTool],
-			[slackSendTool.name, slackSendTool],
-		]);
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: [readTool, docsSearchTool],
-				messages: [],
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "mcp.discoveryMode": false }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: false,
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search"]);
-
-		await session.setActiveToolsByName(["read"]);
-
-		expect(session.getSelectedMCPToolNames()).toEqual([]);
-		expect(session.getActiveToolNames()).toEqual(["read"]);
-		expect(session.systemPrompt).toEqual(["tools:read"]);
-	});
-
-	it("keeps manually deactivated MCP tools off after refresh in non-discovery sessions", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const docsSearchTool = createMcpTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]);
-		const slackSendTool = createMcpTool("mcp__slack_send_message", "slack", "send_message", "Send a Slack message", [
-			"channel",
-			"text",
-		]);
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[docsSearchTool.name, docsSearchTool],
-			[slackSendTool.name, slackSendTool],
-		]);
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: [readTool, docsSearchTool],
-				messages: [],
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "mcp.discoveryMode": false }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: false,
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		await session.setActiveToolsByName(["read"]);
-		expect(session.getSelectedMCPToolNames()).toEqual([]);
-
-		await session.refreshMCPTools([
-			createMcpCustomTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]),
-			createMcpCustomTool("mcp__slack_send_message", "slack", "send_message", "Send a Slack message", [
-				"channel",
-				"text",
-			]),
-		]);
-
-		expect(session.getSelectedMCPToolNames()).toEqual([]);
-		expect(session.getActiveToolNames()).toEqual(["read"]);
-		expect(session.systemPrompt).toEqual(["tools:read"]);
-	});
-
-	it("activates all new MCP tools when activateAll is true, even with discovery off", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const toolRegistry = new Map([[readTool.name, readTool]]);
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: [readTool],
-				messages: [],
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "mcp.discoveryMode": false }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: false,
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		// Start with only non-MCP tools active — no MCP tools in registry.
-		expect(session.getActiveToolNames()).toEqual(["read"]);
-		expect(session.getSelectedMCPToolNames()).toEqual([]);
-
-		// Load MCP tools via activateAll path (simulating ACP client provisioning).
-		await session.refreshMCPTools(
-			[
-				createMcpCustomTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]),
-				createMcpCustomTool("mcp__slack_send_message", "slack", "send_message", "Send a Slack message", [
-					"channel",
-					"text",
-				]),
-			],
-			{ activateAll: true },
-		);
-
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search", "mcp__slack_send_message"]);
-		expect(session.getActiveToolNames()).toEqual(["read", "mcp__docs_search", "mcp__slack_send_message"]);
-		expect(session.systemPrompt).toEqual(["tools:read,mcp__docs_search,mcp__slack_send_message"]);
-	});
-
-	it("preserves directly activated MCP tools across refreshes in discovery mode", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const docsSearchTool = createMcpTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]);
-		const slackSendTool = createMcpTool("mcp__slack_send_message", "slack", "send_message", "Send a Slack message", [
-			"channel",
-			"text",
-		]);
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[docsSearchTool.name, docsSearchTool],
-			[slackSendTool.name, slackSendTool],
-		]);
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: [readTool],
-				messages: [],
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: true,
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		await session.setActiveToolsByName(["read", "mcp__docs_search"]);
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search"]);
-		expect(session.getActiveToolNames()).toEqual(["read", "mcp__docs_search"]);
-
-		await session.refreshMCPTools([
-			createMcpCustomTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]),
-			createMcpCustomTool("mcp__slack_send_message", "slack", "send_message", "Send a Slack message", [
-				"channel",
-				"text",
-			]),
-		]);
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search"]);
-		expect(session.getActiveToolNames()).toEqual(["read", "mcp__docs_search"]);
-	});
-
-	it("keeps MCP tools hidden by default and activates discovered selections additively", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const docsSearchTool = createMcpTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]);
-		const slackSendTool = createMcpTool("mcp__slack_send_message", "slack", "send_message", "Send a Slack message", [
-			"channel",
-			"text",
-		]);
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[docsSearchTool.name, docsSearchTool],
-			[slackSendTool.name, slackSendTool],
-		]);
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: [readTool],
-				messages: [],
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: true,
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		expect(session.getActiveToolNames()).toEqual(["read"]);
-		expect(session.getDiscoverableTools({ source: "mcp" }).map(tool => tool.name)).toEqual([
-			"mcp__docs_search",
-			"mcp__slack_send_message",
-		]);
-
-		await session.activateDiscoveredMCPTools(["mcp__docs_search"]);
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search"]);
-		expect(session.getActiveToolNames()).toEqual(["read", "mcp__docs_search"]);
-		expect(session.systemPrompt).toEqual(["tools:read,mcp__docs_search"]);
-
-		await session.activateDiscoveredMCPTools(["mcp__slack_send_message"]);
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search", "mcp__slack_send_message"]);
-		expect(session.getActiveToolNames()).toEqual(["read", "mcp__docs_search", "mcp__slack_send_message"]);
-		expect(session.systemPrompt).toEqual(["tools:read,mcp__docs_search,mcp__slack_send_message"]);
-	});
-	it("reapplies default MCP server baselines when refreshed tools reconnect", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const docsSearchTool = createMcpTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]);
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[docsSearchTool.name, docsSearchTool],
-		]);
-		const sessionManager = SessionManager.inMemory();
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: [readTool],
-				messages: [],
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager,
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: true,
-			defaultSelectedMCPServerNames: ["slack"],
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		expect(session.getSelectedMCPToolNames()).toEqual([]);
-		expect(session.getActiveToolNames()).toEqual(["read"]);
-
-		await session.refreshMCPTools([
-			createMcpCustomTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]),
-			createMcpCustomTool("mcp__slack_send_message", "slack", "send_message", "Send a Slack message", [
-				"channel",
-				"text",
-			]),
-		]);
-
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__slack_send_message"]);
-		expect(session.getActiveToolNames()).toEqual(["read", "mcp__slack_send_message"]);
-		expect(session.systemPrompt).toEqual(["tools:read,mcp__slack_send_message"]);
-		expect(sessionManager.buildSessionContext().selectedMCPToolNames).toEqual(["mcp__slack_send_message"]);
-	});
-
-	it("persists cleared MCP selections when refresh removes a selected tool", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const docsSearchTool = createMcpTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]);
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[docsSearchTool.name, docsSearchTool],
-		]);
-		const sessionManager = SessionManager.inMemory();
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: [readTool],
-				messages: [],
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager,
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: true,
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		await session.activateDiscoveredMCPTools(["mcp__docs_search"]);
-		expect(sessionManager.buildSessionContext().selectedMCPToolNames).toEqual(["mcp__docs_search"]);
-
-		await session.refreshMCPTools([]);
-
-		expect(session.getSelectedMCPToolNames()).toEqual([]);
-		expect(session.getActiveToolNames()).toEqual(["read"]);
-		expect(sessionManager.buildSessionContext().selectedMCPToolNames).toEqual([]);
-	});
-
-	it("restores unavailable MCP selections in memory without rewriting the persisted session selection", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const sessionManager = SessionManager.inMemory();
-		sessionManager.appendMCPToolSelection(["mcp__docs_search"]);
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: [readTool],
-				messages: [],
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager,
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			modelRegistry: {} as never,
-			toolRegistry: new Map([[readTool.name, readTool]]),
-			mcpDiscoveryEnabled: true,
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		expect(session.getSelectedMCPToolNames()).toEqual([]);
-		expect(sessionManager.buildSessionContext().selectedMCPToolNames).toEqual(["mcp__docs_search"]);
-	});
-
-	it("restores MCP discovery selections when branching to a context without them", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const docsSearchTool = createMcpTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]);
-		const sessionManager = SessionManager.inMemory();
-		const userEntryId = sessionManager.appendMessage({
-			role: "user",
-			content: "start",
-			timestamp: Date.now(),
-		});
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[docsSearchTool.name, docsSearchTool],
-		]);
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: [readTool],
-				messages: sessionManager.buildSessionContext().messages,
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager,
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: true,
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		await session.activateDiscoveredMCPTools(["mcp__docs_search"]);
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search"]);
-
-		const result = await session.branch(userEntryId);
-
-		expect(result.cancelled).toBe(false);
-		expect(session.getSelectedMCPToolNames()).toEqual([]);
-		expect(session.getActiveToolNames()).toEqual(["read"]);
-		expect(session.systemPrompt).toEqual(["tools:read"]);
-	});
-
-	it("restores MCP discovery selections when navigating to a branch without them", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const docsSearchTool = createMcpTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]);
-		const sessionManager = SessionManager.inMemory();
-		const userEntryId = sessionManager.appendMessage({
-			role: "user",
-			content: "start",
-			timestamp: Date.now(),
-		});
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[docsSearchTool.name, docsSearchTool],
-		]);
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: [readTool],
-				messages: sessionManager.buildSessionContext().messages,
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager,
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: true,
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		await session.activateDiscoveredMCPTools(["mcp__docs_search"]);
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search"]);
-
-		const result = await session.navigateTree(userEntryId, { summarize: false });
-
-		expect(result.cancelled).toBe(false);
-		expect(session.getSelectedMCPToolNames()).toEqual([]);
-		expect(session.getActiveToolNames()).toEqual(["read"]);
-		expect(session.systemPrompt).toEqual(["tools:read"]);
-	});
-
-	it("preserves explicit MCP baseline when branching into older history without persisted selection", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const docsSearchTool = createMcpTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]);
-		const sessionManager = SessionManager.inMemory();
-		const userEntryId = sessionManager.appendMessage({
-			role: "user",
-			content: "start",
-			timestamp: Date.now(),
-		});
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[docsSearchTool.name, docsSearchTool],
-		]);
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: [readTool, docsSearchTool],
-				messages: sessionManager.buildSessionContext().messages,
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager,
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: true,
-			initialSelectedMCPToolNames: ["mcp__docs_search"],
-			defaultSelectedMCPToolNames: ["mcp__docs_search"],
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		const result = await session.branch(userEntryId);
-
-		expect(result.cancelled).toBe(false);
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search"]);
-		expect(session.getActiveToolNames()).toEqual(["read", "mcp__docs_search"]);
-		expect(session.systemPrompt).toEqual(["tools:read,mcp__docs_search"]);
-	});
-
-	it("preserves explicit MCP baseline when navigating into older history without persisted selection", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const docsSearchTool = createMcpTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]);
-		const sessionManager = SessionManager.inMemory();
-		const userEntryId = sessionManager.appendMessage({
-			role: "user",
-			content: "start",
-			timestamp: Date.now(),
-		});
-		sessionManager.appendMessage({
-			role: "user",
-			content: "follow up",
-			timestamp: Date.now(),
-		});
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[docsSearchTool.name, docsSearchTool],
-		]);
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: [readTool, docsSearchTool],
-				messages: sessionManager.buildSessionContext().messages,
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager,
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: true,
-			initialSelectedMCPToolNames: ["mcp__docs_search"],
-			defaultSelectedMCPToolNames: ["mcp__docs_search"],
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		const result = await session.navigateTree(userEntryId, { summarize: false });
-
-		expect(result.cancelled).toBe(false);
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search"]);
-		expect(session.getActiveToolNames()).toEqual(["read", "mcp__docs_search"]);
-		expect(session.systemPrompt).toEqual(["tools:read,mcp__docs_search"]);
-	});
-
-	it("restores session defaults in memory across session switches without rewriting sessions missing persisted metadata", async () => {
-		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-agent-session-mcp-switch-"));
-		tempDirs.push(tempDir);
-		const readTool = createBasicTool("read", "Read");
-		const docsSearchTool = createMcpTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]);
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[docsSearchTool.name, docsSearchTool],
-		]);
-
-		const olderSessionManager = SessionManager.create(tempDir, tempDir);
-		olderSessionManager.appendMessage({
-			role: "user",
-			content: "older session",
-			timestamp: Date.now(),
-		});
-		const olderSessionFile = olderSessionManager.getSessionFile();
-		expect(olderSessionFile).toBeString();
-		await olderSessionManager.rewriteEntries();
-		const olderSessionBeforeSwitch = fs.readFileSync(olderSessionFile!, "utf8");
-		const olderSessionMtimeBeforeSwitch = fs.statSync(olderSessionFile!).mtimeMs;
-
-		const sessionManager = SessionManager.create(tempDir, tempDir);
-		const originalSessionFile = sessionManager.getSessionFile();
-		expect(originalSessionFile).toBeString();
-		await sessionManager.flush();
-
-		const reasoningModel: Model<"openai-responses"> = {
-			...createModel(),
-			reasoning: true,
-			thinking: { mode: "effort", efforts: [Effort.Medium] },
-		};
-
-		const agent = new Agent({
-			initialState: {
-				model: reasoningModel,
-				systemPrompt: ["initial"],
-				tools: [readTool, docsSearchTool],
-				messages: sessionManager.buildSessionContext().messages,
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager,
-			settings: Settings.isolated({
-				"mcp.discoveryMode": true,
-				defaultThinkingLevel: "high",
-				"tier.openai": "priority",
-			}),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: true,
-			initialSelectedMCPToolNames: ["mcp__docs_search"],
-			defaultSelectedMCPToolNames: ["mcp__docs_search"],
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search"]);
-		sessionManager.appendThinkingLevelChange(ThinkingLevel.High);
-		sessionManager.appendServiceTierChange({ openai: "flex" });
-		sessionManager.appendMCPToolSelection(["mcp__docs_search"]);
-		expect(sessionManager.buildSessionContext().thinkingLevel).toBe(ThinkingLevel.High);
-		expect(sessionManager.buildSessionContext().serviceTier).toEqual({ openai: "flex" });
-		expect(sessionManager.buildSessionContext().selectedMCPToolNames).toEqual(["mcp__docs_search"]);
-		expect(sessionManager.buildSessionContext().hasPersistedMCPToolSelection).toBe(true);
-		await sessionManager.rewriteEntries();
-		const originalSessionBeforeSwitch = fs.readFileSync(originalSessionFile!, "utf8");
-		const originalSessionMtimeBeforeSwitch = fs.statSync(originalSessionFile!).mtimeMs;
-		await Bun.sleep(20);
-
-		await session.switchSession(olderSessionFile!);
-		expect(session.sessionFile).toBe(olderSessionFile);
-		expect(session.thinkingLevel).toBe(ThinkingLevel.Medium);
-		expect(session.serviceTierByFamily).toEqual({ openai: "priority" });
-		expect(session.getSelectedMCPToolNames()).toEqual([]);
-		expect(session.getActiveToolNames()).toEqual(["read"]);
-		expect(session.systemPrompt).toEqual(["tools:read"]);
-		expect(fs.readFileSync(olderSessionFile!, "utf8")).toBe(olderSessionBeforeSwitch);
-		expect(fs.statSync(olderSessionFile!).mtimeMs).toBe(olderSessionMtimeBeforeSwitch);
-
-		await session.switchSession(originalSessionFile!);
-		expect(session.sessionFile).toBe(originalSessionFile);
-		expect(session.thinkingLevel).toBe(ThinkingLevel.Medium);
-		expect(session.serviceTierByFamily).toEqual({ openai: "flex" });
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search"]);
-		expect(session.getActiveToolNames()).toEqual(["read", "mcp__docs_search"]);
-		expect(session.systemPrompt).toEqual(["tools:read,mcp__docs_search"]);
-		expect(fs.readFileSync(originalSessionFile!, "utf8")).toBe(originalSessionBeforeSwitch);
-		expect(fs.statSync(originalSessionFile!).mtimeMs).toBe(originalSessionMtimeBeforeSwitch);
-	});
-
-	it("restores explicit MCP defaults after startup outage once tools recover in a new session", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const docsSearchTool = createMcpTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]);
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[docsSearchTool.name, docsSearchTool],
-		]);
-		const sessionManager = SessionManager.inMemory();
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: [readTool, docsSearchTool],
-				messages: [],
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager,
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: true,
-			initialSelectedMCPToolNames: ["mcp__docs_search", "mcp__slack_send_message"],
-			defaultSelectedMCPToolNames: ["mcp__docs_search", "mcp__slack_send_message"],
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search"]);
-		expect(session.getActiveToolNames()).toEqual(["read", "mcp__docs_search"]);
-
-		await session.refreshMCPTools([
-			createMcpCustomTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]),
-			createMcpCustomTool("mcp__slack_send_message", "slack", "send_message", "Send a Slack message", [
-				"channel",
-				"text",
-			]),
-		]);
-
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search"]);
-		expect(session.getActiveToolNames()).toEqual(["read", "mcp__docs_search"]);
-
-		await session.newSession();
-
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search", "mcp__slack_send_message"]);
-		expect(session.getActiveToolNames()).toEqual(["read", "mcp__docs_search", "mcp__slack_send_message"]);
-		expect(session.systemPrompt).toEqual(["tools:read,mcp__docs_search,mcp__slack_send_message"]);
-		expect(sessionManager.buildSessionContext().selectedMCPToolNames).toEqual([
-			"mcp__docs_search",
-			"mcp__slack_send_message",
-		]);
-	});
-
-	it("clears discovered MCP selections when starting a brand-new session", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const docsSearchTool = createMcpTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]);
-		const slackSendTool = createMcpTool("mcp__slack_send_message", "slack", "send_message", "Send a Slack message", [
-			"channel",
-			"text",
-		]);
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[docsSearchTool.name, docsSearchTool],
-			[slackSendTool.name, slackSendTool],
-		]);
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: [readTool],
-				messages: [],
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: true,
-			rebuildSystemPrompt: async toolNames => ({
-				systemPrompt: [`tools:${toolNames.join(",")}`],
-			}),
-		});
-		sessions.push(session);
-
-		await session.activateDiscoveredMCPTools(["mcp__docs_search"]);
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__docs_search"]);
-		expect(session.getActiveToolNames()).toEqual(["read", "mcp__docs_search"]);
-
-		await session.newSession();
-
-		expect(session.getSelectedMCPToolNames()).toEqual([]);
-		expect(session.getActiveToolNames()).toEqual(["read"]);
-		expect(session.systemPrompt).toEqual(["tools:read"]);
-	});
-	// ── Findings #3: discovery index is invalidated on active-tool changes ─────
-	it("setActiveToolsByName invalidates the generic discoverable tool search index", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const docsSearchTool = createMcpTool("mcp__docs_search", "docs", "search", "Search internal docs", ["query"]);
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[docsSearchTool.name, docsSearchTool],
-		]);
-		const agent = new Agent({
-			initialState: { model: createModel(), systemPrompt: ["initial"], tools: [readTool], messages: [] },
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: true,
-			rebuildSystemPrompt: async toolNames => ({ systemPrompt: [`tools:${toolNames.join(",")}`] }),
-		});
-		sessions.push(session);
-
-		// Index built before activation contains the discoverable MCP tool.
-		const beforeIndex = session.getDiscoverableToolSearchIndex();
-		const beforeNames = beforeIndex.documents.map(d => d.tool.name);
-		expect(beforeNames).toContain("mcp__docs_search");
-
-		await session.setActiveToolsByName(["read", "mcp__docs_search"]);
-
-		// After activation the same lookup must return a fresh index that no longer lists the
-		// now-active tool. If invalidation regressed, this would still return `beforeIndex`.
-		const afterIndex = session.getDiscoverableToolSearchIndex();
-		expect(afterIndex).not.toBe(beforeIndex);
-		expect(afterIndex.documents.map(d => d.tool.name)).not.toContain("mcp__docs_search");
-	});
-
-	// ── Findings #4: built-in discovery is restricted to declared discoverable ─
-	it("getDiscoverableTools({source:'builtin'}) excludes hidden and non-declared registry tools", () => {
-		const readTool = createBasicTool("read", "Read");
-		readTool.loadMode = "essential";
-		const findTool = createBasicTool("find", "Find");
-		findTool.loadMode = "discoverable";
-		findTool.summary = "Find files and directories matching a glob pattern";
-		const resolveTool = createBasicTool("resolve", "Resolve"); // hidden — must be excluded
-		const customTool = createBasicTool("custom_inactive", "Custom"); // not in metadata — must be excluded
-		const toolRegistry = new Map([
-			[readTool.name, readTool],
-			[findTool.name, findTool],
-			[resolveTool.name, resolveTool],
-			[customTool.name, customTool],
-		]);
-		const agent = new Agent({
-			initialState: { model: createModel(), systemPrompt: ["initial"], tools: [readTool], messages: [] },
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "tools.discoveryMode": "all" }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: false,
-			rebuildSystemPrompt: async toolNames => ({ systemPrompt: [`tools:${toolNames.join(",")}`] }),
-		});
-		sessions.push(session);
-
-		const builtin = session.getDiscoverableTools({ source: "builtin" });
-		const names = builtin.map(t => t.name);
-		expect(names).toContain("find"); // declared discoverable AND present in registry
-		expect(names).not.toContain("read"); // already active
-		expect(names).not.toContain("resolve"); // hidden — no discoverable loadMode
-		expect(names).not.toContain("custom_inactive"); // unknown — no discoverable loadMode
-	});
-
-	it("spills oversized MCP tool output to an artifact after refreshMCPTools", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const toolRegistry = new Map([[readTool.name, readTool]]);
-		const agent = new Agent({
-			initialState: { model: createModel(), systemPrompt: ["initial"], tools: [readTool], messages: [] },
-		});
-		const sessionManager = SessionManager.inMemory();
-		const session = new AgentSession({
-			agent,
-			sessionManager,
-			settings: Settings.isolated({ "mcp.discoveryMode": false }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: false,
-			rebuildSystemPrompt: async toolNames => ({ systemPrompt: [`tools:${toolNames.join(",")}`] }),
-		});
-		sessions.push(session);
-
-		const big = "data line\n".repeat(500);
-		await session.refreshMCPTools([createOversizedMcpTool("mcp__demo_dump", "demo", "dump", big)]);
-
-		const registered = session.getToolByName("mcp__demo_dump");
-		expect(registered).toBeDefined();
-
-		const result = await registered!.execute(
-			"call-spill",
-			{},
-			undefined,
-			undefined,
-			createSpillContext(sessionManager),
-		);
-		const text = textOf(result);
-		expect(Buffer.byteLength(text)).toBeLessThan(Buffer.byteLength(big));
-		expect(text).toContain("artifact://");
-		expect(result.isError).toBeFalsy();
-		const meta = (result.details as { meta?: OutputMeta }).meta;
-		expect(meta?.truncation?.artifactId).toBeDefined();
-	});
-
-	it("keeps an oversized MCP result successful and truncated when the artifact save fails", async () => {
-		const readTool = createBasicTool("read", "Read");
-		const toolRegistry = new Map([[readTool.name, readTool]]);
-		const agent = new Agent({
-			initialState: { model: createModel(), systemPrompt: ["initial"], tools: [readTool], messages: [] },
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "mcp.discoveryMode": false }),
-			modelRegistry: {} as never,
-			toolRegistry,
-			mcpDiscoveryEnabled: false,
-			rebuildSystemPrompt: async toolNames => ({ systemPrompt: [`tools:${toolNames.join(",")}`] }),
-		});
-		sessions.push(session);
-
-		const big = "data line\n".repeat(500);
-		await session.refreshMCPTools([createOversizedMcpTool("mcp__demo_dump", "demo", "dump", big)]);
-		const registered = session.getToolByName("mcp__demo_dump");
-		expect(registered).toBeDefined();
-
-		// Local in-memory manager whose artifact save throws (e.g. disk full). The
-		// spy lives on a throwaway instance, so it never leaks to other tests.
-		const failingManager = SessionManager.inMemory();
-		vi.spyOn(failingManager, "saveArtifact").mockRejectedValue(new Error("disk full"));
-		const context = createSpillContext(failingManager);
-
-		const result = await registered!.execute("call-fail", {}, undefined, undefined, context);
-		const text = textOf(result);
-		expect(result.isError).toBeFalsy();
-		expect(Buffer.byteLength(text)).toBeLessThan(Buffer.byteLength(big));
-		expect(text).not.toContain("artifact://");
-		const meta = (result.details as { meta?: OutputMeta }).meta;
-		expect(meta?.truncation).toBeDefined();
-		expect(meta?.truncation?.artifactId).toBeUndefined();
-	});
-});
diff --git a/packages/coding-agent/test/agent-session-plan-mode-convergence.test.ts b/packages/coding-agent/test/agent-session-plan-mode-convergence.test.ts
index cb6ceaec5..6343fe01d 100644
--- a/packages/coding-agent/test/agent-session-plan-mode-convergence.test.ts
+++ b/packages/coding-agent/test/agent-session-plan-mode-convergence.test.ts
@@ -1,12 +1,12 @@
 /**
- * Contract: plan mode converges on `ask`/`resolve` regardless of how a turn
+ * Contract: plan mode converges on `ask`/`write xd://propose` regardless of how a turn
  * ends, and non-user producers cannot keep it spinning.
  *
  *  T1. An advisor concern in plan mode is recorded as a visible card but never
  *      wakes an autonomous primary turn.
  *  T2. An idle IRC message in plan mode is folded into context ("injected"),
  *      not woken.
- *  T3. A plan-mode turn that stops without `ask`/`resolve` is reminded at the
+ *  T3. A plan-mode turn that stops without a decision tool call is reminded at the
  *      terminal settle, bounded by PLAN_MODE_REMINDER_MAX (then yields to the
  *      user), and either decision tool resets the counter.
  */
@@ -87,7 +87,6 @@ describe("AgentSession plan-mode convergence", () => {
 		} finally {
 			session = undefined;
 			for (const authStorage of authStorages.splice(0)) authStorage.close();
-			// dispose() awaits the agent teardown above; no wall-clock wait needed.
 			await tempDir?.remove();
 		}
 	});
@@ -100,15 +99,15 @@ describe("AgentSession plan-mode convergence", () => {
 		if (!model) throw new Error("Expected bundled anthropic model to exist");
 
 		const askTool = makeTool("ask");
-		const resolveTool = makeTool("resolve");
+		const writeTool = makeTool("write");
 		const readTool = makeTool("read");
 
 		const mock = createMockModel({ responses });
 		const agent = new Agent({
 			getApiKey: () => "test-key",
-			// All three tools active so a scripted ask/resolve/read call (and a
+			// All three tools active so a scripted ask/write/read call (and a
 			// forced "required" choice) can actually execute (isToolChoiceActive).
-			initialState: { model, systemPrompt: ["Test"], tools: [askTool, resolveTool, readTool], messages: [] },
+			initialState: { model, systemPrompt: ["Test"], tools: [askTool, writeTool, readTool], messages: [] },
 			streamFn: mock.stream,
 		});
 
@@ -141,10 +140,10 @@ describe("AgentSession plan-mode convergence", () => {
 			modelRegistry,
 			toolRegistry: new Map<string, AgentTool>([
 				["ask", askTool],
-				["resolve", resolveTool],
+				["write", writeTool],
 				["read", readTool],
 			]),
-			builtInToolNames: ["ask", "resolve", "read"],
+			builtInToolNames: ["ask", "write", "read"],
 			advisorTools: [],
 			advisorStreamFn,
 			sideStreamFn,
@@ -176,9 +175,7 @@ describe("AgentSession plan-mode convergence", () => {
 			m => m.role === "custom" && m.customType === "advisor",
 		);
 		expect(advisorCards.length).toBeGreaterThanOrEqual(1);
-		// The note was preserved/recorded, not used to wake the primary.
 		expect(harness.mock.calls.length).toBe(0);
-		// The advisor model actually ran (the test drove the routeAdvice seam).
 		expect(harness.advisorMock?.calls.length ?? 0).toBeGreaterThanOrEqual(1);
 	});
 
@@ -204,20 +201,16 @@ describe("AgentSession plan-mode convergence", () => {
 		registry.register({ id: "peer", displayName: "peer", kind: "sub", session: null, status: "running" });
 		try {
 			const bus = IrcBus.global();
-			// Park the sender's reply waiter first (timeout 0 = no wall-clock timer;
-			// a broken auto-reply path fails via the test runner's own timeout).
 			const replyPromise = bus.wait("peer", { from: "me" }, 0);
 			const msg: IrcMessage = { id: "m2", from: "peer", to: "me", body: "blocked on you — status?", ts: Date.now() };
 
 			const outcome = await harness.session.deliverIrcMessage(msg, { expectsReply: true });
 			expect(outcome).toBe("injected");
 
-			// The ephemeral side-channel turn answered the sender for real.
 			const reply = await replyPromise;
 			expect(reply?.replyTo).toBe("m2");
 			expect(reply?.body).toContain("still planning");
 			expect(harness.sideMock?.calls.length).toBe(1);
-			// The primary loop never woke: no model call, no assistant turn.
 			expect(harness.mock.calls.length).toBe(0);
 			expect(harness.session.agent.state.messages.some(m => m.role === "assistant")).toBe(false);
 		} finally {
@@ -226,9 +219,6 @@ describe("AgentSession plan-mode convergence", () => {
 	});
 
 	it("T3a: convergence reminders are bounded by the cap, then yield to the user", async () => {
-		// Alternating text-stop / read cascade: each text stop with awaiting=false
-		// escalates a reminder; each read clears awaiting (not the count). The 7th
-		// text stop lands with awaiting=false AND count===cap → cap guard yields.
 		const harness = await createPlanSession([
 			{ content: ["planning A"] },
 			{ content: [{ type: "toolCall", name: "read", arguments: { path: "a" } }] },
@@ -239,26 +229,31 @@ describe("AgentSession plan-mode convergence", () => {
 			{ content: ["planning D"] },
 		]);
 
-		// Todos are ENABLED (default) with an incomplete item, so a missing plan-mode
-		// gate in #checkTodoCompletion would inject a todo reminder and schedule an
-		// 8th continuation past the cap — the mock.calls.length === 7 assertion below
-		// is the behavioral guard for that bypass.
 		harness.session.setTodoPhases([{ name: "Plan", tasks: [{ content: "draft the plan", status: "pending" }] }]);
 
 		await harness.session.prompt("make a plan");
 		await harness.session.waitForIdle();
 
-		// Exactly PLAN_MODE_REMINDER_MAX (3) reminders, then a cap-yield (no 4th,
-		// no further continuation), and plan mode is still on (not silently exited).
 		expect(countReminders(harness.session.agent.state.messages)).toBe(3);
 		expect(harness.mock.calls.length).toBe(7);
 		expect(harness.session.getPlanModeState()?.enabled).toBe(true);
 	});
 
-	it("T3b: a resolve call resets the convergence counter", async () => {
+	it("T3b: a propose write resets the convergence counter", async () => {
 		const harness = await createPlanSession([
 			{ content: ["planning A"] },
-			{ content: [{ type: "toolCall", name: "resolve", arguments: { action: "discard", reason: "test reset" } }] },
+			{
+				content: [
+					{
+						type: "toolCall",
+						name: "write",
+						arguments: {
+							path: "xd://propose",
+							content: "test-reset",
+						},
+					},
+				],
+			},
 			{ content: ["planning B"] },
 			{ content: ["planning C"] },
 		]);
@@ -266,9 +261,6 @@ describe("AgentSession plan-mode convergence", () => {
 		await harness.session.prompt("make a plan");
 		await harness.session.waitForIdle();
 
-		// reminder #1 (text) → resolve resets → reminder #2 (text) → awaiting latch
-		// suppresses on the final text stop. Two reminders proves the reset re-armed
-		// the budget; four model calls proves no runaway.
 		expect(countReminders(harness.session.agent.state.messages)).toBe(2);
 		expect(harness.mock.calls.length).toBe(4);
 	});
diff --git a/packages/coding-agent/test/agent-session-resolve-reminder.test.ts b/packages/coding-agent/test/agent-session-resolve-reminder.test.ts
index f9ea9529d..efd2a000b 100644
--- a/packages/coding-agent/test/agent-session-resolve-reminder.test.ts
+++ b/packages/coding-agent/test/agent-session-resolve-reminder.test.ts
@@ -11,7 +11,7 @@ import { AgentSession } from "@oh-my-pi/pi-coding-agent/session/agent-session";
 import { AuthStorage } from "@oh-my-pi/pi-coding-agent/session/auth-storage";
 import { SessionManager } from "@oh-my-pi/pi-coding-agent/session/session-manager";
 import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
-import { queueResolveHandler, ResolveTool } from "@oh-my-pi/pi-coding-agent/tools/resolve";
+import { dispatchResolutionDevice, queueResolveHandler } from "@oh-my-pi/pi-coding-agent/tools/resolve";
 import { buildNamedToolChoice } from "@oh-my-pi/pi-coding-agent/utils/tool-choice";
 import { removeSyncWithRetries, Snowflake } from "@oh-my-pi/pi-utils";
 
@@ -43,7 +43,7 @@ describe("AgentSession resolve reminder", () => {
 			peekQueueInvoker: () => session.peekQueueInvoker(),
 			peekPendingInvoker: () => session.peekPendingInvoker(),
 			clearPendingInvokers: () => session.clearPendingInvokers(),
-			peekStandingResolveHandler: () => session.peekStandingResolveHandler(),
+			peekPlanProposalHandler: () => session.peekPlanProposalHandler(),
 		} as unknown as ToolSession;
 
 		const agent = new Agent({
@@ -76,22 +76,20 @@ describe("AgentSession resolve reminder", () => {
 			apply: async () => ({ content: [{ type: "text", text: "Applied" }] }),
 		});
 
-		// Forcing was removed — staging a preview never queues a hard tool_choice.
 		expect(session.toolChoiceQueue.nextToolChoice()).toBeUndefined();
 
-		// The reminder now rides an agent-level soft requirement (delivered once by
-		// the agent loop) instead of a host-side steer that churned the prefix.
 		const directive = session.nextToolChoiceDirective();
 		expect(isSoftToolRequirement(directive)).toBe(true);
 		if (!isSoftToolRequirement(directive)) throw new Error("expected soft requirement");
-		expect(directive.toolName).toBe("resolve");
+		expect(directive.toolName).toBe("write");
+		expect(directive.satisfies?.({ name: "write", arguments: { path: "xd://resolve" } })).toBe(true);
+		expect(directive.satisfies?.({ name: "write", arguments: { path: "xd://reject" } })).toBe(true);
+		expect(directive.satisfies?.({ name: "write", arguments: { path: "/tmp/out.md" } })).toBe(false);
 		const reminder = directive.reminder[0];
 		expect(reminder?.role).toBe("custom");
 		if (reminder?.role === "custom") {
 			expect(reminder.customType).toBe("resolve-reminder");
 		}
-
-		// Nothing was steered into the conversation — no prefix churn.
 		expect(session.agent.peekSteeringQueue()).toHaveLength(0);
 	});
 
@@ -106,18 +104,14 @@ describe("AgentSession resolve reminder", () => {
 			},
 		});
 
-		// Gate armed before resolve runs.
 		expect(isSoftToolRequirement(session.nextToolChoiceDirective())).toBe(true);
+		await dispatchResolutionDevice(toolSession, "resolve", "looks correct");
 
-		const tool = new ResolveTool(toolSession);
-		await tool.execute("call-apply", { action: "apply", reason: "looks correct" });
-
-		// Apply ran (forwarding works) AND the gate cleared (no phantom pending).
 		expect(applyRuns).toBe(1);
 		expect(session.nextToolChoiceDirective()).toBeUndefined();
 	});
 
-	it("drains a phantom pending gate when resolve cannot dispatch", async () => {
+	it("drains a phantom pending gate when reject cannot dispatch", async () => {
 		queueResolveHandler(toolSession, {
 			label: "AST Edit: 1 replacement in 1 file",
 			sourceToolName: "ast_edit",
@@ -125,18 +119,14 @@ describe("AgentSession resolve reminder", () => {
 		});
 		expect(isSoftToolRequirement(session.nextToolChoiceDirective())).toBe(true);
 
-		// Mirror the production deadlock: the queue still reports a pending head, but
-		// every dispatch peek returns undefined (the original loop-trigger).
 		const facade = {
 			...toolSession,
 			peekQueueInvoker: () => undefined,
 			peekPendingInvoker: () => undefined,
-			peekStandingResolveHandler: () => undefined,
+			peekPlanProposalHandler: () => undefined,
 		} as ToolSession;
-		const tool = new ResolveTool(facade);
 
-		// `discard` with no invoker now drains the gate instead of leaving a phantom.
-		const result = await tool.execute("call-discard", { action: "discard", reason: "drain stale gate" });
+		const { result } = await dispatchResolutionDevice(facade, "reject", "drain stale gate");
 		expect(result.isError ?? false).toBe(false);
 		expect(session.nextToolChoiceDirective()).toBeUndefined();
 	});
diff --git a/packages/coding-agent/test/agent-session-ssh-refresh.test.ts b/packages/coding-agent/test/agent-session-ssh-refresh.test.ts
deleted file mode 100644
index 2934fa363..000000000
--- a/packages/coding-agent/test/agent-session-ssh-refresh.test.ts
+++ /dev/null
@@ -1,240 +0,0 @@
-import { afterEach, describe, expect, it, spyOn } from "bun:test";
-import { Agent, type AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { Model } from "@oh-my-pi/pi-ai";
-import { buildModel } from "@oh-my-pi/pi-catalog/build";
-import { reset as resetCapabilities } from "@oh-my-pi/pi-coding-agent/capability";
-import { type SSHHost, sshCapability } from "@oh-my-pi/pi-coding-agent/capability/ssh";
-import { Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
-import { loadCapability } from "@oh-my-pi/pi-coding-agent/discovery";
-import { AgentSession } from "@oh-my-pi/pi-coding-agent/session/agent-session";
-import { SessionManager } from "@oh-my-pi/pi-coding-agent/session/session-manager";
-import { addSSHHost, removeSSHHost, updateSSHHost } from "@oh-my-pi/pi-coding-agent/ssh/config-writer";
-import * as connectionManager from "@oh-my-pi/pi-coding-agent/ssh/connection-manager";
-import { loadSshTool, type ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
-import { getSSHConfigPath, TempDir } from "@oh-my-pi/pi-utils";
-
-function createModel(): Model<"openai-responses"> {
-	return buildModel({
-		id: "mock",
-		name: "mock",
-		api: "openai-responses",
-		provider: "openai",
-		baseUrl: "https://example.invalid",
-		reasoning: false,
-		input: ["text"],
-		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-		contextWindow: 8192,
-		maxTokens: 2048,
-	});
-}
-
-describe("AgentSession SSH tool refresh", () => {
-	const tempDirs: TempDir[] = [];
-	const sessions: AgentSession[] = [];
-
-	afterEach(async () => {
-		for (const session of sessions.splice(0)) {
-			await session.dispose();
-		}
-		for (const tempDir of tempDirs.splice(0)) {
-			tempDir.removeSync();
-		}
-		resetCapabilities();
-	});
-
-	function createSession(
-		cwd: string,
-		initialTools: AgentTool[] = [],
-		registryTools = initialTools,
-		options?: { reloadSshTool?: () => Promise<AgentTool | null>; requestedToolNames?: ReadonlySet<string> },
-	): AgentSession {
-		const settings = Settings.isolated({ "compaction.enabled": false });
-		const sessionManager = SessionManager.inMemory(cwd);
-		const toolSession: ToolSession = {
-			cwd,
-			hasUI: false,
-			settings,
-			getSessionFile: () => sessionManager.getSessionFile() ?? null,
-			getSessionSpawns: () => "*",
-		};
-		const toolRegistry = new Map(registryTools.map(tool => [tool.name, tool]));
-		const agent = new Agent({
-			initialState: {
-				model: createModel(),
-				systemPrompt: ["initial"],
-				tools: initialTools,
-				messages: [],
-			},
-		});
-		const session = new AgentSession({
-			agent,
-			sessionManager,
-			settings,
-			modelRegistry: {} as never,
-			toolRegistry,
-			reloadSshTool:
-				options?.reloadSshTool ?? (async () => (await loadSshTool(toolSession)) as unknown as AgentTool | null),
-			requestedToolNames: options?.requestedToolNames,
-			rebuildSystemPrompt: async (toolNames, tools) => ({
-				systemPrompt: toolNames.map(name => `${name}:${tools.get(name)?.description ?? ""}`),
-			}),
-		});
-		sessions.push(session);
-		return session;
-	}
-
-	it("adds the ssh tool after a first host is written over a cached missing config", async () => {
-		const tempDir = TempDir.createSync("@pi-ssh-refresh-");
-		tempDirs.push(tempDir);
-		const cwd = tempDir.path();
-
-		const preWrite = await loadCapability<SSHHost>(sshCapability.id, { cwd });
-		expect(preWrite.items).toHaveLength(0);
-
-		const session = createSession(cwd);
-		await addSSHHost(getSSHConfigPath("project", cwd), "staging", { host: "192.0.2.10" });
-		await session.refreshSshTool({ activateIfAvailable: true });
-
-		expect(session.getAllToolNames()).toContain("ssh");
-		expect(session.getActiveToolNames()).toContain("ssh");
-		expect(session.getToolByName("ssh")?.description).toContain("staging (192.0.2.10)");
-		expect(session.agent.state.systemPrompt.join("\n")).toContain("staging (192.0.2.10)");
-	});
-
-	it("removes ssh from registry and active tools when the last host is removed", async () => {
-		const tempDir = TempDir.createSync("@pi-ssh-refresh-");
-		tempDirs.push(tempDir);
-		const cwd = tempDir.path();
-		const configPath = getSSHConfigPath("project", cwd);
-
-		await addSSHHost(configPath, "prod", { host: "203.0.113.9" });
-		const sshTool = await loadSshTool({
-			cwd,
-			hasUI: false,
-			settings: Settings.isolated({ "compaction.enabled": false }),
-			getSessionSpawns: () => "*",
-			getSessionFile: () => null,
-		});
-		expect(sshTool).not.toBeNull();
-
-		const session = createSession(cwd, [sshTool as unknown as AgentTool]);
-		await removeSSHHost(configPath, "prod");
-		await session.refreshSshTool();
-
-		expect(session.getAllToolNames()).not.toContain("ssh");
-		expect(session.getActiveToolNames()).not.toContain("ssh");
-	});
-
-	it("does not activate an existing inactive ssh tool during reload refresh", async () => {
-		const tempDir = TempDir.createSync("@pi-ssh-refresh-");
-		tempDirs.push(tempDir);
-		const cwd = tempDir.path();
-		const configPath = getSSHConfigPath("project", cwd);
-
-		await addSSHHost(configPath, "dev", { host: "192.0.2.20" });
-		const sshTool = await loadSshTool({
-			cwd,
-			hasUI: false,
-			settings: Settings.isolated({ "compaction.enabled": false }),
-			getSessionSpawns: () => "*",
-			getSessionFile: () => null,
-		});
-		expect(sshTool).not.toBeNull();
-
-		await addSSHHost(configPath, "dev2", { host: "192.0.2.21" });
-		const session = createSession(cwd, [], [sshTool as unknown as AgentTool]);
-		await session.refreshSshTool({ activateIfAvailable: true });
-
-		expect(session.getAllToolNames()).toContain("ssh");
-		expect(session.getActiveToolNames()).not.toContain("ssh");
-		expect(session.getToolByName("ssh")?.description).toContain("dev2 (192.0.2.21)");
-	});
-
-	it("reloads ssh from the session's current cwd after move", async () => {
-		const oldProject = TempDir.createSync("@pi-ssh-refresh-old-");
-		const newProject = TempDir.createSync("@pi-ssh-refresh-new-");
-		tempDirs.push(oldProject, newProject);
-		await SessionManager.inMemory(oldProject.path()).moveTo?.(newProject.path());
-		await addSSHHost(getSSHConfigPath("project", newProject.path()), "moved", { host: "198.51.100.8" });
-		const movedTool = await loadSshTool({
-			cwd: newProject.path(),
-			hasUI: false,
-			settings: Settings.isolated({ "compaction.enabled": false }),
-			getSessionSpawns: () => "*",
-			getSessionFile: () => null,
-		});
-		expect(movedTool).not.toBeNull();
-
-		const refreshedSession = createSession(oldProject.path(), [], [], {
-			reloadSshTool: async () => movedTool as unknown as AgentTool,
-		});
-		await refreshedSession.refreshSshTool({ activateIfAvailable: true });
-
-		expect(refreshedSession.getAllToolNames()).toContain("ssh");
-		expect(refreshedSession.getToolByName("ssh")?.description).toContain("moved (198.51.100.8)");
-	});
-
-	it("invalidates cached host metadata before rebuilding descriptions when a host config changes", async () => {
-		const tempDir = TempDir.createSync("@pi-ssh-refresh-");
-		tempDirs.push(tempDir);
-		const cwd = tempDir.path();
-		const configPath = getSSHConfigPath("project", cwd);
-
-		await addSSHHost(configPath, "prod", { host: "203.0.113.9" });
-		const initialTool = await loadSshTool({
-			cwd,
-			hasUI: false,
-			settings: Settings.isolated({ "compaction.enabled": false }),
-			getSessionSpawns: () => "*",
-			getSessionFile: () => null,
-		});
-		expect(initialTool).not.toBeNull();
-		const session = createSession(cwd, [initialTool as unknown as AgentTool]);
-
-		const invalidateSpy = spyOn(connectionManager, "invalidateHostMetadata").mockResolvedValue(undefined);
-		await updateSSHHost(configPath, "prod", { host: "203.0.113.10" });
-		await session.refreshSshTool({ activateIfAvailable: true });
-
-		expect(invalidateSpy).toHaveBeenNthCalledWith(1, new Set(["prod"]));
-		expect(session.getToolByName("ssh")?.description).toContain("prod (203.0.113.10)");
-	});
-
-	it("invalidates newly added host names before rebuilding the ssh tool", async () => {
-		const tempDir = TempDir.createSync("@pi-ssh-refresh-");
-		tempDirs.push(tempDir);
-		const cwd = tempDir.path();
-		const configPath = getSSHConfigPath("project", cwd);
-
-		await addSSHHost(configPath, "fresh", { host: "203.0.113.11" });
-		const session = createSession(cwd);
-		await session.refreshSshTool({ activateIfAvailable: true });
-
-		expect(session.getToolByName("ssh")?.description).toContain("fresh (203.0.113.11)");
-		expect(session.getToolByName("ssh")?.description).toContain("fresh (203.0.113.11)");
-	});
-
-	it("does not activate ssh when it was excluded from the requested tool allowlist", async () => {
-		const tempDir = TempDir.createSync("@pi-ssh-refresh-");
-		tempDirs.push(tempDir);
-		const cwd = tempDir.path();
-		const configPath = getSSHConfigPath("project", cwd);
-		const blockedTool: AgentTool = {
-			name: "ssh",
-			label: "SSH",
-			description: "blocked",
-			parameters: { type: "object", properties: {} },
-			strict: true,
-			execute: async () => ({ content: [{ type: "text", text: "" }] }),
-		};
-
-		await addSSHHost(configPath, "hidden", { host: "203.0.113.12" });
-		const session = createSession(cwd, [], [blockedTool], {
-			reloadSshTool: async () => blockedTool,
-			requestedToolNames: new Set(["read"]),
-		});
-		await session.refreshSshTool({ activateIfAvailable: true });
-
-		expect(session.getAllToolNames()).toContain("ssh");
-		expect(session.getActiveToolNames()).not.toContain("ssh");
-	});
-});
diff --git a/packages/coding-agent/test/agent-session-tool-call-loop-guard.test.ts b/packages/coding-agent/test/agent-session-tool-call-loop-guard.test.ts
index ad2032388..42b57578f 100644
--- a/packages/coding-agent/test/agent-session-tool-call-loop-guard.test.ts
+++ b/packages/coding-agent/test/agent-session-tool-call-loop-guard.test.ts
@@ -94,7 +94,7 @@ describe("AgentSession tool-call loop guard", () => {
 			"todo.enabled": false,
 			"model.toolCallLoopGuard.enabled": true,
 			"model.toolCallLoopGuard.threshold": 5,
-			"model.toolCallLoopGuard.exemptTools": ["job", "irc"],
+			"model.toolCallLoopGuard.exemptTools": ["hub"],
 		});
 		settings.setModelRole("default", `${model.provider}/${model.id}`);
 		session = new AgentSession({
diff --git a/packages/coding-agent/test/agent-session-tool-rebuild-skip.test.ts b/packages/coding-agent/test/agent-session-tool-rebuild-skip.test.ts
index 4f14bea98..4acbea2fe 100644
--- a/packages/coding-agent/test/agent-session-tool-rebuild-skip.test.ts
+++ b/packages/coding-agent/test/agent-session-tool-rebuild-skip.test.ts
@@ -66,7 +66,6 @@ describe("AgentSession refreshMCPTools rebuild skipping", () => {
 	});
 
 	interface NewSessionOptions {
-		mcpDiscoveryEnabled?: boolean;
 		getMcpServerInstructions?: () => Map<string, string> | undefined;
 		getLocalCalendarDate?: () => string;
 	}
@@ -100,7 +99,6 @@ describe("AgentSession refreshMCPTools rebuild skipping", () => {
 			rebuildSystemPrompt: async (toolNames, _tools) => ({
 				systemPrompt: [await rebuildSystemPrompt(toolNames)],
 			}),
-			mcpDiscoveryEnabled: options.mcpDiscoveryEnabled,
 			getMcpServerInstructions: options.getMcpServerInstructions,
 			getLocalCalendarDate: options.getLocalCalendarDate,
 		});
@@ -158,23 +156,21 @@ describe("AgentSession refreshMCPTools rebuild skipping", () => {
 		const a = createMcpCustomTool("mcp__nucleus_search", "nucleus", "search", "Search");
 		const b = createMcpCustomTool("mcp__nucleus_explain", "nucleus", "explain", "Explain");
 
-		// Bring both into the registry; only `mcp__nucleus_search` becomes active per
-		// the agent's initial tool set.
+		// Connected MCP tools are all enabled after refresh.
 		await session.refreshMCPTools([a, b]);
 		const baseline = rebuildCount;
 		expect(baseline).toBeGreaterThanOrEqual(1);
 
-		// Activate the previously-inactive tool: the active list grew, signature must
-		// change, rebuild must fire.
-		await session.setActiveToolsByName(["read", "mcp__nucleus_search", "mcp__nucleus_explain"]);
+		// Remove one active tool: the active list shrinks, so rebuild must fire.
+		await session.setActiveToolsByName(["read", "mcp__nucleus_search"]);
 		expect(rebuildCount).toBe(baseline + 1);
 
 		// Same list again: skip.
-		await session.setActiveToolsByName(["read", "mcp__nucleus_search", "mcp__nucleus_explain"]);
+		await session.setActiveToolsByName(["read", "mcp__nucleus_search"]);
 		expect(rebuildCount).toBe(baseline + 1);
 
-		// Drop one: rebuild fires again.
-		await session.setActiveToolsByName(["read", "mcp__nucleus_search"]);
+		// Restore it: rebuild fires again.
+		await session.setActiveToolsByName(["read", "mcp__nucleus_search", "mcp__nucleus_explain"]);
 		expect(rebuildCount).toBe(baseline + 2);
 	});
 
@@ -246,7 +242,7 @@ describe("AgentSession refreshMCPTools rebuild skipping", () => {
 		expect(rebuildCount).toBe(2);
 	});
 
-	it("ignores incidental insertion order in the refresh argument", async () => {
+	it("rebuilds when the refresh argument tool order changes", async () => {
 		let rebuildCount = 0;
 		const { session } = newSession(async toolNames => {
 			rebuildCount++;
@@ -256,14 +252,13 @@ describe("AgentSession refreshMCPTools rebuild skipping", () => {
 		const a = createMcpCustomTool("mcp__nucleus_a", "nucleus", "a", "A");
 		const b = createMcpCustomTool("mcp__nucleus_b", "nucleus", "b", "B");
 
-		// `refreshMCPTools` re-derives the active tool set from the registry using the
-		// session's existing ordering, so passing the same content in a different order
-		// must not mutate the signature.
+		// All connected MCP tools are active, so their ordering contributes to the
+		// rendered prompt and changing it must rebuild.
 		await session.refreshMCPTools([a, b]);
 		expect(rebuildCount).toBe(1);
 
 		await session.refreshMCPTools([b, a]);
-		expect(rebuildCount).toBe(1);
+		expect(rebuildCount).toBe(2);
 	});
 
 	it("rebuilds when an MCP tool's label changes", async () => {
@@ -320,35 +315,30 @@ describe("AgentSession refreshMCPTools rebuild skipping", () => {
 		expect(rebuildCount).toBe(3);
 	});
 
-	it("rebuilds when a discoverable (inactive) registry tool's metadata changes", async () => {
-		// With MCP discovery on, the rebuilt prompt summarizes ALL discoverable MCP
-		// tools — including ones not in the active set. The signature must capture the
-		// full registry; otherwise a description change to a discoverable-but-inactive
-		// tool would silently leave a stale summary in the cached prompt.
+	it("rebuilds when an MCP registry tool's metadata changes", async () => {
+		// All connected MCP tools are enabled. The signature must capture the full
+		// registry so a description change cannot leave stale prompt metadata cached.
 		let rebuildCount = 0;
-		const { session } = newSession(
-			async toolNames => {
-				rebuildCount++;
-				return `tools:${toolNames.join(",")}`;
-			},
-			{ mcpDiscoveryEnabled: true },
-		);
+		const { session } = newSession(async toolNames => {
+			rebuildCount++;
+			return `tools:${toolNames.join(",")}`;
+		}, {});
 
 		const active = createMcpCustomTool("mcp__nucleus_search", "nucleus", "search", "Search");
-		const discoverable = createMcpCustomTool("mcp__nucleus_explain", "nucleus", "explain", "Explain v1");
+		const secondary = createMcpCustomTool("mcp__nucleus_explain", "nucleus", "explain", "Explain v1");
 
-		await session.refreshMCPTools([active, discoverable]);
+		await session.refreshMCPTools([active, secondary]);
 		const baseline = rebuildCount;
 		expect(baseline).toBeGreaterThanOrEqual(1);
 
 		// Same registry: skip.
-		await session.refreshMCPTools([active, discoverable]);
+		await session.refreshMCPTools([active, secondary]);
 		expect(rebuildCount).toBe(baseline);
 
-		// Mutate the discoverable (NOT active) tool's description: signature must
-		// differ via the registrySegment branch and force a rebuild.
-		const discoverableV2 = createMcpCustomTool("mcp__nucleus_explain", "nucleus", "explain", "Explain v2");
-		await session.refreshMCPTools([active, discoverableV2]);
+		// Mutate the secondary tool's description: the signature must differ and force
+		// a rebuild.
+		const secondaryV2 = createMcpCustomTool("mcp__nucleus_explain", "nucleus", "explain", "Explain v2");
+		await session.refreshMCPTools([active, secondaryV2]);
 		expect(rebuildCount).toBe(baseline + 1);
 	});
 	it("rebuilds when an MCP tool's customWireName changes", async () => {
@@ -388,22 +378,20 @@ describe("AgentSession refreshMCPTools rebuild skipping", () => {
 	it("rebuilds when a tool's getter-based description reflects new settings state", async () => {
 		// Built-in tools whose prompt-rendered metadata depends on settings expose
 		// `description` via getters that re-evaluate on every access (TaskTool reads
-		// task.disabledAgents/maxConcurrency/isolation.mode/simple/async.enabled,
-		// SearchToolBm25Tool reads the discoverable MCP tool count, EditTool resolves
-		// through the current edit-mode definition). The signature reads `tool.description`
-		// live each call, so a settings flip that mutates the rendered string MUST differ
-		// the signature on the next `#applyActiveToolsByName`. Defending this contract
-		// against a future refactor that caches per-tool description strings.
+		// task.disabledAgents/maxConcurrency/isolation.mode/simple/async.enabled, and
+		// EditTool resolves through the current edit-mode definition). The signature
+		// reads `tool.description` live each call, so a settings flip that mutates the
+		// rendered string must change the signature on the next
+		// `#applyActiveToolsByName`.
 		let rebuildCount = 0;
 		const { session } = newSession(
 			async toolNames => {
 				rebuildCount++;
 				return `tools:${toolNames.join(",")}`;
 			},
-			// Discovery-on so the dynamic tool participates in the registry segment too,
-			// matching the production pattern where `TaskTool` and friends are always
-			// reachable via the registry.
-			{ mcpDiscoveryEnabled: true },
+			// The dynamic tool is active, so the signature reads its description via
+			// the active tool metadata segment.
+			{},
 		);
 
 		// Reuse the initially-active MCP name so the tool stays in the active list
diff --git a/packages/coding-agent/test/async-yield-queue.test.ts b/packages/coding-agent/test/async-yield-queue.test.ts
index e4ad7a146..ac373ae49 100644
--- a/packages/coding-agent/test/async-yield-queue.test.ts
+++ b/packages/coding-agent/test/async-yield-queue.test.ts
@@ -4,7 +4,7 @@ import { type AsyncJob, AsyncJobManager } from "@oh-my-pi/pi-coding-agent/async"
 import type { CustomMessage } from "@oh-my-pi/pi-coding-agent/session/messages";
 import { YieldQueue } from "@oh-my-pi/pi-coding-agent/session/yield-queue";
 import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
-import { JobTool } from "@oh-my-pi/pi-coding-agent/tools/job";
+import { type CoordinationDetails, HubTool } from "../src/tools/hub";
 
 type AsyncEntry = {
 	jobId: string;
@@ -131,9 +131,9 @@ describe("async result yield queue delivery", () => {
 		await harness.manager.waitForAll();
 		await waitUntil(() => harness.queue.has("async-result"), "Timed out waiting for staged async result");
 
-		const tool = new JobTool(createToolSession(harness.manager));
-		const result = await tool.execute("tool-call", { poll: [jobId] });
-		expect(result.details?.jobs.find(job => job.id === jobId)?.status).toBe("completed");
+		const tool = new HubTool(createToolSession(harness.manager));
+		const result = await tool.execute("tool-call", { op: "wait", ids: [jobId] });
+		expect((result.details as CoordinationDetails)?.jobs?.find(job => job.id === jobId)?.status).toBe("completed");
 
 		await harness.queue.flush("streaming");
 
diff --git a/packages/coding-agent/test/discovery/builtin-defaults.test.ts b/packages/coding-agent/test/discovery/builtin-defaults.test.ts
index 80b626b99..b5fc21226 100644
--- a/packages/coding-agent/test/discovery/builtin-defaults.test.ts
+++ b/packages/coding-agent/test/discovery/builtin-defaults.test.ts
@@ -60,9 +60,11 @@ describe("builtin-defaults rule provider", () => {
 		expect(lazylock?.condition).toHaveLength(2);
 	});
 
-	it("preserves a per-rule interruptMode override from frontmatter", async () => {
+	it("forces every bundled rule to warn without interrupting", async () => {
 		const rules = await loadBuiltinRules();
-		expect(rules.find(r => r.name === "ts-set-map")?.interruptMode).toBe("never");
+		for (const rule of rules) {
+			expect(rule.interruptMode, rule.name).toBe("never");
+		}
 	});
 
 	it("fires the no-test-timers rule on real timers in *.test.ts but not plain *.ts", async () => {
diff --git a/packages/coding-agent/test/gallery-cli.test.ts b/packages/coding-agent/test/gallery-cli.test.ts
index 6cac5fbe2..67d618388 100644
--- a/packages/coding-agent/test/gallery-cli.test.ts
+++ b/packages/coding-agent/test/gallery-cli.test.ts
@@ -91,9 +91,9 @@ describe("gallery harness", () => {
 
 	it("renders curated failed states as failures", async () => {
 		const cases = [
-			["irc_inbox", "IRC inbox failed: message store unavailable.", "IRC inbox empty"],
-			["irc_list", "IRC list failed: agent hub is unavailable.", "no other agents"],
-			["job", "Subagent exited 1: Redis connection string is missing.", "cancelled"],
+			["hub_inbox", "IRC inbox failed: message store unavailable.", "IRC inbox empty"],
+			["hub_list", "IRC list failed: agent hub is unavailable.", "no other agents"],
+			["hub_jobs", "Subagent exited 1: Redis connection string is missing.", "cancelled"],
 		] as const;
 
 		for (const [name, expected, forbidden] of cases) {
diff --git a/packages/coding-agent/test/goals/goal-mode-integration.test.ts b/packages/coding-agent/test/goals/goal-mode-integration.test.ts
index b60489569..88a66049c 100644
--- a/packages/coding-agent/test/goals/goal-mode-integration.test.ts
+++ b/packages/coding-agent/test/goals/goal-mode-integration.test.ts
@@ -11,7 +11,6 @@ import { AgentSession } from "@oh-my-pi/pi-coding-agent/session/agent-session";
 import { AuthStorage } from "@oh-my-pi/pi-coding-agent/session/auth-storage";
 import { normalizeCustomMessagePayload } from "@oh-my-pi/pi-coding-agent/session/messages";
 import { SessionManager } from "@oh-my-pi/pi-coding-agent/session/session-manager";
-import type { DiscoverableTool } from "@oh-my-pi/pi-coding-agent/tool-discovery/tool-index";
 import { createTools, type Tool, type ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
 import type { TodoPhase } from "@oh-my-pi/pi-coding-agent/tools/todo";
 import { TempDir } from "@oh-my-pi/pi-utils";
@@ -306,71 +305,6 @@ describe("InteractiveMode goal mode integration", () => {
 		expect(content.match(/<\/todo_context>/g)).toHaveLength(1);
 	});
 
-	it("includes no-activation todo state when todo is discoverable but search is inactive", async () => {
-		harness.settings.set("tools.discoveryMode", "all");
-		await harness.mode.handleGoalModeCommand("Ship the release");
-		harness.session.setTodoPhases([
-			{
-				name: "Verification",
-				tasks: [{ content: "Run focused checks", status: "pending" }],
-			},
-		]);
-		expect(harness.session.getActiveToolNames()).not.toContain("todo");
-		expect(harness.session.getActiveToolNames()).not.toContain("search_tool_bm25");
-		expect(harness.session.getDiscoverableTools({ source: "builtin" }).some(tool => tool.name === "todo")).toBe(true);
-		const sendCustomMessage = vi.spyOn(harness.session, "sendCustomMessage").mockResolvedValue(false);
-
-		await harness.session.sendGoalModeContext({ deliverAs: "steer" });
-
-		const message = normalizeCustomMessagePayload(sendCustomMessage.mock.calls[0]?.[0]);
-		const content = typeof message.content === "string" ? message.content : "";
-		expect(message?.customType).toBe("goal-mode-context");
-		expect(content).toContain("<todo_context>");
-		expect(content).toContain("Run focused checks");
-		expect(content).toContain("read-only progress state");
-		expect(content).toContain("not active in this turn");
-		expect(content).toContain("do not claim todo updates unless a later turn exposes the tool");
-		expect(content).not.toContain("activate `todo` first");
-		expect(content).not.toContain("call the `todo` tool first");
-	});
-
-	it("advertises todo activation only when search tool is active", async () => {
-		harness.settings.set("tools.discoveryMode", "all");
-		Object.assign(harness.toolSession, {
-			isToolDiscoveryEnabled: () => harness.session.isToolDiscoveryEnabled(),
-			getSelectedDiscoveredToolNames: () => harness.session.getSelectedDiscoveredToolNames(),
-			activateDiscoveredTools: (toolNames: string[]) => harness.session.activateDiscoveredTools(toolNames),
-			getDiscoverableTools: (filter?: { source?: DiscoverableTool["source"] }) =>
-				harness.session.getDiscoverableTools(filter),
-		});
-		for (const tool of await createTools(harness.toolSession, ["search_tool_bm25"])) {
-			harness.toolRegistry.set(tool.name, tool);
-		}
-		await harness.session.setActiveToolsByName(["read", "search_tool_bm25"]);
-		await harness.mode.handleGoalModeCommand("Ship the release");
-		harness.session.setTodoPhases([
-			{
-				name: "Verification",
-				tasks: [{ content: "Run focused checks", status: "pending" }],
-			},
-		]);
-		expect(harness.session.getActiveToolNames()).not.toContain("todo");
-		expect(harness.session.getActiveToolNames()).toContain("search_tool_bm25");
-		const sendCustomMessage = vi.spyOn(harness.session, "sendCustomMessage").mockResolvedValue(false);
-
-		await harness.session.sendGoalModeContext({ deliverAs: "steer" });
-
-		const message = normalizeCustomMessagePayload(sendCustomMessage.mock.calls[0]?.[0]);
-		const content = typeof message.content === "string" ? message.content : "";
-		expect(message?.customType).toBe("goal-mode-context");
-		expect(content).toContain("<todo_context>");
-		expect(content).toContain("Run focused checks");
-		expect(content).toContain("read-only progress state");
-		expect(content).toContain("discoverable but not active");
-		expect(content).toContain("call `search_tool_bm25` to activate `todo` first");
-		expect(content).not.toContain("do not claim todo updates unless a later turn exposes the tool");
-	});
-
 	it("omits persisted todo state when todo tool is inactive", async () => {
 		await harness.mode.handleGoalModeCommand("Ship the release");
 		harness.session.setTodoPhases([
diff --git a/packages/coding-agent/test/interactive-mode-default-plan-mode.test.ts b/packages/coding-agent/test/interactive-mode-default-plan-mode.test.ts
index 1b67c01e4..51e9a322a 100644
--- a/packages/coding-agent/test/interactive-mode-default-plan-mode.test.ts
+++ b/packages/coding-agent/test/interactive-mode-default-plan-mode.test.ts
@@ -76,13 +76,10 @@ describe("InteractiveMode plan.defaultOnStartup", () => {
 		const registry = new ModelRegistry(authStorage, path.join(tempDir.path(), `models-${Bun.nanoseconds()}.yml`));
 		const initialModel = modelOrThrow(registry, "claude-sonnet-4-5");
 		const readTool = makeTool("read");
-		const resolveTool = makeTool("resolve");
-		// AgentSession requires a Map-typed tool registry; the harness needs both
-		// `read` (the initial active tool) and `resolve` (added on plan-mode entry).
-		const toolRegistry = new Map<string, AgentTool>([
-			[readTool.name, readTool],
-			[resolveTool.name, resolveTool],
-		]);
+		// AgentSession requires a Map-typed tool registry; `read` is the initial
+		// active tool. Plan approval is a `write` to xd://propose, so plan-mode
+		// entry only augments the built-in `write` tool when present.
+		const toolRegistry = new Map<string, AgentTool>([[readTool.name, readTool]]);
 		for (const tool of options.extraRegistryTools ?? []) {
 			toolRegistry.set(tool.name, tool);
 		}
@@ -101,7 +98,7 @@ describe("InteractiveMode plan.defaultOnStartup", () => {
 			settings,
 			modelRegistry: registry,
 			toolRegistry,
-			builtInToolNames: options.builtInToolNames ?? ["read", "resolve"],
+			builtInToolNames: options.builtInToolNames ?? ["read"],
 		});
 		session = createdSession;
 		mode = new InteractiveMode(createdSession, "test");
@@ -115,7 +112,7 @@ describe("InteractiveMode plan.defaultOnStartup", () => {
 
 		expect(created.planModeEnabled).toBe(true);
 		expect(session?.getPlanModeState()).toMatchObject({ enabled: true, planFilePath: "local://PLAN.md" });
-		expect(session?.getActiveToolNames()).toContain("resolve");
+		expect(session?.getActiveToolNames()).toContain("read");
 	});
 
 	it("activates write when entering plan mode even if it was hidden by discoveryMode (issue #3165)", async () => {
@@ -127,7 +124,7 @@ describe("InteractiveMode plan.defaultOnStartup", () => {
 		const writeTool = makeTool("write");
 		const created = createHarness(Settings.isolated({ "plan.defaultOnStartup": true, "compaction.enabled": false }), {
 			extraRegistryTools: [writeTool],
-			builtInToolNames: ["read", "resolve", "write"],
+			builtInToolNames: ["read", "write"],
 		});
 
 		expect(session?.getActiveToolNames()).not.toContain("write");
@@ -136,7 +133,6 @@ describe("InteractiveMode plan.defaultOnStartup", () => {
 
 		expect(created.planModeEnabled).toBe(true);
 		expect(session?.getActiveToolNames()).toContain("write");
-		expect(session?.getActiveToolNames()).toContain("resolve");
 	});
 
 	it("does not activate an extension-shadowed write tool in plan mode", async () => {
@@ -148,7 +144,6 @@ describe("InteractiveMode plan.defaultOnStartup", () => {
 		await created.init({ suppressWelcomeIntro: true });
 
 		expect(created.planModeEnabled).toBe(true);
-		expect(session?.getActiveToolNames()).toContain("resolve");
 		expect(session?.getActiveToolNames()).not.toContain("write");
 	});
 
diff --git a/packages/coding-agent/test/issue-4348-repro.test.ts b/packages/coding-agent/test/issue-4348-repro.test.ts
index f99554c0a..95cd64aef 100644
--- a/packages/coding-agent/test/issue-4348-repro.test.ts
+++ b/packages/coding-agent/test/issue-4348-repro.test.ts
@@ -47,8 +47,6 @@ function transcriptWith(messages: AgentMessage[]): SessionContext {
 		serviceTier: undefined,
 		models: {},
 		injectedTtsrRules: [],
-		selectedMCPToolNames: [],
-		hasPersistedMCPToolSelection: false,
 		mode: "none",
 	};
 }
diff --git a/packages/coding-agent/test/job-poll-displacement.test.ts b/packages/coding-agent/test/job-poll-displacement.test.ts
index 63d6ff526..f1110ee89 100644
--- a/packages/coding-agent/test/job-poll-displacement.test.ts
+++ b/packages/coding-agent/test/job-poll-displacement.test.ts
@@ -1,13 +1,13 @@
 /**
- * Repeated `job` polls must not stack "waiting on N jobs" frames in the
- * transcript: a poll whose watched jobs are all still running stays live
- * (displaceable) and the next `job` call replaces it — one persistent poll.
+ * Repeated `hub` waits must not stack "waiting on N jobs" frames in the
+ * transcript: a wait whose watched jobs are all still running stays live
+ * (displaceable) and the next `hub` call replaces it — one persistent wait.
  *
  * Contracts under test:
  *  - ToolExecutionComponent: a waiting-poll result keeps the block
  *    un-finalized and displaceable; a settled/cancelled/error result
  *    finalizes normally; seal() always freezes.
- *  - EventController: a follow-up `job` call removes the tracked waiting
+ *  - EventController: a follow-up `hub` call removes the tracked waiting
  *    poll from the transcript; any other tool seals it in place.
  */
 import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "bun:test";
@@ -31,6 +31,7 @@ function pollResult(statuses: JobStatus[], extra: { cancelled?: boolean; isError
 		content: [{ type: "text" as const, text: "" }],
 		isError: extra.isError,
 		details: {
+			op: "wait" as const,
 			jobs: statuses.map((status, i) => ({
 				id: `j${i}`,
 				type: "task" as const,
@@ -66,7 +67,7 @@ function trackComponent(components: ToolExecutionComponent[], component: ToolExe
 	return component;
 }
 
-describe("job waiting-poll block lifecycle", () => {
+describe("hub waiting-poll block lifecycle", () => {
 	const created: ToolExecutionComponent[] = [];
 
 	beforeEach(async () => {
@@ -84,7 +85,10 @@ describe("job waiting-poll block lifecycle", () => {
 	});
 
 	function makeJobComponent() {
-		return trackComponent(created, new ToolExecutionComponent("job", { poll: ["j0", "j1"] }, {}, undefined, uiStub));
+		return trackComponent(
+			created,
+			new ToolExecutionComponent("hub", { op: "wait", ids: ["j0", "j1"] }, {}, undefined, uiStub),
+		);
 	}
 
 	it("keeps an all-running poll live and displaceable until sealed", () => {
@@ -184,15 +188,15 @@ describe("EventController displaces consecutive waiting polls", () => {
 		await controller.handleEvent({
 			type: "tool_execution_start",
 			toolCallId,
-			toolName: "job",
-			args: { poll: ["j0"] },
+			toolName: "hub",
+			args: { op: "wait", ids: ["j0"] },
 		});
 		const component = children[children.length - 1] as ToolExecutionComponent;
 		trackComponent(created, component);
 		await controller.handleEvent({
 			type: "tool_execution_end",
 			toolCallId,
-			toolName: "job",
+			toolName: "hub",
 			result: pollResult(["running", "running"]),
 			isError: false,
 		});
@@ -218,7 +222,7 @@ describe("EventController displaces consecutive waiting polls", () => {
 		return component;
 	}
 
-	it("removes the previous waiting poll when the next job call starts", async () => {
+	it("removes the previous waiting poll when the next hub call starts", async () => {
 		const { controller, children } = createFixture();
 
 		const first = await runPoll(controller, children, "t1");
@@ -373,14 +377,14 @@ describe("EventController displaces consecutive waiting polls", () => {
 		await controller.handleEvent({
 			type: "tool_execution_start",
 			toolCallId: "t1",
-			toolName: "job",
-			args: { poll: ["j0"] },
+			toolName: "hub",
+			args: { op: "wait", ids: ["j0"] },
 		});
 		const settled = trackComponent(created, children[children.length - 1] as ToolExecutionComponent);
 		await controller.handleEvent({
 			type: "tool_execution_end",
 			toolCallId: "t1",
-			toolName: "job",
+			toolName: "hub",
 			result: pollResult(["completed", "running"]),
 			isError: false,
 		});
diff --git a/packages/coding-agent/test/job-renderer-preview.test.ts b/packages/coding-agent/test/job-renderer-preview.test.ts
index e261a9673..24bec5a56 100644
--- a/packages/coding-agent/test/job-renderer-preview.test.ts
+++ b/packages/coding-agent/test/job-renderer-preview.test.ts
@@ -7,14 +7,15 @@
 import { afterAll, beforeAll, describe, expect, it } from "bun:test";
 import { resetSettingsForTest, Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
 import { initTheme, theme } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
-import { jobToolRenderer } from "@oh-my-pi/pi-coding-agent/tools/job";
 import { prompt } from "@oh-my-pi/pi-utils";
 import taskSummaryTemplate from "../src/prompts/tools/task-summary.md" with { type: "text" };
+import { hubToolRenderer } from "../src/tools/hub";
 
 function renderLines(resultText: string): string {
 	const result = {
 		content: [{ type: "text", text: "" }],
 		details: {
+			op: "wait" as const,
 			jobs: [
 				{
 					id: "SpawnProbe",
@@ -27,9 +28,9 @@ function renderLines(resultText: string): string {
 			],
 		},
 	};
-	const component = jobToolRenderer.renderResult(
+	const component = hubToolRenderer.renderResult(
 		result,
-		{ expanded: true } as Parameters<typeof jobToolRenderer.renderResult>[1],
+		{ expanded: true } as Parameters<typeof hubToolRenderer.renderResult>[1],
 		theme,
 	);
 	return (component.render(120) as readonly string[]).join("\n");
@@ -140,13 +141,13 @@ describe("job renderer task-result preview", () => {
 		it("shows all jobs when isPartial is true", () => {
 			const result = {
 				content: [{ type: "text" as const, text: "" }],
-				details: { jobs: jobsData },
+				details: { op: "wait" as const, jobs: jobsData },
 			};
-			const component = jobToolRenderer.renderResult(
+			const component = hubToolRenderer.renderResult(
 				result,
-				{ expanded: true, isPartial: true } as Parameters<typeof jobToolRenderer.renderResult>[1],
+				{ expanded: true, isPartial: true } as Parameters<typeof hubToolRenderer.renderResult>[1],
 				theme,
-				{ poll: [] },
+				{ op: "wait", ids: [] },
 			);
 			const output = Bun.stripANSI((component.render(120) as readonly string[]).join("\n"));
 			expect(output).toContain("Job1 running");
@@ -158,13 +159,13 @@ describe("job renderer task-result preview", () => {
 		it("shows only finished jobs when isPartial is false and it is a poll call", () => {
 			const result = {
 				content: [{ type: "text" as const, text: "" }],
-				details: { jobs: jobsData },
+				details: { op: "wait" as const, jobs: jobsData },
 			};
-			const component = jobToolRenderer.renderResult(
+			const component = hubToolRenderer.renderResult(
 				result,
-				{ expanded: true, isPartial: false } as Parameters<typeof jobToolRenderer.renderResult>[1],
+				{ expanded: true, isPartial: false } as Parameters<typeof hubToolRenderer.renderResult>[1],
 				theme,
-				{ poll: [] },
+				{ op: "wait", ids: [] },
 			);
 			const output = Bun.stripANSI((component.render(120) as readonly string[]).join("\n"));
 			expect(output).not.toContain("Job1 running");
@@ -185,13 +186,13 @@ describe("job renderer task-result preview", () => {
 			];
 			const result = {
 				content: [{ type: "text" as const, text: "" }],
-				details: { jobs: runningJobsOnly },
+				details: { op: "wait" as const, jobs: runningJobsOnly },
 			};
-			const component = jobToolRenderer.renderResult(
+			const component = hubToolRenderer.renderResult(
 				result,
-				{ expanded: true, isPartial: false } as Parameters<typeof jobToolRenderer.renderResult>[1],
+				{ expanded: true, isPartial: false } as Parameters<typeof hubToolRenderer.renderResult>[1],
 				theme,
-				{ poll: [] },
+				{ op: "wait", ids: [] },
 			);
 			const lines = component.render(120) as readonly string[];
 			expect(lines).toHaveLength(0);
@@ -200,13 +201,13 @@ describe("job renderer task-result preview", () => {
 		it("does not collapse running jobs when isPartial is false and list is true", () => {
 			const result = {
 				content: [{ type: "text" as const, text: "" }],
-				details: { jobs: jobsData },
+				details: { op: "jobs" as const, jobs: jobsData },
 			};
-			const component = jobToolRenderer.renderResult(
+			const component = hubToolRenderer.renderResult(
 				result,
-				{ expanded: true, isPartial: false } as Parameters<typeof jobToolRenderer.renderResult>[1],
+				{ expanded: true, isPartial: false } as Parameters<typeof hubToolRenderer.renderResult>[1],
 				theme,
-				{ list: true },
+				{ op: "jobs" },
 			);
 			const output = Bun.stripANSI((component.render(120) as readonly string[]).join("\n"));
 			expect(output).toContain("Job1 running");
@@ -218,13 +219,13 @@ describe("job renderer task-result preview", () => {
 		it("does not collapse running jobs when isPartial is false and cancel-only is true", () => {
 			const result = {
 				content: [{ type: "text" as const, text: "" }],
-				details: { jobs: jobsData },
+				details: { op: "cancel" as const, jobs: jobsData },
 			};
-			const component = jobToolRenderer.renderResult(
+			const component = hubToolRenderer.renderResult(
 				result,
-				{ expanded: true, isPartial: false } as Parameters<typeof jobToolRenderer.renderResult>[1],
+				{ expanded: true, isPartial: false } as Parameters<typeof hubToolRenderer.renderResult>[1],
 				theme,
-				{ cancel: ["Job1"] },
+				{ op: "cancel", ids: ["Job1"] },
 			);
 			const output = Bun.stripANSI((component.render(120) as readonly string[]).join("\n"));
 			expect(output).toContain("Job1 running");
@@ -237,15 +238,16 @@ describe("job renderer task-result preview", () => {
 			const result = {
 				content: [{ type: "text" as const, text: "" }],
 				details: {
+					op: "jobs" as const,
 					jobs: [],
 					agents: [{ id: "Worker", parentId: "Main", activity: "grepping the tree", ageMs: 65_000 }],
 				},
 			};
-			const component = jobToolRenderer.renderResult(
+			const component = hubToolRenderer.renderResult(
 				result,
-				{ expanded: true, isPartial: false } as Parameters<typeof jobToolRenderer.renderResult>[1],
+				{ expanded: true, isPartial: false } as Parameters<typeof hubToolRenderer.renderResult>[1],
 				theme,
-				{ list: true },
+				{ op: "jobs" },
 			);
 			const output = Bun.stripANSI((component.render(120) as readonly string[]).join("\n"));
 			expect(output).toContain("1 running agent — no jobs");
@@ -256,13 +258,13 @@ describe("job renderer task-result preview", () => {
 		it("keeps a sealed bare-poll result visible when it carries an agent roster", () => {
 			const result = {
 				content: [{ type: "text" as const, text: "No running background jobs to wait for." }],
-				details: { jobs: [], agents: [{ id: "Worker", ageMs: 1_000 }] },
+				details: { op: "wait" as const, jobs: [], agents: [{ id: "Worker", ageMs: 1_000 }] },
 			};
-			const component = jobToolRenderer.renderResult(
+			const component = hubToolRenderer.renderResult(
 				result,
-				{ expanded: true, isPartial: false } as Parameters<typeof jobToolRenderer.renderResult>[1],
+				{ expanded: true, isPartial: false } as Parameters<typeof hubToolRenderer.renderResult>[1],
 				theme,
-				{ poll: [] },
+				{ op: "wait", ids: [] },
 			);
 			const output = Bun.stripANSI((component.render(120) as readonly string[]).join("\n"));
 			expect(output).toContain("Worker");
diff --git a/packages/coding-agent/test/job-tool-agent-roster.test.ts b/packages/coding-agent/test/job-tool-agent-roster.test.ts
index ce689f1f6..ed34a437b 100644
--- a/packages/coding-agent/test/job-tool-agent-roster.test.ts
+++ b/packages/coding-agent/test/job-tool-agent-roster.test.ts
@@ -10,7 +10,7 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { AsyncJobManager } from "@oh-my-pi/pi-coding-agent/async";
 import { AgentRegistry } from "@oh-my-pi/pi-coding-agent/registry/agent-registry";
 import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
-import { JobTool } from "@oh-my-pi/pi-coding-agent/tools/job";
+import { type CoordinationDetails, HubTool } from "../src/tools/hub";
 
 const managers: AsyncJobManager[] = [];
 
@@ -55,14 +55,14 @@ afterEach(async () => {
 	}
 });
 
-describe("job list snapshot", () => {
-	test("empty list reports 'no jobs' instead of empty output", async () => {
-		const tool = new JobTool(createToolSession({ manager: createManager(), agentId: "Main" }));
+describe("hub jobs snapshot", () => {
+	test("empty jobs snapshot reports 'no jobs' instead of empty output", async () => {
+		const tool = new HubTool(createToolSession({ manager: createManager(), agentId: "Main" }));
 
-		const result = await tool.execute("call", { list: true });
+		const result = await tool.execute("call", { op: "jobs" });
 
 		expect(resultText(result)).toBe("No background jobs.");
-		expect(result.details?.jobs).toEqual([]);
+		expect((result.details as CoordinationDetails)?.jobs).toEqual([]);
 	});
 
 	test("list surfaces running subagents that have no backing job", async () => {
@@ -72,11 +72,11 @@ describe("job list snapshot", () => {
 		registry.setStatus("Idler", "idle");
 		registry.register({ id: "advisor", displayName: "advisor", kind: "advisor", session: null });
 		registry.register({ id: "Main", displayName: "Main", kind: "main", session: null });
-		const tool = new JobTool(createToolSession({ manager: createManager(), registry, agentId: "Main" }));
+		const tool = new HubTool(createToolSession({ manager: createManager(), registry, agentId: "Main" }));
 
-		const result = await tool.execute("call", { list: true });
+		const result = await tool.execute("call", { op: "jobs" });
 
-		expect(result.details?.agents?.map(agent => agent.id)).toEqual(["Worker"]);
+		expect((result.details as CoordinationDetails)?.agents?.map(agent => agent.id)).toEqual(["Worker"]);
 		const text = resultText(result);
 		expect(text).toContain("Running Agents (1)");
 		expect(text).toContain("Worker");
@@ -94,12 +94,12 @@ describe("job list snapshot", () => {
 		registerRunningSub(registry, "vibe-1");
 		// Woken via irc: running agent with no job at all.
 		registerRunningSub(registry, "Loner");
-		const tool = new JobTool(createToolSession({ manager, registry, agentId: "Main" }));
+		const tool = new HubTool(createToolSession({ manager, registry, agentId: "Main" }));
 
-		const result = await tool.execute("call", { list: true });
+		const result = await tool.execute("call", { op: "jobs" });
 
-		expect(result.details?.jobs.map(job => job.id).sort()).toEqual(["AgentA", "vibe-1-t1"]);
-		expect(result.details?.agents?.map(agent => agent.id)).toEqual(["Loner"]);
+		expect((result.details as CoordinationDetails)?.jobs?.map(job => job.id).sort()).toEqual(["AgentA", "vibe-1-t1"]);
+		expect((result.details as CoordinationDetails)?.agents?.map(agent => agent.id)).toEqual(["Loner"]);
 		manager.cancel("AgentA");
 		manager.cancel("vibe-1-t1");
 	});
@@ -111,45 +111,45 @@ describe("job list snapshot", () => {
 		await manager.waitForAll();
 		// The agent was re-woken (e.g. via irc) after its job completed.
 		registerRunningSub(registry, "AgentB");
-		const tool = new JobTool(createToolSession({ manager, registry, agentId: "Main" }));
+		const tool = new HubTool(createToolSession({ manager, registry, agentId: "Main" }));
 
-		const result = await tool.execute("call", { list: true });
+		const result = await tool.execute("call", { op: "jobs" });
 
-		expect(result.details?.jobs.find(job => job.id === "AgentB")?.status).toBe("completed");
-		expect(result.details?.agents?.map(agent => agent.id)).toEqual(["AgentB"]);
+		expect((result.details as CoordinationDetails)?.jobs?.find(job => job.id === "AgentB")?.status).toBe("completed");
+		expect((result.details as CoordinationDetails)?.agents?.map(agent => agent.id)).toEqual(["AgentB"]);
 	});
 });
 
-describe("job poll with no matching jobs", () => {
-	test("bare poll with nothing running stays a useless no-op message", async () => {
-		const tool = new JobTool(createToolSession({ manager: createManager(), agentId: "Main" }));
+describe("hub wait with no matching jobs", () => {
+	test("bare wait with nothing running stays a useless no-op message", async () => {
+		const tool = new HubTool(createToolSession({ manager: createManager(), agentId: "Main" }));
 
-		const result = await tool.execute("call", {});
+		const result = await tool.execute("call", { op: "wait" });
 
 		expect(resultText(result)).toBe("No running background jobs to wait for.");
 		expect(result.useless).toBe(true);
 	});
 
-	test("bare poll reports running agents outside job control", async () => {
+	test("bare wait reports running agents outside job control", async () => {
 		const registry = new AgentRegistry();
 		registerRunningSub(registry, "Worker");
-		const tool = new JobTool(createToolSession({ manager: createManager(), registry, agentId: "Main" }));
+		const tool = new HubTool(createToolSession({ manager: createManager(), registry }));
 
-		const result = await tool.execute("call", {});
+		const result = await tool.execute("call", { op: "wait" });
 
 		const text = resultText(result);
 		expect(text).toContain("No running background jobs to wait for.");
 		expect(text).toContain("Worker");
-		expect(result.details?.agents?.map(agent => agent.id)).toEqual(["Worker"]);
+		expect((result.details as CoordinationDetails)?.agents?.map(agent => agent.id)).toEqual(["Worker"]);
 		expect(result.useless).toBeUndefined();
 	});
 
-	test("polling an agent id that has no job explains the agent's state", async () => {
+	test("waiting on an agent id that has no job explains the agent's state", async () => {
 		const registry = new AgentRegistry();
 		registerRunningSub(registry, "Worker");
-		const tool = new JobTool(createToolSession({ manager: createManager(), registry, agentId: "Main" }));
+		const tool = new HubTool(createToolSession({ manager: createManager(), registry, agentId: "Main" }));
 
-		const result = await tool.execute("call", { poll: ["Worker"] });
+		const result = await tool.execute("call", { op: "wait", ids: ["Worker"] });
 
 		const text = resultText(result);
 		expect(text).toContain("No matching jobs found for IDs: Worker");
diff --git a/packages/coding-agent/test/modes/utils/render-initial-messages.test.ts b/packages/coding-agent/test/modes/utils/render-initial-messages.test.ts
index bc3df339f..5f5ceb529 100644
--- a/packages/coding-agent/test/modes/utils/render-initial-messages.test.ts
+++ b/packages/coding-agent/test/modes/utils/render-initial-messages.test.ts
@@ -50,8 +50,6 @@ function makeEmptyContext(): SessionContext {
 		serviceTier: undefined,
 		models: {},
 		injectedTtsrRules: [],
-		selectedMCPToolNames: [],
-		hasPersistedMCPToolSelection: false,
 		mode: "none",
 	};
 }
diff --git a/packages/coding-agent/test/read-tool-group.test.ts b/packages/coding-agent/test/read-tool-group.test.ts
index e5b6c43da..40c421c2e 100644
--- a/packages/coding-agent/test/read-tool-group.test.ts
+++ b/packages/coding-agent/test/read-tool-group.test.ts
@@ -5,7 +5,7 @@ import { resetSettingsForTest, Settings, settings } from "@oh-my-pi/pi-coding-ag
 import { getDefault } from "@oh-my-pi/pi-coding-agent/config/settings-schema";
 import {
 	ReadToolGroupComponent,
-	readArgsTargetInternalUrl,
+	readArgsCollapseIntoGroup,
 } from "@oh-my-pi/pi-coding-agent/modes/components/read-tool-group";
 import * as themeModule from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
 
@@ -275,7 +275,7 @@ describe("ReadToolGroupComponent", () => {
 	});
 });
 
-describe("readArgsTargetInternalUrl", () => {
+describe("readArgsCollapseIntoGroup", () => {
 	it.each([
 		["skill://my-skill"],
 		["skill://my-skill/file.md"],
@@ -288,26 +288,28 @@ describe("readArgsTargetInternalUrl", () => {
 		["rule://name"],
 		["mcp://server/resource"],
 		["local://PLAN.md"],
-	])("treats %s as an internal URL read", target => {
-		expect(readArgsTargetInternalUrl({ path: target })).toBe(true);
-		expect(readArgsTargetInternalUrl({ file_path: target })).toBe(true);
+	])("keeps %s as a full tool execution (not grouped)", target => {
+		expect(readArgsCollapseIntoGroup({ path: target })).toBe(false);
+		expect(readArgsCollapseIntoGroup({ file_path: target })).toBe(false);
 	});
 
 	it.each([
 		[path.resolve("/tmp/example.ts")],
 		["./relative/path.md"],
 		["https://example.com/file"],
-		[""],
-	])("treats %s as a filesystem/external target", target => {
-		expect(readArgsTargetInternalUrl({ path: target })).toBe(false);
+		["xd://"],
+		["xd://generate_image"],
+	])("collapses %s into the read group", target => {
+		expect(readArgsCollapseIntoGroup({ path: target })).toBe(true);
+		expect(readArgsCollapseIntoGroup({ file_path: target })).toBe(true);
 	});
 
 	it("returns false for non-record / missing arguments", () => {
-		expect(readArgsTargetInternalUrl(undefined)).toBe(false);
-		expect(readArgsTargetInternalUrl(null)).toBe(false);
-		expect(readArgsTargetInternalUrl("skill://x")).toBe(false);
-		expect(readArgsTargetInternalUrl(["skill://x"])).toBe(false);
-		expect(readArgsTargetInternalUrl({})).toBe(false);
-		expect(readArgsTargetInternalUrl({ path: 42 })).toBe(false);
+		expect(readArgsCollapseIntoGroup(undefined)).toBe(false);
+		expect(readArgsCollapseIntoGroup(null)).toBe(false);
+		expect(readArgsCollapseIntoGroup("xd://x")).toBe(false);
+		expect(readArgsCollapseIntoGroup(["xd://x"])).toBe(false);
+		expect(readArgsCollapseIntoGroup({})).toBe(false);
+		expect(readArgsCollapseIntoGroup({ path: 42 })).toBe(false);
 	});
 });
diff --git a/packages/coding-agent/test/sdk-generate-image-tool-gating.test.ts b/packages/coding-agent/test/sdk-generate-image-tool-gating.test.ts
index 977adbd9a..48adf9e61 100644
--- a/packages/coding-agent/test/sdk-generate-image-tool-gating.test.ts
+++ b/packages/coding-agent/test/sdk-generate-image-tool-gating.test.ts
@@ -73,4 +73,22 @@ describe("generate_image tool gating", () => {
 		const names = await activeToolNames(Settings.isolated({}), ["read", "generate_image"]);
 		expect(names).toContain("generate_image");
 	});
+
+	it("exposes generate_image as an xd:// device (not top-level) in a default session", async () => {
+		// Default session (no explicit --tools) with tools.xdev on: image-gen is a
+		// discoverable custom tool, so it mounts as an xd:// device instead of
+		// shipping its schema top-level.
+		const { session } = await createAgentSession({
+			cwd: registryDir,
+			agentDir: registryDir,
+			modelRegistry,
+			sessionManager: SessionManager.inMemory(),
+			settings: Settings.isolated({}),
+			model: getBundledModel("openai", "gpt-4o-mini"),
+			disableExtensionDiscovery: true,
+		});
+		sessions.push(session);
+		expect(session.getActiveToolNames()).not.toContain("generate_image");
+		expect(session.getXdevToolEntries().map(entry => entry.name)).toContain("generate_image");
+	});
 });
diff --git a/packages/coding-agent/test/sdk-mcp-auto-discovery.test.ts b/packages/coding-agent/test/sdk-mcp-auto-discovery.test.ts
deleted file mode 100644
index 888c85925..000000000
--- a/packages/coding-agent/test/sdk-mcp-auto-discovery.test.ts
+++ /dev/null
@@ -1,242 +0,0 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, mock, spyOn } from "bun:test";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { AuthStorage } from "@oh-my-pi/pi-ai";
-import { getBundledModel } from "@oh-my-pi/pi-catalog/models";
-import { ModelRegistry } from "@oh-my-pi/pi-coding-agent/config/model-registry";
-import { Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
-import { createAgentSession } from "@oh-my-pi/pi-coding-agent/sdk";
-import { SessionManager } from "@oh-my-pi/pi-coding-agent/session/session-manager";
-import { getAgentDir, removeSyncWithRetries, Snowflake, setAgentDir } from "@oh-my-pi/pi-utils";
-import { MANY_TOOL_COUNT } from "./fixtures/many-tools-mcp";
-
-// Contracts for deferred (hasUI) MCP discovery follow-ups:
-//
-// 1. `tools.discoveryMode: "auto"` is resolved at session build time against a
-//    registry that cannot yet contain the deferred MCP tools. When the
-//    background connect reports a toolset large enough to cross the auto
-//    threshold, the session MUST upgrade to discovery mode — register and
-//    activate `search_tool_bm25`, mark discovery enabled, and expose the MCP
-//    tools as discoverable — instead of force-activating all of them.
-//
-// 2. A session disposed while servers are still connecting MUST NOT be touched
-//    by the late discovery result: no tools resurrected onto the disposed
-//    session and the manager's transports disconnected.
-const FIXTURE_PATH = path.join(import.meta.dir, "fixtures", "many-tools-mcp.ts");
-
-describe("createAgentSession deferred MCP auto discovery", () => {
-	let registryDir: string;
-	let tempDir: string;
-	let authStorage: AuthStorage;
-	let modelRegistry: ModelRegistry;
-	let originalAgentDir: string;
-	// Discovery resolves user-level MCP config from `os.homedir()`; redirect it
-	// to an empty dir so the test connects ONLY to the fixture server and never
-	// spawns the developer's real MCP servers.
-	let isolatedHome: string;
-
-	beforeAll(async () => {
-		registryDir = path.join(os.tmpdir(), `pi-sdk-mcp-auto-registry-${Snowflake.next()}`);
-		fs.mkdirSync(registryDir, { recursive: true });
-		isolatedHome = path.join(os.tmpdir(), `pi-sdk-mcp-auto-home-${Snowflake.next()}`);
-		fs.mkdirSync(isolatedHome, { recursive: true });
-		originalAgentDir = getAgentDir();
-		authStorage = await AuthStorage.create(path.join(registryDir, "auth.db"));
-		modelRegistry = new ModelRegistry(authStorage);
-	});
-
-	afterAll(() => {
-		authStorage.close();
-		for (const dir of [registryDir, isolatedHome]) {
-			if (dir && fs.existsSync(dir)) {
-				removeSyncWithRetries(dir);
-			}
-		}
-	});
-
-	beforeEach(() => {
-		tempDir = path.join(os.tmpdir(), `pi-sdk-mcp-auto-${Snowflake.next()}`);
-		fs.mkdirSync(tempDir, { recursive: true });
-		setAgentDir(tempDir);
-		spyOn(os, "homedir").mockReturnValue(isolatedHome);
-	});
-
-	afterEach(() => {
-		setAgentDir(originalAgentDir);
-		if (tempDir && fs.existsSync(tempDir)) {
-			removeSyncWithRetries(tempDir);
-		}
-		mock.restore();
-	});
-
-	const writeMcpConfig = (extraArgs: string[] = []) => {
-		fs.writeFileSync(
-			path.join(tempDir, ".mcp.json"),
-			JSON.stringify({
-				mcpServers: {
-					many: { type: "stdio", command: process.execPath, args: [FIXTURE_PATH, ...extraArgs] },
-				},
-			}),
-		);
-	};
-
-	const baseOptions = () => ({
-		cwd: tempDir,
-		agentDir: tempDir,
-		modelRegistry,
-		sessionManager: SessionManager.inMemory(),
-		settings: Settings.isolated({}),
-		model: getBundledModel("openai", "gpt-4o-mini"),
-		disableExtensionDiscovery: true,
-		skills: [],
-		contextFiles: [],
-		promptTemplates: [],
-		slashCommands: [],
-		enableLsp: false,
-		skipPythonPreflight: true,
-		enableMCP: true,
-		hasUI: true,
-	});
-
-	it("flips auto discovery on when the deferred MCP toolset crosses the threshold", async () => {
-		writeMcpConfig();
-		// A small explicit toolset keeps the pre-discovery registry far below the
-		// 40-tool auto threshold; the fixture's 45 tools must push it across.
-		const { session } = await createAgentSession({ ...baseOptions(), toolNames: ["read", "edit", "bash"] });
-		try {
-			// Genuine integration wait: discovery spawns the fixture as a real
-			// subprocess and connects asynchronously, and the SDK fires that work
-			// fire-and-forget with no completion promise or event exposed — fake
-			// timers cannot drive a child process, so poll the live session with
-			// a generous ceiling, exiting the instant discovery flips on.
-			const deadline = Date.now() + 30_000;
-			while (!session.isMCPDiscoveryEnabled() && Date.now() < deadline) {
-				await Bun.sleep(50);
-			}
-
-			expect(session.isMCPDiscoveryEnabled()).toBe(true);
-			const activeNames = session.getActiveToolNames();
-			expect(activeNames).toContain("search_tool_bm25");
-			// Discovery mode means the MCP tools are searchable, NOT force-activated.
-			expect(activeNames.filter(name => name.startsWith("mcp__"))).toEqual([]);
-			const discoverable = session.getDiscoverableTools({ source: "mcp" });
-			expect(discoverable.length).toBe(MANY_TOOL_COUNT);
-		} finally {
-			await session.dispose();
-		}
-	}, 40_000);
-
-	it("flips auto discovery when MCP tools finish after the startup timeout", async () => {
-		writeMcpConfig(["--delay", "750"]);
-		const { session } = await createAgentSession({ ...baseOptions(), toolNames: ["read"] });
-		try {
-			// The manager returns from startup after 250 ms while this fixture is
-			// still connecting. Its eventual tools arrive through onToolsChanged,
-			// so wait for that observable registry update rather than a fixed delay.
-			const deadline = Date.now() + 30_000;
-			while (
-				session.getAllToolNames().filter(name => name.startsWith("mcp__")).length < MANY_TOOL_COUNT &&
-				Date.now() < deadline
-			) {
-				await Bun.sleep(50);
-			}
-
-			expect(session.isMCPDiscoveryEnabled()).toBe(true);
-			const activeNames = session.getActiveToolNames();
-			expect(activeNames).toContain("read");
-			expect(activeNames).toContain("search_tool_bm25");
-			expect(activeNames.filter(name => name.startsWith("mcp__"))).toEqual([]);
-			expect(session.getDiscoverableTools({ source: "mcp" })).toHaveLength(MANY_TOOL_COUNT);
-		} finally {
-			await session.dispose();
-		}
-	}, 40_000);
-
-	it("disposing mid-connect disconnects the manager and never resurrects tools", async () => {
-		// Stall `initialize` in the real fixture subprocess so the connect is
-		// guaranteed to still be in flight when dispose() runs. Deterministic
-		// time control cannot order a race against a child process.
-		writeMcpConfig(["--delay", "750"]);
-		const { session, mcpManager } = await createAgentSession({
-			...baseOptions(),
-			toolNames: ["read", "edit", "bash"],
-		});
-		expect(mcpManager).toBeDefined();
-		if (!mcpManager) throw new Error("expected deferred session to own an MCPManager");
-		const disconnectSpy = spyOn(mcpManager, "disconnectAll");
-
-		await session.dispose();
-		expect(session.isDisposed).toBe(true);
-
-		// Genuine integration wait (see above): the deferred task notices the
-		// disposed session once the stalled connect resolves and must disconnect
-		// instead of refreshing tools. Exits the instant the spy fires.
-		const deadline = Date.now() + 30_000;
-		while (disconnectSpy.mock.calls.length === 0 && Date.now() < deadline) {
-			await Bun.sleep(50);
-		}
-		expect(disconnectSpy).toHaveBeenCalled();
-		expect(session.getActiveToolNames().filter(name => name.startsWith("mcp__"))).toEqual([]);
-		expect(session.getActiveToolNames()).not.toContain("search_tool_bm25");
-		expect(session.isMCPDiscoveryEnabled()).toBe(false);
-	}, 40_000);
-
-	it("disconnects the owned MCP manager when a top-level session disposes", async () => {
-		writeMcpConfig();
-		const { session, mcpManager } = await createAgentSession({
-			...baseOptions(),
-			toolNames: ["read", "edit", "bash"],
-		});
-		expect(mcpManager).toBeDefined();
-		if (!mcpManager) throw new Error("expected owning session to create an MCPManager");
-		try {
-			// Let the deferred connect FINISH first, so a later disconnectAll can
-			// only originate from dispose() itself — not the mid-connect disposal
-			// path (covered by the test above). Genuine integration wait: discovery
-			// connects a real subprocess fire-and-forget with no awaitable signal,
-			// and fake timers cannot drive a child process; poll the live session
-			// with a generous ceiling, exiting the instant discovery flips on.
-			const deadline = Date.now() + 30_000;
-			while (!session.isMCPDiscoveryEnabled() && Date.now() < deadline) {
-				await Bun.sleep(50);
-			}
-			expect(session.isMCPDiscoveryEnabled()).toBe(true);
-			expect(mcpManager.getConnectedServers()).toContain("many");
-
-			const disconnectSpy = spyOn(mcpManager, "disconnectAll");
-			await session.dispose();
-			expect(disconnectSpy).toHaveBeenCalled();
-		} finally {
-			// dispose() already tore it down; this is idempotent belt-and-braces.
-			await mcpManager.disconnectAll();
-		}
-	}, 40_000);
-
-	it("does not disconnect a reused parent MCP manager when a child session disposes", async () => {
-		writeMcpConfig();
-		const parent = await createAgentSession({
-			...baseOptions(),
-			toolNames: ["read", "edit", "bash"],
-		});
-		expect(parent.mcpManager).toBeDefined();
-		if (!parent.mcpManager) throw new Error("expected parent session to create an MCPManager");
-		const parentManager = parent.mcpManager;
-		try {
-			// A subagent-style session reuses the parent's manager via
-			// `mcpManager` and therefore does NOT own it.
-			const child = await createAgentSession({
-				...baseOptions(),
-				hasUI: false,
-				toolNames: ["read"],
-				mcpManager: parentManager,
-			});
-			const disconnectSpy = spyOn(parentManager, "disconnectAll");
-			await child.session.dispose();
-			expect(disconnectSpy).not.toHaveBeenCalled();
-		} finally {
-			await parent.session.dispose();
-			await parentManager.disconnectAll();
-		}
-	}, 40_000);
-});
diff --git a/packages/coding-agent/test/sdk-mcp-discovery.test.ts b/packages/coding-agent/test/sdk-mcp-discovery.test.ts
deleted file mode 100644
index 71deb1a66..000000000
--- a/packages/coding-agent/test/sdk-mcp-discovery.test.ts
+++ /dev/null
@@ -1,514 +0,0 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "bun:test";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import { AuthStorage, Effort, type Model } from "@oh-my-pi/pi-ai";
-import { buildModel } from "@oh-my-pi/pi-catalog/build";
-import { getBundledModel } from "@oh-my-pi/pi-catalog/models";
-import { ModelRegistry } from "@oh-my-pi/pi-coding-agent/config/model-registry";
-import { Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
-import type { CustomTool } from "@oh-my-pi/pi-coding-agent/extensibility/custom-tools/types";
-import { createAgentSession } from "@oh-my-pi/pi-coding-agent/sdk";
-import { SessionManager } from "@oh-my-pi/pi-coding-agent/session/session-manager";
-import { TOOL_DISCOVERY_AUTO_THRESHOLD } from "@oh-my-pi/pi-coding-agent/tool-discovery/mode";
-import { removeSyncWithRetries, Snowflake } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
-
-function createMcpCustomTool(name: string, serverName: string, mcpToolName: string): CustomTool {
-	return {
-		name,
-		label: `${serverName}/${mcpToolName}`,
-		description: `Tool ${mcpToolName} from ${serverName}`,
-		mcpServerName: serverName,
-		mcpToolName,
-		parameters: type({ query: "string" }),
-		async execute() {
-			return { content: [{ type: "text", text: `${name} executed` }] };
-		},
-	} as CustomTool;
-}
-
-function createReasoningModel(): Model<"openai-responses"> {
-	return buildModel({
-		id: "mock-reasoning",
-		name: "mock-reasoning",
-		api: "openai-responses",
-		provider: "openai",
-		baseUrl: "https://example.invalid",
-		reasoning: true,
-		thinking: { mode: "effort", efforts: [Effort.Medium, Effort.High] },
-		input: ["text"],
-		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-		contextWindow: 8192,
-		maxTokens: 2048,
-	});
-}
-
-const oldSessionMtime = new Date("2000-01-01T00:00:00.000Z");
-
-describe("createAgentSession MCP discovery prompt gating", () => {
-	let tempDir: string;
-	let registryDir: string;
-	let authStorage: AuthStorage;
-	let modelRegistry: ModelRegistry;
-
-	// Immutable across tests: ModelRegistry's constructor eagerly loads the bundled
-	// model catalog (~120ms). The tests pass models explicitly and never mutate the
-	// registry (refreshInBackground is skipped when modelRegistry is supplied, and
-	// extension source sync is empty under disableExtensionDiscovery), so build it once.
-	beforeAll(async () => {
-		registryDir = path.join(os.tmpdir(), `pi-sdk-mcp-discovery-registry-${Snowflake.next()}`);
-		fs.mkdirSync(registryDir, { recursive: true });
-		authStorage = await AuthStorage.create(path.join(registryDir, "auth.db"));
-		modelRegistry = new ModelRegistry(authStorage);
-	});
-
-	afterAll(() => {
-		authStorage.close();
-		if (registryDir && fs.existsSync(registryDir)) {
-			removeSyncWithRetries(registryDir);
-		}
-	});
-
-	beforeEach(() => {
-		tempDir = path.join(os.tmpdir(), `pi-sdk-mcp-discovery-${Snowflake.next()}`);
-		fs.mkdirSync(tempDir, { recursive: true });
-	});
-
-	afterEach(() => {
-		if (tempDir && fs.existsSync(tempDir)) {
-			removeSyncWithRetries(tempDir);
-		}
-	});
-
-	it("does not advertise MCP discovery when search_tool_bm25 is not active", async () => {
-		const { session } = await createAgentSession({
-			cwd: tempDir,
-			agentDir: tempDir,
-			modelRegistry,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			model: getBundledModel("openai", "gpt-4o-mini"),
-			disableExtensionDiscovery: true,
-			skills: [],
-			contextFiles: [],
-			promptTemplates: [],
-			slashCommands: [],
-			enableMCP: false,
-			enableLsp: false,
-			toolNames: ["read"],
-			customTools: [createMcpCustomTool("mcp__github_create_issue", "github", "create_issue")],
-		});
-
-		expect(session.systemPrompt.join("\n")).not.toContain("### MCP tool discovery");
-		expect(session.systemPrompt.join("\n")).not.toContain(
-			"call `search_tool_bm25` before concluding no such tool exists",
-		);
-	});
-
-	it("default auto discovery hides MCP tools once the total tool set is too large", async () => {
-		const mcpTools = Array.from({ length: TOOL_DISCOVERY_AUTO_THRESHOLD + 1 }, (_, index) =>
-			createMcpCustomTool(`mcp__auto_tool_${index}`, "auto", `tool_${index}`),
-		);
-		const { session } = await createAgentSession({
-			cwd: tempDir,
-			agentDir: tempDir,
-			modelRegistry,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({}),
-			model: getBundledModel("openai", "gpt-4o-mini"),
-			disableExtensionDiscovery: true,
-			skills: [],
-			contextFiles: [],
-			promptTemplates: [],
-			slashCommands: [],
-			enableMCP: false,
-			enableLsp: false,
-			customTools: mcpTools,
-		});
-
-		const activeNames = session.getActiveToolNames();
-		expect(session.isToolDiscoveryEnabled()).toBe(true);
-		expect(activeNames).toContain("search_tool_bm25");
-		expect(activeNames).not.toContain("mcp__auto_tool_0");
-		expect(session.getDiscoverableTools({ source: "mcp" })).toHaveLength(TOOL_DISCOVERY_AUTO_THRESHOLD + 1);
-	});
-
-	it("advertises discovery guidance for builtin-only tools.discoveryMode all sessions", async () => {
-		const { session } = await createAgentSession({
-			cwd: tempDir,
-			agentDir: tempDir,
-			modelRegistry,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "tools.discoveryMode": "all" }),
-			model: getBundledModel("openai", "gpt-4o-mini"),
-			disableExtensionDiscovery: true,
-			skills: [],
-			contextFiles: [],
-			promptTemplates: [],
-			slashCommands: [],
-			enableMCP: false,
-			enableLsp: false,
-		});
-
-		const prompt = session.systemPrompt.join("\n");
-		const searchTool = session.agent.state.tools.find(tool => tool.name === "search_tool_bm25");
-		expect(session.getActiveToolNames()).not.toContain("search");
-		expect(prompt).toContain("call `search_tool_bm25` before concluding no such tool exists");
-		expect(searchTool?.description).toContain("Total discoverable tools available:");
-	});
-
-	it("exposes task under tools.discoveryMode all when task.eager is preferred", async () => {
-		const { session } = await createAgentSession({
-			cwd: tempDir,
-			agentDir: tempDir,
-			modelRegistry,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "tools.discoveryMode": "all", "task.eager": "preferred" }),
-			model: getBundledModel("openai", "gpt-4o-mini"),
-			disableExtensionDiscovery: true,
-			skills: [],
-			contextFiles: [],
-			promptTemplates: [],
-			slashCommands: [],
-			enableMCP: false,
-			enableLsp: false,
-		});
-
-		expect(session.getActiveToolNames()).toContain("task");
-		await session.dispose();
-	});
-
-	it("hides task under tools.discoveryMode all when task.eager is default", async () => {
-		const { session } = await createAgentSession({
-			cwd: tempDir,
-			agentDir: tempDir,
-			modelRegistry,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "tools.discoveryMode": "all" }),
-			model: getBundledModel("openai", "gpt-4o-mini"),
-			disableExtensionDiscovery: true,
-			skills: [],
-			contextFiles: [],
-			promptTemplates: [],
-			slashCommands: [],
-			enableMCP: false,
-			enableLsp: false,
-		});
-
-		expect(session.getActiveToolNames()).not.toContain("task");
-		await session.dispose();
-	});
-
-	it("preserves explicitly requested MCP tools in discovery mode", async () => {
-		const { session } = await createAgentSession({
-			cwd: tempDir,
-			agentDir: tempDir,
-			modelRegistry,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			model: getBundledModel("openai", "gpt-4o-mini"),
-			disableExtensionDiscovery: true,
-			skills: [],
-			contextFiles: [],
-			promptTemplates: [],
-			slashCommands: [],
-			enableMCP: false,
-			enableLsp: false,
-			toolNames: ["read", "mcp__github_create_issue", "search_tool_bm25"],
-			customTools: [
-				createMcpCustomTool("mcp__github_create_issue", "github", "create_issue"),
-				createMcpCustomTool("mcp__slack_post_message", "slack", "post_message"),
-			],
-		});
-
-		expect(session.getActiveToolNames()).toContain("mcp__github_create_issue");
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__github_create_issue"]);
-		expect(session.systemPrompt.join("\n")).toContain("mcp__github_create_issue");
-
-		await session.activateDiscoveredMCPTools(["mcp__slack_post_message"]);
-
-		expect(session.getActiveToolNames()).toEqual(
-			expect.arrayContaining(["read", "search_tool_bm25", "mcp__github_create_issue", "mcp__slack_post_message"]),
-		);
-		expect(session.getSelectedMCPToolNames()).toEqual(["mcp__github_create_issue", "mcp__slack_post_message"]);
-	});
-
-	it("keeps configured discovery default servers visible in discovery mode", async () => {
-		const { session } = await createAgentSession({
-			cwd: tempDir,
-			agentDir: tempDir,
-			modelRegistry,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({
-				"mcp.discoveryMode": true,
-				"mcp.discoveryDefaultServers": ["github", "missing"],
-			}),
-			model: getBundledModel("openai", "gpt-4o-mini"),
-			disableExtensionDiscovery: true,
-			skills: [],
-			contextFiles: [],
-			promptTemplates: [],
-			slashCommands: [],
-			enableMCP: false,
-			enableLsp: false,
-			toolNames: ["read", "search_tool_bm25"],
-			customTools: [
-				createMcpCustomTool("mcp__github_create_issue", "github", "create_issue"),
-				createMcpCustomTool("mcp__slack_post_message", "slack", "post_message"),
-			],
-		});
-		try {
-			expect(session.getSelectedMCPToolNames()).toEqual(["mcp__github_create_issue"]);
-			expect(session.getActiveToolNames()).toEqual(
-				expect.arrayContaining(["read", "search_tool_bm25", "mcp__github_create_issue"]),
-			);
-			expect(session.getActiveToolNames()).not.toContain("mcp__slack_post_message");
-		} finally {
-			await session.dispose();
-		}
-	});
-
-	it("builds search_tool_bm25 descriptions from the loaded MCP catalog", async () => {
-		const { session } = await createAgentSession({
-			cwd: tempDir,
-			agentDir: tempDir,
-			modelRegistry,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			model: getBundledModel("openai", "gpt-4o-mini"),
-			disableExtensionDiscovery: true,
-			skills: [],
-			contextFiles: [],
-			promptTemplates: [],
-			slashCommands: [],
-			enableMCP: false,
-			enableLsp: false,
-			toolNames: ["read", "search_tool_bm25"],
-			customTools: [createMcpCustomTool("mcp__github_create_issue", "github", "create_issue")],
-		});
-
-		const searchTool = session.agent.state.tools.find(tool => tool.name === "search_tool_bm25");
-		expect(searchTool?.description).toContain("Total discoverable tools available: 1.");
-		expect(searchTool?.description).toContain("Discoverable MCP servers in this session: github (1 tool).");
-	});
-
-	it("prunes deactivated builtin discoveries so they can be rediscovered", async () => {
-		const { session } = await createAgentSession({
-			cwd: tempDir,
-			agentDir: tempDir,
-			modelRegistry,
-			sessionManager: SessionManager.inMemory(),
-			settings: Settings.isolated({ "tools.discoveryMode": "all" }),
-			model: getBundledModel("openai", "gpt-4o-mini"),
-			disableExtensionDiscovery: true,
-			skills: [],
-			contextFiles: [],
-			promptTemplates: [],
-			slashCommands: [],
-			enableMCP: false,
-			enableLsp: false,
-		});
-
-		expect(await session.activateDiscoveredTools(["grep"])).toEqual(["grep"]);
-		expect(session.getSelectedDiscoveredToolNames()).toContain("grep");
-
-		await session.setActiveToolsByName(["read", "search_tool_bm25"]);
-
-		expect(session.getActiveToolNames()).not.toContain("grep");
-		expect(session.getSelectedDiscoveredToolNames()).not.toContain("grep");
-		expect(await session.activateDiscoveredTools(["grep"])).toEqual(["grep"]);
-		expect(session.getActiveToolNames()).toContain("grep");
-	});
-	it("restores explicit MCP, thinking, and service-tier entries when resuming without rewriting the session file", async () => {
-		const firstManager = SessionManager.create(tempDir, tempDir);
-		const { session: firstSession } = await createAgentSession({
-			cwd: tempDir,
-			agentDir: tempDir,
-			modelRegistry,
-			sessionManager: firstManager,
-			settings: Settings.isolated({
-				"mcp.discoveryMode": true,
-				defaultThinkingLevel: "high",
-				"tier.openai": "priority",
-			}),
-			model: createReasoningModel(),
-			disableExtensionDiscovery: true,
-			skills: [],
-			contextFiles: [],
-			promptTemplates: [],
-			slashCommands: [],
-			enableMCP: false,
-			enableLsp: false,
-			toolNames: ["read", "search_tool_bm25"],
-			customTools: [
-				createMcpCustomTool("mcp__github_create_issue", "github", "create_issue"),
-				createMcpCustomTool("mcp__slack_post_message", "slack", "post_message"),
-			],
-		});
-		await firstSession.activateDiscoveredMCPTools(["mcp__slack_post_message"]);
-		firstSession.sessionManager.appendThinkingLevelChange(ThinkingLevel.Off);
-		firstSession.sessionManager.appendServiceTierChange({ openai: "priority" });
-		expect(firstSession.sessionManager.buildSessionContext().thinkingLevel).toBe(ThinkingLevel.Off);
-		expect(firstSession.getSelectedMCPToolNames()).toEqual(["mcp__slack_post_message"]);
-		const sessionFile = firstSession.sessionFile;
-		expect(sessionFile).toBeDefined();
-		await firstSession.sessionManager.rewriteEntries();
-		fs.utimesSync(sessionFile!, oldSessionMtime, oldSessionMtime);
-		const persistedBeforeResume = fs.readFileSync(sessionFile!, "utf8");
-		const persistedMtimeBeforeResume = fs.statSync(sessionFile!).mtimeMs;
-		await firstSession.dispose();
-		const resumedManager = await SessionManager.open(sessionFile!, tempDir);
-		const { session: resumedSession } = await createAgentSession({
-			cwd: tempDir,
-			agentDir: tempDir,
-			modelRegistry,
-			sessionManager: resumedManager,
-			settings: Settings.isolated({
-				"mcp.discoveryMode": true,
-				defaultThinkingLevel: "high",
-				"tier.openai": "none",
-			}),
-			model: createReasoningModel(),
-			disableExtensionDiscovery: true,
-			skills: [],
-			contextFiles: [],
-			promptTemplates: [],
-			slashCommands: [],
-			enableMCP: false,
-			enableLsp: false,
-			toolNames: ["read", "search_tool_bm25"],
-			customTools: [
-				createMcpCustomTool("mcp__github_create_issue", "github", "create_issue"),
-				createMcpCustomTool("mcp__slack_post_message", "slack", "post_message"),
-			],
-		});
-		try {
-			expect(resumedSession.thinkingLevel).toBe(ThinkingLevel.Off);
-			expect(resumedSession.serviceTierByFamily).toEqual({ openai: "priority" });
-			expect(resumedSession.getSelectedMCPToolNames()).toEqual(["mcp__slack_post_message"]);
-			expect(resumedSession.getActiveToolNames()).toEqual(
-				expect.arrayContaining(["read", "search_tool_bm25", "mcp__slack_post_message"]),
-			);
-			expect(resumedSession.systemPrompt.join("\n")).toContain("mcp__slack_post_message");
-			expect(fs.readFileSync(sessionFile!, "utf8")).toBe(persistedBeforeResume);
-			expect(fs.statSync(sessionFile!).mtimeMs).toBe(persistedMtimeBeforeResume);
-		} finally {
-			await resumedSession.dispose();
-		}
-	});
-
-	it("restores fallback MCP, thinking, and service-tier state in memory without rewriting the session file", async () => {
-		const sessionManager = SessionManager.create(tempDir, tempDir);
-		sessionManager.appendMessage({
-			role: "user",
-			content: "resume me",
-			timestamp: Date.now(),
-		});
-		const sessionFile = sessionManager.getSessionFile();
-		expect(sessionFile).toBeDefined();
-		await sessionManager.rewriteEntries();
-		fs.utimesSync(sessionFile!, oldSessionMtime, oldSessionMtime);
-		const persistedBeforeResume = fs.readFileSync(sessionFile!, "utf8");
-		const persistedMtimeBeforeResume = fs.statSync(sessionFile!).mtimeMs;
-		const resumedManager = await SessionManager.open(sessionFile!, tempDir);
-		const { session } = await createAgentSession({
-			cwd: tempDir,
-			agentDir: tempDir,
-			modelRegistry,
-			sessionManager: resumedManager,
-			settings: Settings.isolated({
-				"mcp.discoveryMode": true,
-				"mcp.discoveryDefaultServers": ["github"],
-				defaultThinkingLevel: "high",
-				"tier.openai": "priority",
-			}),
-			model: createReasoningModel(),
-			disableExtensionDiscovery: true,
-			skills: [],
-			contextFiles: [],
-			promptTemplates: [],
-			slashCommands: [],
-			enableMCP: false,
-			enableLsp: false,
-			toolNames: ["read", "search_tool_bm25"],
-			customTools: [
-				createMcpCustomTool("mcp__github_create_issue", "github", "create_issue"),
-				createMcpCustomTool("mcp__slack_post_message", "slack", "post_message"),
-			],
-		});
-		try {
-			expect(session.thinkingLevel).toBe(ThinkingLevel.High);
-			expect(session.serviceTierByFamily).toEqual({ openai: "priority" });
-			expect(session.getSelectedMCPToolNames()).toEqual(["mcp__github_create_issue"]);
-			expect(session.getActiveToolNames()).toEqual(
-				expect.arrayContaining(["read", "search_tool_bm25", "mcp__github_create_issue"]),
-			);
-			expect(session.sessionManager.buildSessionContext().hasPersistedMCPToolSelection).toBe(false);
-			expect(fs.readFileSync(sessionFile!, "utf8")).toBe(persistedBeforeResume);
-			expect(fs.statSync(sessionFile!).mtimeMs).toBe(persistedMtimeBeforeResume);
-		} finally {
-			await session.dispose();
-		}
-	});
-
-	it("keeps a cleared MCP selection empty when resuming with explicitly requested MCP tools", async () => {
-		const firstManager = SessionManager.create(tempDir, tempDir);
-		const { session: firstSession } = await createAgentSession({
-			cwd: tempDir,
-			agentDir: tempDir,
-			modelRegistry,
-			sessionManager: firstManager,
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			model: getBundledModel("openai", "gpt-4o-mini"),
-			disableExtensionDiscovery: true,
-			skills: [],
-			contextFiles: [],
-			promptTemplates: [],
-			slashCommands: [],
-			enableMCP: false,
-			enableLsp: false,
-			toolNames: ["read", "search_tool_bm25", "mcp__github_create_issue"],
-			customTools: [
-				createMcpCustomTool("mcp__github_create_issue", "github", "create_issue"),
-				createMcpCustomTool("mcp__slack_post_message", "slack", "post_message"),
-			],
-		});
-		await firstSession.setActiveToolsByName(["read", "search_tool_bm25"]);
-		expect(firstSession.getSelectedMCPToolNames()).toEqual([]);
-		const sessionFile = firstSession.sessionFile;
-		expect(sessionFile).toBeDefined();
-		await firstSession.sessionManager.rewriteEntries();
-		await firstSession.dispose();
-
-		const resumedManager = await SessionManager.open(sessionFile!, tempDir);
-		const { session: resumedSession } = await createAgentSession({
-			cwd: tempDir,
-			agentDir: tempDir,
-			modelRegistry,
-			sessionManager: resumedManager,
-			settings: Settings.isolated({ "mcp.discoveryMode": true }),
-			model: getBundledModel("openai", "gpt-4o-mini"),
-			disableExtensionDiscovery: true,
-			skills: [],
-			contextFiles: [],
-			promptTemplates: [],
-			slashCommands: [],
-			enableMCP: false,
-			enableLsp: false,
-			toolNames: ["read", "search_tool_bm25", "mcp__github_create_issue"],
-			customTools: [
-				createMcpCustomTool("mcp__github_create_issue", "github", "create_issue"),
-				createMcpCustomTool("mcp__slack_post_message", "slack", "post_message"),
-			],
-		});
-		try {
-			expect(resumedSession.getSelectedMCPToolNames()).toEqual([]);
-			expect(resumedSession.getActiveToolNames()).toEqual(expect.arrayContaining(["read", "search_tool_bm25"]));
-			expect(resumedSession.getActiveToolNames()).not.toContain("mcp__github_create_issue");
-		} finally {
-			await resumedSession.dispose();
-		}
-	});
-});
diff --git a/packages/coding-agent/test/sdk-tool-activation.test.ts b/packages/coding-agent/test/sdk-tool-activation.test.ts
index fd6c4e343..55125324c 100644
--- a/packages/coding-agent/test/sdk-tool-activation.test.ts
+++ b/packages/coding-agent/test/sdk-tool-activation.test.ts
@@ -111,7 +111,11 @@ describe("createAgentSession defaultInactive tool activation", () => {
 			expect(session.getAllToolNames()).toEqual(
 				expect.arrayContaining(["default_active_tool", "default_inactive_tool"]),
 			);
-			expect(session.getActiveToolNames()).toContain("default_active_tool");
+			// Discoverable extension tools mount as xd:// devices, not top-level active tools.
+			const deviceNames = session.getXdevToolEntries().map(entry => entry.name);
+			expect(deviceNames).toContain("default_active_tool");
+			expect(session.getActiveToolNames()).not.toContain("default_active_tool");
+			expect(deviceNames).not.toContain("default_inactive_tool");
 			expect(session.getActiveToolNames()).not.toContain("default_inactive_tool");
 			expect(session.systemPrompt.join("\n")).toContain("default_active_tool");
 			expect(session.systemPrompt.join("\n")).not.toContain("default_inactive_tool");
@@ -180,14 +184,14 @@ describe("createAgentSession defaultInactive tool activation", () => {
 		}
 	});
 
-	it("keeps the hidden resolve tool registered for plan mode even when no deferrable tool is requested", async () => {
-		// Regression for #1428: plan mode submits its finalized plan via
-		// `resolve { action: "apply" }` dispatched through a standing handler
-		// (interactive-mode.ts: `setStandingResolveHandler`). With an explicit
+	it("keeps the write tool registered for plan mode even when no deferrable tool is requested", async () => {
+		// Regression for #1428 (adapted to the xd://propose device): plan mode
+		// submits its finalized plan by writing the chosen slug/title to
+		// xd://propose, dispatched through the plan-proposal handler
+		// (interactive-mode.ts: `setPlanProposalHandler`). With an explicit
 		// read-only `toolNames` (e.g. `read`, `search`, `find`, `web_search`)
-		// the registry has no `deferrable` tool, so the previous gate dropped
-		// `resolve` from the registry and plan mode silently activated without
-		// it — leaving the agent stuck after drafting the plan.
+		// the registry has no `write` and no `deferrable` tool; dropping it would
+		// silently activate plan mode with no way to submit the plan.
 		const tempDir = makeTempDir();
 
 		const { session } = await createAgentSession({
@@ -196,13 +200,13 @@ describe("createAgentSession defaultInactive tool activation", () => {
 		});
 
 		try {
-			expect(session.getToolByName("resolve")).toBeDefined();
+			expect(session.getToolByName("write")).toBeDefined();
 		} finally {
 			await session.dispose();
 		}
 	});
 
-	it("drops the hidden resolve tool when neither a deferrable tool nor plan mode can use it", async () => {
+	it("does not force write into the registry when neither a deferrable tool nor plan mode needs it", async () => {
 		const tempDir = makeTempDir();
 
 		const settings = Settings.isolated();
@@ -215,7 +219,7 @@ describe("createAgentSession defaultInactive tool activation", () => {
 		});
 
 		try {
-			expect(session.getToolByName("resolve")).toBeUndefined();
+			expect(session.getToolByName("write")).toBeUndefined();
 		} finally {
 			await session.dispose();
 		}
@@ -273,7 +277,9 @@ describe("createAgentSession defaultInactive tool activation", () => {
 
 		try {
 			expect(session.getToolByName("tts")).toBeDefined();
-			expect(session.getActiveToolNames()).toContain("tts");
+			// tts is a discoverable custom tool → mounted as an xd:// device, not top-level.
+			expect(session.getXdevToolEntries().map(entry => entry.name)).toContain("tts");
+			expect(session.getActiveToolNames()).not.toContain("tts");
 		} finally {
 			await session.dispose();
 		}
diff --git a/packages/coding-agent/test/settings-manager.test.ts b/packages/coding-agent/test/settings-manager.test.ts
index 2f5958941..f47c2e38d 100644
--- a/packages/coding-agent/test/settings-manager.test.ts
+++ b/packages/coding-agent/test/settings-manager.test.ts
@@ -694,17 +694,6 @@ describe("Settings", () => {
 			expect(settings.get("grep.enabled")).toBe(true);
 		});
 
-		it("migrates legacy tool names in persisted essential overrides", async () => {
-			await writeSettings({
-				tools: { essentialOverride: ["read", "find", "search", "grep"] },
-				"tools.essentialOverride": ["find", "search", "read"],
-			});
-
-			const settings = await Settings.init({ cwd: projectDir, agentDir });
-
-			expect(settings.get("tools.essentialOverride")).toEqual(["read", "glob", "grep"]);
-		});
-
 		it("migrates from settings.json containing comments", async () => {
 			const jsonPath = path.join(agentDir, "settings.json");
 			await fs.promises.writeFile(
diff --git a/packages/coding-agent/test/ssh/ssh-executor.test.ts b/packages/coding-agent/test/ssh/ssh-executor.test.ts
deleted file mode 100644
index d261ff157..000000000
--- a/packages/coding-agent/test/ssh/ssh-executor.test.ts
+++ /dev/null
@@ -1,95 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "bun:test";
-import * as connectionManager from "@oh-my-pi/pi-coding-agent/ssh/connection-manager";
-import { executeSSH } from "@oh-my-pi/pi-coding-agent/ssh/ssh-executor";
-import * as sshfsMount from "@oh-my-pi/pi-coding-agent/ssh/sshfs-mount";
-import { type ChildProcess, ptree } from "@oh-my-pi/pi-utils";
-
-type TestStdin = "pipe" | "ignore" | Buffer | Uint8Array | null;
-
-function createNeverClosingStream(): ReadableStream<Uint8Array> {
-	return new ReadableStream<Uint8Array>({
-		start(controller) {
-			controller.enqueue(new TextEncoder().encode("started\n"));
-		},
-	});
-}
-
-function createBlockedChild<In extends TestStdin>(exited?: Promise<number>): ChildProcess<In> {
-	const { promise } = Promise.withResolvers<number>();
-
-	return {
-		stdout: createNeverClosingStream(),
-		stderr: undefined,
-		exited: exited ?? promise,
-		[Symbol.dispose]() {},
-	} as unknown as ChildProcess<In>;
-}
-
-async function flushMicrotasks(count: number): Promise<void> {
-	for (let i = 0; i < count; i++) {
-		await Promise.resolve();
-	}
-}
-
-describe("executeSSH", () => {
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	function mockOpenStreamChild(exited?: Promise<number>) {
-		vi.spyOn(connectionManager, "ensureConnection").mockResolvedValue();
-		vi.spyOn(connectionManager, "buildRemoteCommand").mockResolvedValue(["remote", "sleep 60"]);
-		vi.spyOn(sshfsMount, "hasSshfs").mockReturnValue(false);
-		vi.spyOn(ptree, "spawn").mockImplementation(<In extends TestStdin>() => createBlockedChild<In>(exited));
-	}
-
-	function startOpenStreamCommand(controller: AbortController) {
-		const chunked = Promise.withResolvers<void>();
-		const resultPromise = executeSSH({ name: "remote", host: "remote" }, "sleep 60", {
-			signal: controller.signal,
-			onChunk: () => chunked.resolve(),
-		});
-		return { resultPromise, chunked: chunked.promise };
-	}
-
-	it("returns promptly when an abort races a ControlMaster stream that stays open", async () => {
-		mockOpenStreamChild();
-
-		const controller = new AbortController();
-		const { resultPromise, chunked } = startOpenStreamCommand(controller);
-		await chunked;
-
-		let result: Awaited<typeof resultPromise> | undefined;
-		resultPromise.then(value => {
-			result = value;
-		});
-		controller.abort("user interrupt");
-		await flushMicrotasks(20);
-		expect(result).toBeDefined();
-		if (!result) return;
-		expect(result.cancelled).toBe(true);
-		expect(result.exitCode).toBeUndefined();
-		expect(result.output).toContain("Command aborted");
-	});
-
-	it("reports cancellation when abort unblocks streams after the ssh process exits", async () => {
-		mockOpenStreamChild(Promise.resolve(0));
-
-		const controller = new AbortController();
-		const { resultPromise, chunked } = startOpenStreamCommand(controller);
-		await chunked;
-		await flushMicrotasks(20);
-
-		let result: Awaited<typeof resultPromise> | undefined;
-		resultPromise.then(value => {
-			result = value;
-		});
-		controller.abort("user interrupt");
-		await flushMicrotasks(20);
-		expect(result).toBeDefined();
-		if (!result) return;
-		expect(result.cancelled).toBe(true);
-		expect(result.exitCode).toBeUndefined();
-		expect(result.output).toContain("Command aborted");
-	});
-});
diff --git a/packages/coding-agent/test/task/subagent-lsp.test.ts b/packages/coding-agent/test/task/subagent-lsp.test.ts
index 6b0a6145c..fb098200e 100644
--- a/packages/coding-agent/test/task/subagent-lsp.test.ts
+++ b/packages/coding-agent/test/task/subagent-lsp.test.ts
@@ -268,7 +268,7 @@ describe("subagent LSP availability", () => {
 			description: "Reviewer-like task agent",
 			systemPrompt: "Review with read-only specialty tools.",
 			source: "bundled",
-			tools: ["bash", "ast_grep", "report_finding", "memory_edit", "retain", "todo"],
+			tools: ["bash", "ast_grep", "memory_edit", "retain", "todo"],
 		});
 		const { getOptions } = mockCreateAgentSession();
 		const planMode = { enabled: true, planFilePath: "local://PLAN.md" };
@@ -278,7 +278,7 @@ describe("subagent LSP availability", () => {
 
 		const toolNames = getOptions()?.toolNames;
 		expect(getOptions()?.enableLsp).toBe(true);
-		expect(toolNames).toEqual(["read", "grep", "glob", "lsp", "web_search", "ast_grep", "report_finding", "irc"]);
+		expect(toolNames).toEqual(["read", "grep", "glob", "lsp", "web_search", "ast_grep", "hub"]);
 		expect(toolNames).not.toContain("bash");
 		expect(toolNames).not.toContain("memory_edit");
 		expect(toolNames).not.toContain("retain");
diff --git a/packages/coding-agent/test/tool-discovery/initial-tools.test.ts b/packages/coding-agent/test/tool-discovery/initial-tools.test.ts
deleted file mode 100644
index 0d2e7881b..000000000
--- a/packages/coding-agent/test/tool-discovery/initial-tools.test.ts
+++ /dev/null
@@ -1,192 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
-import type { BuiltinToolLoadMode, ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
-import {
-	AskTool,
-	BUILTIN_TOOLS,
-	computeEssentialBuiltinNames,
-	createTools,
-	DEFAULT_ESSENTIAL_TOOL_NAMES,
-	filterInitialToolsForDiscoveryAll,
-	GithubTool,
-	IrcTool,
-	JobTool,
-	SshTool,
-} from "@oh-my-pi/pi-coding-agent/tools";
-
-const allToolsSettings = Settings.isolated({
-	"astGrep.enabled": true,
-	"astEdit.enabled": true,
-	"debug.enabled": true,
-	"glob.enabled": true,
-	"grep.enabled": true,
-	"github.enabled": true,
-	"lsp.enabled": true,
-	"inspect_image.enabled": true,
-	"web_search.enabled": true,
-	"browser.enabled": true,
-	"checkpoint.enabled": true,
-	"todo.enabled": true,
-	"memory.backend": "mnemopi",
-	"autolearn.enabled": true,
-	"tools.discoveryMode": "all",
-});
-
-const toolSession: ToolSession = {
-	cwd: "/tmp/test",
-	hasUI: false,
-	getSessionFile: () => null,
-	getSessionSpawns: () => null,
-	settings: allToolsSettings,
-	isToolDiscoveryEnabled: () => true,
-	getSelectedDiscoveredToolNames: () => [],
-	activateDiscoveredTools: async names => names,
-};
-
-async function getToolMetadata(): Promise<Map<string, { loadMode?: string; summary?: string }>> {
-	const tools = await createTools(toolSession, Object.keys(BUILTIN_TOOLS));
-	const metadata = new Map(tools.map(tool => [tool.name, { loadMode: tool.loadMode, summary: tool.summary }]));
-	for (const tool of [
-		new AskTool({ ...toolSession, hasUI: true }),
-		new GithubTool(toolSession),
-		new SshTool(toolSession, [], new Map(), ""),
-		new JobTool(toolSession),
-		new IrcTool(toolSession),
-	]) {
-		metadata.set(tool.name, { loadMode: tool.loadMode, summary: tool.summary });
-	}
-	return metadata;
-}
-describe("BUILTIN_TOOLS public factory map", () => {
-	it("sets loading fields on tool definitions without wrapping factories", async () => {
-		const metadata = await getToolMetadata();
-		const missing = Object.keys(BUILTIN_TOOLS).filter(name => metadata.get(name)?.loadMode === undefined);
-		expect(missing).toEqual([]);
-	});
-	it("exposes launch instead of daemon", async () => {
-		const launch = await BUILTIN_TOOLS.launch(toolSession);
-		expect(launch?.name).toBe("launch");
-		expect(Object.hasOwn(BUILTIN_TOOLS, "daemon")).toBeFalse();
-	});
-});
-
-describe("built-in tool loadMode annotations", () => {
-	it("provides a summary for every discoverable tool", async () => {
-		const missing: string[] = [];
-		const metadata = await getToolMetadata();
-		for (const [name, meta] of metadata) {
-			if (meta.loadMode === "discoverable" && !meta.summary) {
-				missing.push(name);
-			}
-		}
-		expect(missing).toEqual([]);
-	});
-
-	it("marks eval essential so it survives tools.discoveryMode 'all'", async () => {
-		const metadata = await getToolMetadata();
-		expect(metadata.get("eval")?.loadMode).toBe("essential");
-		// Essential loadMode keeps eval active under discovery-all even when it is
-		// absent from the essential-names set — not relying on the names list.
-		const kept = filterInitialToolsForDiscoveryAll(["eval"], {
-			loadModeOf: name => metadata.get(name)?.loadMode as BuiltinToolLoadMode | undefined,
-			essentialNames: new Set<string>(),
-			explicitlyRequested: new Set<string>(),
-			restored: new Set<string>(),
-			forceActive: new Set<string>(),
-		});
-		expect(kept).toEqual(["eval"]);
-	});
-});
-
-describe("computeEssentialBuiltinNames", () => {
-	it("returns DEFAULT_ESSENTIAL_TOOL_NAMES when override is empty", () => {
-		const settings = Settings.isolated({});
-		expect(computeEssentialBuiltinNames(settings).sort()).toEqual([...DEFAULT_ESSENTIAL_TOOL_NAMES].sort());
-	});
-
-	it("respects tools.essentialOverride when provided", () => {
-		const settings = Settings.isolated({ "tools.essentialOverride": ["read", "glob"] });
-		expect(computeEssentialBuiltinNames(settings).sort()).toEqual(["glob", "read"]);
-	});
-
-	it("maps legacy essential override tool names", () => {
-		const settings = Settings.isolated({ "tools.essentialOverride": ["read", "find", "search", "glob"] });
-		expect(computeEssentialBuiltinNames(settings).sort()).toEqual(["glob", "grep", "read"]);
-	});
-
-	it("filters override entries that are not known built-in tools", () => {
-		const settings = Settings.isolated({
-			"tools.essentialOverride": ["read", "not_a_real_tool", "edit"],
-		});
-		expect(computeEssentialBuiltinNames(settings).sort()).toEqual(["edit", "read"]);
-	});
-
-	it("trims whitespace and drops empty entries from the override", () => {
-		const settings = Settings.isolated({
-			"tools.essentialOverride": [" read ", "", "  "],
-		});
-		expect(computeEssentialBuiltinNames(settings)).toEqual(["read"]);
-	});
-
-	it("falls back to defaults when override is non-empty but contains only invalid names", () => {
-		// The filtered list is empty (no valid names), but the override was provided —
-		// current behavior returns the empty filtered list (caller can decide). Document the behavior.
-		const settings = Settings.isolated({
-			"tools.essentialOverride": ["not_a_real_tool"],
-		});
-		expect(computeEssentialBuiltinNames(settings)).toEqual([]);
-	});
-});
-
-describe("tools.discoveryMode settings schema", () => {
-	it("defaults to auto discovery mode", () => {
-		const settings = Settings.isolated({});
-		expect(settings.get("tools.discoveryMode")).toBe("auto");
-	});
-
-	it("back-compat: mcp.discoveryMode still accepted", () => {
-		const settings = Settings.isolated({ "mcp.discoveryMode": true });
-		expect(settings.get("mcp.discoveryMode")).toBe(true);
-	});
-});
-
-describe("filterInitialToolsForDiscoveryAll", () => {
-	const loadModes: Record<string, BuiltinToolLoadMode> = {
-		read: "essential",
-		edit: "essential",
-		todo: "discoverable",
-		grep: "discoverable",
-	};
-	const base = {
-		loadModeOf: (name: string): BuiltinToolLoadMode | undefined => loadModes[name],
-		essentialNames: new Set(["read", "bash", "edit", "write", "glob"]),
-		explicitlyRequested: new Set<string>(),
-		restored: new Set<string>(),
-		forceActive: new Set<string>(),
-	};
-
-	it("hides non-essential discoverable built-ins", () => {
-		expect(filterInitialToolsForDiscoveryAll(["read", "edit", "todo", "grep"], base)).toEqual(["read", "edit"]);
-	});
-
-	it("keeps discoverable tools required by a forced tool_choice (eager todo)", () => {
-		const result = filterInitialToolsForDiscoveryAll(["read", "todo", "grep"], {
-			...base,
-			forceActive: new Set(["todo"]),
-		});
-		expect(result).toEqual(["read", "todo"]);
-	});
-
-	it("keeps explicitly requested and restored discoverable tools", () => {
-		const result = filterInitialToolsForDiscoveryAll(["todo", "grep"], {
-			...base,
-			explicitlyRequested: new Set(["grep"]),
-			restored: new Set(["todo"]),
-		});
-		expect([...result].sort()).toEqual(["grep", "todo"]);
-	});
-
-	it("never hides tools without a built-in loadMode (MCP/custom/extension)", () => {
-		expect(filterInitialToolsForDiscoveryAll(["mcp__server__tool", "grep"], base)).toEqual(["mcp__server__tool"]);
-	});
-});
diff --git a/packages/coding-agent/test/tool-discovery/persistence.test.ts b/packages/coding-agent/test/tool-discovery/persistence.test.ts
deleted file mode 100644
index 3fcc276bb..000000000
--- a/packages/coding-agent/test/tool-discovery/persistence.test.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import type { DiscoverableTool } from "@oh-my-pi/pi-coding-agent/tool-discovery/tool-index";
-import {
-	buildDiscoverableToolSearchIndex,
-	searchDiscoverableTools,
-} from "@oh-my-pi/pi-coding-agent/tool-discovery/tool-index";
-
-describe("generic index: DiscoverableTool round-trip", () => {
-	const tools: DiscoverableTool[] = [
-		{
-			name: "glob",
-			label: "glob",
-			summary: "Find files matching a glob pattern",
-			source: "builtin",
-			schemaKeys: ["pattern", "path"],
-		},
-		{
-			name: "mcp__gh_search",
-			label: "github/search",
-			summary: "Search GitHub repositories",
-			source: "mcp",
-			serverName: "github",
-			mcpToolName: "search",
-			schemaKeys: ["query"],
-		},
-	];
-
-	it("builds and searches without loss", () => {
-		const index = buildDiscoverableToolSearchIndex(tools);
-		expect(index.documents).toHaveLength(2);
-
-		const findResults = searchDiscoverableTools(index, "find files", 3);
-		expect(findResults.some((r: any) => r.tool.name === "glob")).toBe(true);
-
-		const ghResults = searchDiscoverableTools(index, "github search", 3);
-		expect(ghResults.some((r: any) => r.tool.name === "mcp__gh_search")).toBe(true);
-	});
-
-	it("preserves source field in search results", () => {
-		const index = buildDiscoverableToolSearchIndex(tools);
-		const results = searchDiscoverableTools(index, "github", 3);
-		const ghResult = results.find((r: any) => r.tool.name === "mcp__gh_search");
-		expect(ghResult).toBeDefined();
-		expect(ghResult!.tool.source).toBe("mcp");
-	});
-});
diff --git a/packages/coding-agent/test/tool-discovery/subagent.test.ts b/packages/coding-agent/test/tool-discovery/subagent.test.ts
deleted file mode 100644
index df567650c..000000000
--- a/packages/coding-agent/test/tool-discovery/subagent.test.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
-import {
-	resolveEffectiveToolDiscoveryMode,
-	TOOL_DISCOVERY_AUTO_THRESHOLD,
-} from "@oh-my-pi/pi-coding-agent/tool-discovery/mode";
-
-// ─── Subagent discovery mode inheritance tests ────────────────────────────────
-// These are unit-level tests that verify the settings resolution logic
-// without needing to spin up a full AgentSession or subagent.
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe("effective discovery mode resolution", () => {
-	function resolveEffectiveMode(settings: Settings, toolCount = 0): "off" | "mcp-only" | "all" {
-		return resolveEffectiveToolDiscoveryMode(settings, toolCount);
-	}
-
-	it("tools.discoveryMode=all beats mcp.discoveryMode=false", () => {
-		const s = Settings.isolated({ "tools.discoveryMode": "all", "mcp.discoveryMode": false });
-		expect(resolveEffectiveMode(s)).toBe("all");
-	});
-
-	it("tools.discoveryMode=mcp-only beats mcp.discoveryMode=false", () => {
-		const s = Settings.isolated({ "tools.discoveryMode": "mcp-only", "mcp.discoveryMode": false });
-		expect(resolveEffectiveMode(s)).toBe("mcp-only");
-	});
-
-	it("tools.discoveryMode=off + mcp.discoveryMode=true → mcp-only (back-compat alias)", () => {
-		const s = Settings.isolated({ "tools.discoveryMode": "off", "mcp.discoveryMode": true });
-		expect(resolveEffectiveMode(s)).toBe("mcp-only");
-	});
-
-	it("tools.discoveryMode=off + mcp.discoveryMode=false → off", () => {
-		const s = Settings.isolated({ "tools.discoveryMode": "off", "mcp.discoveryMode": false });
-		expect(resolveEffectiveMode(s)).toBe("off");
-	});
-
-	it("default auto settings stay off at the threshold", () => {
-		const s = Settings.isolated({});
-		expect(s.get("tools.discoveryMode")).toBe("auto");
-		expect(resolveEffectiveMode(s, TOOL_DISCOVERY_AUTO_THRESHOLD)).toBe("off");
-	});
-
-	it("default auto settings enable mcp-only above the threshold", () => {
-		const s = Settings.isolated({});
-		expect(resolveEffectiveMode(s, TOOL_DISCOVERY_AUTO_THRESHOLD + 1)).toBe("mcp-only");
-	});
-});
diff --git a/packages/coding-agent/test/tool-discovery/tool-index.test.ts b/packages/coding-agent/test/tool-discovery/tool-index.test.ts
deleted file mode 100644
index 1b418d807..000000000
--- a/packages/coding-agent/test/tool-discovery/tool-index.test.ts
+++ /dev/null
@@ -1,311 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import type { DiscoverableTool } from "@oh-my-pi/pi-coding-agent/tool-discovery/tool-index";
-import {
-	buildDiscoverableToolSearchIndex,
-	collectDiscoverableTools,
-	filterBySource,
-	formatDiscoverableToolServerSummary,
-	getDiscoverableTool,
-	isMCPToolName,
-	searchDiscoverableTools,
-	selectDiscoverableToolNamesByServer,
-	summarizeDiscoverableTools,
-} from "@oh-my-pi/pi-coding-agent/tool-discovery/tool-index";
-import { type } from "arktype";
-
-// ─── Minimal AgentTool stub ───────────────────────────────────────────────────
-
-function makeAgentTool(
-	name: string,
-	opts: {
-		label?: string;
-		description?: string;
-		mcpServerName?: string;
-		mcpToolName?: string;
-		parameters?: object;
-	} = {},
-) {
-	return {
-		name,
-		label: opts.label ?? name,
-		description: opts.description ?? `${name} description`,
-		mcpServerName: opts.mcpServerName,
-		mcpToolName: opts.mcpToolName,
-		parameters: opts.parameters,
-		strict: false,
-		async execute() {
-			return { content: [] };
-		},
-	} as any;
-}
-
-function mcpAgentTool(
-	name: string,
-	serverName: string,
-	mcpToolName: string,
-	description: string,
-	schemaKeys: string[] = [],
-) {
-	const properties = Object.fromEntries(schemaKeys.map(k => [k, { type: "string" }]));
-	return makeAgentTool(name, {
-		label: `${serverName}/${mcpToolName}`,
-		description,
-		mcpServerName: serverName,
-		mcpToolName,
-		parameters: { type: "object", properties },
-	});
-}
-
-// ─── isMCPToolName ────────────────────────────────────────────────────────────
-
-describe("isMCPToolName", () => {
-	it("returns true for mcp__ prefixed names", () => {
-		expect(isMCPToolName("mcp__github_search")).toBe(true);
-		expect(isMCPToolName("mcp__")).toBe(true);
-	});
-	it("returns false for non-mcp names", () => {
-		expect(isMCPToolName("read")).toBe(false);
-		expect(isMCPToolName("bash")).toBe(false);
-		expect(isMCPToolName("")).toBe(false);
-	});
-});
-
-// ─── getDiscoverableTool ──────────────────────────────────────────────────────
-
-describe("getDiscoverableTool", () => {
-	it("infers source=mcp from mcp__ prefix", () => {
-		const tool = mcpAgentTool("mcp__gh_search", "github", "search", "Search repositories", ["query"]);
-		const result = getDiscoverableTool(tool);
-		expect(result).not.toBeNull();
-		expect(result!.source).toBe("mcp");
-		expect(result!.serverName).toBe("github");
-		expect(result!.mcpToolName).toBe("search");
-	});
-
-	it("infers source=builtin for non-mcp names", () => {
-		const tool = makeAgentTool("read", { description: "Read a file" });
-		const result = getDiscoverableTool(tool);
-		expect(result).not.toBeNull();
-		expect(result!.source).toBe("builtin");
-		expect(result!.serverName).toBeUndefined();
-	});
-
-	it("respects source override", () => {
-		const tool = makeAgentTool("my_ext_tool", { description: "Custom extension tool" });
-		const result = getDiscoverableTool(tool, { source: "extension" });
-		expect(result!.source).toBe("extension");
-	});
-
-	it("falls back to description (first 200 chars) as summary when no summary override", () => {
-		const longDesc = "A".repeat(300);
-		const tool = makeAgentTool("foo", { description: longDesc });
-		const result = getDiscoverableTool(tool);
-		expect(result!.summary).toBe("A".repeat(200));
-	});
-
-	it("uses summary override when provided", () => {
-		const tool = makeAgentTool("foo", { description: "Long description..." });
-		const result = getDiscoverableTool(tool, { summary: "Short summary" });
-		expect(result!.summary).toBe("Short summary");
-	});
-
-	it("extracts schema keys from parameters.properties", () => {
-		const tool = makeAgentTool("foo", {
-			parameters: { type: "object", properties: { alpha: {}, beta: {}, gamma: {} } },
-		});
-		const result = getDiscoverableTool(tool);
-		// sorted alphabetically
-		expect(result!.schemaKeys).toEqual(["alpha", "beta", "gamma"]);
-	});
-
-	it("extracts schema keys from Zod-schema parameters via wire conversion", () => {
-		const tool = makeAgentTool("foo", {
-			parameters: type({ gamma: "string", alpha: "number?", beta: "boolean" }),
-		});
-		const result = getDiscoverableTool(tool);
-		expect(result!.schemaKeys).toEqual(["alpha", "beta", "gamma"]);
-	});
-});
-
-// ─── collectDiscoverableTools ─────────────────────────────────────────────────
-
-describe("collectDiscoverableTools", () => {
-	it("collects all tools from an iterable", () => {
-		const tools = [makeAgentTool("read"), makeAgentTool("bash"), makeAgentTool("edit")];
-		const result = collectDiscoverableTools(tools);
-		expect(result).toHaveLength(3);
-		expect(result.map(t => t.name)).toEqual(["read", "bash", "edit"]);
-	});
-
-	it("overrides source when specified", () => {
-		const tools = [makeAgentTool("custom_tool")];
-		const result = collectDiscoverableTools(tools, { source: "extension" });
-		expect(result[0]!.source).toBe("extension");
-	});
-
-	it("uses summaryMap when provided", () => {
-		const tools = [makeAgentTool("read", { description: "Reads a file from disk" })];
-		const summaryMap = new Map([["read", "Short one-liner"]]);
-		const result = collectDiscoverableTools(tools, { summaryMap });
-		expect(result[0]!.summary).toBe("Short one-liner");
-	});
-});
-
-// ─── filterBySource ───────────────────────────────────────────────────────────
-
-describe("filterBySource", () => {
-	const mixed: DiscoverableTool[] = [
-		{ name: "read", label: "read", summary: "x", source: "builtin", schemaKeys: [] },
-		{ name: "mcp__gh", label: "gh", summary: "x", source: "mcp", serverName: "gh", schemaKeys: [] },
-		{ name: "ext_foo", label: "ext_foo", summary: "x", source: "extension", schemaKeys: [] },
-	];
-
-	it("filters by builtin", () => {
-		expect(filterBySource(mixed, "builtin").map(t => t.name)).toEqual(["read"]);
-	});
-	it("filters by mcp", () => {
-		expect(filterBySource(mixed, "mcp").map(t => t.name)).toEqual(["mcp__gh"]);
-	});
-	it("filters by extension", () => {
-		expect(filterBySource(mixed, "extension").map(t => t.name)).toEqual(["ext_foo"]);
-	});
-});
-
-// ─── summarizeDiscoverableTools ───────────────────────────────────────────────
-
-describe("summarizeDiscoverableTools", () => {
-	it("groups tools by server and counts them", () => {
-		const tools: DiscoverableTool[] = [
-			{ name: "mcp__gh_1", label: "gh/1", summary: "x", source: "mcp", serverName: "github", schemaKeys: [] },
-			{ name: "mcp__gh_2", label: "gh/2", summary: "x", source: "mcp", serverName: "github", schemaKeys: [] },
-			{ name: "mcp__sl_1", label: "sl/1", summary: "x", source: "mcp", serverName: "slack", schemaKeys: [] },
-			{ name: "builtin_read", label: "read", summary: "x", source: "builtin", schemaKeys: [] },
-		];
-		const summary = summarizeDiscoverableTools(tools);
-		expect(summary.toolCount).toBe(4);
-		expect(summary.servers).toHaveLength(2);
-		// Alphabetical order
-		expect(summary.servers[0]).toEqual({ name: "github", toolCount: 2 });
-		expect(summary.servers[1]).toEqual({ name: "slack", toolCount: 1 });
-	});
-
-	it("returns empty servers for tools without serverName", () => {
-		const tools: DiscoverableTool[] = [
-			{ name: "read", label: "read", summary: "x", source: "builtin", schemaKeys: [] },
-		];
-		const summary = summarizeDiscoverableTools(tools);
-		expect(summary.toolCount).toBe(1);
-		expect(summary.servers).toHaveLength(0);
-	});
-});
-
-// ─── formatDiscoverableToolServerSummary ─────────────────────────────────────
-
-describe("formatDiscoverableToolServerSummary", () => {
-	it("formats singular", () => {
-		expect(formatDiscoverableToolServerSummary({ name: "github", toolCount: 1 })).toBe("github (1 tool)");
-	});
-	it("formats plural", () => {
-		expect(formatDiscoverableToolServerSummary({ name: "slack", toolCount: 3 })).toBe("slack (3 tools)");
-	});
-});
-
-// ─── selectDiscoverableToolNamesByServer ──────────────────────────────────────
-
-describe("selectDiscoverableToolNamesByServer", () => {
-	const tools: DiscoverableTool[] = [
-		{ name: "mcp__gh_1", label: "gh/1", summary: "x", source: "mcp", serverName: "github", schemaKeys: [] },
-		{ name: "mcp__sl_1", label: "sl/1", summary: "x", source: "mcp", serverName: "slack", schemaKeys: [] },
-		{ name: "read", label: "read", summary: "x", source: "builtin", schemaKeys: [] },
-	];
-
-	it("returns names for tools in the specified servers", () => {
-		const result = selectDiscoverableToolNamesByServer(tools, new Set(["github"]));
-		expect(result).toEqual(["mcp__gh_1"]);
-	});
-
-	it("returns empty array when serverNames is empty", () => {
-		expect(selectDiscoverableToolNamesByServer(tools, new Set())).toEqual([]);
-	});
-});
-
-// ─── buildDiscoverableToolSearchIndex + searchDiscoverableTools ───────────────
-
-describe("BM25 search", () => {
-	const tools: DiscoverableTool[] = [
-		{
-			name: "mcp__github_create_issue",
-			label: "github/create_issue",
-			summary: "Create a GitHub issue in the selected repository",
-			source: "mcp",
-			serverName: "github",
-			mcpToolName: "create_issue",
-			schemaKeys: ["owner", "repo", "title", "body"],
-		},
-		{
-			name: "mcp__github_list_prs",
-			label: "github/list_pull_requests",
-			summary: "List pull requests for a GitHub repository",
-			source: "mcp",
-			serverName: "github",
-			mcpToolName: "list_pull_requests",
-			schemaKeys: ["owner", "repo", "state"],
-		},
-		{
-			name: "mcp__slack_post",
-			label: "slack/post_message",
-			summary: "Post a message to a Slack channel",
-			source: "mcp",
-			serverName: "slack",
-			mcpToolName: "post_message",
-			schemaKeys: ["channel", "text"],
-		},
-		{
-			name: "glob",
-			label: "glob",
-			summary: "Find files and directories matching a glob pattern",
-			source: "builtin",
-			schemaKeys: ["pattern", "path"],
-		},
-	];
-
-	const index = buildDiscoverableToolSearchIndex(tools);
-
-	it("builds an index with the correct document count", () => {
-		expect(index.documents).toHaveLength(4);
-	});
-
-	it("returns ranked matches for a query", () => {
-		const results = searchDiscoverableTools(index, "github issue", 5);
-		expect(results.length).toBeGreaterThan(0);
-		expect(results[0]!.tool.name).toBe("mcp__github_create_issue");
-		expect(results[0]!.score).toBeGreaterThan(0);
-	});
-
-	it("finds built-in tools too", () => {
-		const results = searchDiscoverableTools(index, "find files", 5);
-		expect(results.some(r => r.tool.name === "glob")).toBe(true);
-	});
-
-	it("respects the limit", () => {
-		const results = searchDiscoverableTools(index, "github", 1);
-		expect(results).toHaveLength(1);
-	});
-
-	it("returns empty array for query matching nothing", () => {
-		const results = searchDiscoverableTools(index, "xyzzy_nonexistent_term_12345", 5);
-		expect(results).toHaveLength(0);
-	});
-
-	it("throws for empty query", () => {
-		expect(() => searchDiscoverableTools(index, "   ", 5)).toThrow(
-			"Query must contain at least one letter or number.",
-		);
-	});
-
-	it("returns empty array when index has no documents", () => {
-		const emptyIndex = buildDiscoverableToolSearchIndex([]);
-		const results = searchDiscoverableTools(emptyIndex, "github", 5);
-		expect(results).toHaveLength(0);
-	});
-});
diff --git a/packages/coding-agent/test/tools.test.ts b/packages/coding-agent/test/tools.test.ts
index bef4448cd..c694cceac 100644
--- a/packages/coding-agent/test/tools.test.ts
+++ b/packages/coding-agent/test/tools.test.ts
@@ -11,7 +11,6 @@ import { EditTool } from "@oh-my-pi/pi-coding-agent/edit";
 import { SessionManager } from "@oh-my-pi/pi-coding-agent/session/session-manager";
 import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
 import { BashTool } from "@oh-my-pi/pi-coding-agent/tools/bash";
-import { JobTool } from "@oh-my-pi/pi-coding-agent/tools/job";
 import { wrapToolWithMetaNotice } from "@oh-my-pi/pi-coding-agent/tools/output-meta";
 import { ReadTool } from "@oh-my-pi/pi-coding-agent/tools/read";
 import * as toolTimeouts from "@oh-my-pi/pi-coding-agent/tools/tool-timeouts";
@@ -20,6 +19,7 @@ import { unzip } from "@oh-my-pi/pi-coding-agent/utils/zip";
 import { $which, removeSyncWithRetries, Snowflake } from "@oh-my-pi/pi-utils";
 import { GlobTool } from "../src/tools/glob";
 import { DEFAULT_FILE_LIMIT, GrepTool, MULTI_FILE_PER_FILE_MATCHES } from "../src/tools/grep";
+import { HubTool } from "../src/tools/hub";
 
 // Helper to extract text from content blocks
 function getTextOutput(result: any): string {
@@ -1576,7 +1576,7 @@ function b() {
 		});
 	});
 
-	describe("JobTool", () => {
+	describe("HubTool", () => {
 		it("should wait for jobs and acknowledge deliveries to prevent race conditions", async () => {
 			const manager = new AsyncJobManager({
 				onJobComplete: async () => {},
@@ -1584,12 +1584,12 @@ function b() {
 			const session = createTestToolSession(testDir, Settings.isolated({ "bash.autoBackground.enabled": true }), {
 				asyncJobManager: manager,
 			});
-			const jobTool = new JobTool(session);
+			const jobTool = new HubTool(session);
 
 			const jobId = manager.register("bash", "test job", async () => "success");
 
 			// Job is running, call poll
-			const resultPromise = jobTool.execute("test-call-poll-1", { poll: [jobId] });
+			const resultPromise = jobTool.execute("test-call-poll-1", { op: "wait", ids: [jobId] });
 
 			// Ensure poll finished
 			const result = await resultPromise;
@@ -1609,35 +1609,35 @@ function b() {
 			const session = createTestToolSession(testDir, Settings.isolated({ "bash.autoBackground.enabled": true }), {
 				asyncJobManager: manager,
 			});
-			const jobTool = new JobTool(session);
+			const jobTool = new HubTool(session);
 			const gate = Promise.withResolvers<string>();
 			const jobId = manager.register("bash", "long job", () => gate.promise);
 
 			// Poll cut short while the job is still running: a pure "still
 			// waiting" snapshot carries no information once consumed.
 			const controller = new AbortController();
-			const pollPromise = jobTool.execute("test-call-useless-poll", { poll: [jobId] }, controller.signal);
+			const pollPromise = jobTool.execute("test-call-useless-poll", { op: "wait", ids: [jobId] }, controller.signal);
 			controller.abort();
 			const polled = await pollPromise;
 			expect(polled.useless).toBe(true);
 
 			// A list snapshot showing only running jobs is equally uneventful.
-			const listed = await jobTool.execute("test-call-useless-list", { list: true });
+			const listed = await jobTool.execute("test-call-useless-list", { op: "jobs" });
 			expect(listed.useless).toBe(true);
 
 			// Once the job settles, the result is informative — flag absent.
 			gate.resolve("done");
-			const settled = await jobTool.execute("test-call-useless-settled", { poll: [jobId] });
+			const settled = await jobTool.execute("test-call-useless-settled", { op: "wait", ids: [jobId] });
 			expect(getTextOutput(settled)).toContain("Completed");
 			expect(settled.useless).toBeUndefined();
 
 			// Nothing left to wait for: noise once consumed.
-			const idle = await jobTool.execute("test-call-useless-idle", {});
+			const idle = await jobTool.execute("test-call-useless-idle", { op: "wait" });
 			expect(getTextOutput(idle)).toContain("No running background jobs");
 			expect(idle.useless).toBe(true);
 
 			// A poll naming unknown ids found nothing — equally uneventful.
-			const missing = await jobTool.execute("test-call-useless-missing", { poll: ["no-such-job"] });
+			const missing = await jobTool.execute("test-call-useless-missing", { op: "wait", ids: ["no-such-job"] });
 			expect(getTextOutput(missing)).toContain("No matching jobs found");
 			expect(missing.useless).toBe(true);
 		});
diff --git a/packages/coding-agent/test/tools/ast-edit.test.ts b/packages/coding-agent/test/tools/ast-edit.test.ts
index 1a5b8f9d5..5d3e7105d 100644
--- a/packages/coding-agent/test/tools/ast-edit.test.ts
+++ b/packages/coding-agent/test/tools/ast-edit.test.ts
@@ -20,7 +20,9 @@ function createTestSession(cwd = "/tmp/test", overrides: Partial<ToolSession> =
 		hasUI: true,
 		getSessionFile: () => null,
 		getSessionSpawns: () => "*",
-		settings: Settings.isolated(),
+		// xdev mounting (default-on) would unmount the discoverable ast_edit
+		// into xd://; these tests need it in the returned toolset.
+		settings: Settings.isolated({ "tools.xdev": false }),
 		...overrides,
 	};
 }
diff --git a/packages/coding-agent/test/tools/ast-grep.test.ts b/packages/coding-agent/test/tools/ast-grep.test.ts
index 29131d2ce..275626e77 100644
--- a/packages/coding-agent/test/tools/ast-grep.test.ts
+++ b/packages/coding-agent/test/tools/ast-grep.test.ts
@@ -12,7 +12,7 @@ function createTestSession(cwd = "/tmp/test", overrides: Partial<ToolSession> =
 		hasUI: true,
 		getSessionFile: () => null,
 		getSessionSpawns: () => "*",
-		settings: Settings.isolated(),
+		settings: Settings.isolated({ "astGrep.enabled": true, "tools.xdev": false }),
 		...overrides,
 	};
 }
@@ -121,58 +121,61 @@ describe("ast_grep parse errors", () => {
 			const lateDir = path.join(tempDir, "z");
 			await fs.mkdir(earlyDir, { recursive: true });
 			await fs.mkdir(lateDir, { recursive: true });
-			await Bun.write(path.join(earlyDir, "early.ts"), 'marker("early");\n');
-			for (let index = 0; index < 60; index++) {
-				await Bun.write(path.join(lateDir, `late-${index.toString().padStart(2, "0")}.ts`), 'marker("late");\n');
-			}
-
-			const tools = await createTools(createTestSession(tempDir));
-			const tool = tools.find(entry => entry.name === "ast_grep");
-			expect(tool).toBeDefined();
-
-			const result = await tool!.execute("ast-grep-multi-page", {
-				pat: "marker($A)",
-				path: `${lateDir}; ${earlyDir}`,
-			});
-
-			const text = result.content.find(content => content.type === "text")?.text ?? "";
-			const details = result.details as
-				| { matchCount?: number; fileCount?: number; limitReached?: boolean }
-				| undefined;
-
-			expect(text).toMatch(/^## early\.ts#[0-9A-F]{4}/m);
-			expect(details?.matchCount).toBe(61);
-			expect(details?.fileCount).toBe(61);
-			expect(details?.limitReached).toBe(true);
-		} finally {
-			await removeWithRetries(tempDir);
-		}
-	});
-
-	it("parses PlusCal content through the tlaplus language aliases", async () => {
-		const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "ast-grep-tlaplus-"));
-		try {
-			const filePath = path.join(tempDir, "Spec.tla");
 			await Bun.write(
-				filePath,
-				`---- MODULE Spec ----\n(* --algorithm Demo\nvariables x = 0;\nbegin\n  Inc:\n    x := x + 1;\nend algorithm; *)\n====\n`,
+				path.join(earlyDir, "a.ts"),
+				Array.from({ length: 8 }, () => "const sharedSymbol = 1;").join("\n"),
+			);
+			await Bun.write(
+				path.join(lateDir, "z.ts"),
+				Array.from({ length: 8 }, () => "const sharedSymbol = 1;").join("\n"),
 			);
 
 			const tools = await createTools(createTestSession(tempDir));
 			const tool = tools.find(entry => entry.name === "ast_grep");
 			expect(tool).toBeDefined();
 
-			const result = await tool!.execute("ast-grep-tlaplus", {
-				pat: "Inc",
-				path: filePath,
+			const result = await tool!.execute("ast-grep-multi-page", {
+				pat: "sharedSymbol",
+				path: `${earlyDir};${lateDir}`,
+				page: 2,
+				pageSize: 10,
 			});
-
 			const text = result.content.find(content => content.type === "text")?.text ?? "";
-			const details = result.details as { matchCount?: number; parseErrors?: string[] } | undefined;
+			const details = result.details as
+				| { matchCount?: number; hasMore?: boolean; page?: number; pageSize?: number }
+				| undefined;
 
-			expect(text).toContain("Inc");
-			expect(details?.matchCount).toBe(1);
-			expect(details?.parseErrors).toBeUndefined();
+			expect(details?.matchCount).toBe(16);
+			expect(details?.hasMore).toBe(false);
+			expect(details?.page).toBe(2);
+			expect(details?.pageSize).toBe(10);
+			expect(text).toContain("Page 2 of 2");
+			expect(text).toContain("a.ts");
+			expect(text).toContain("z.ts");
+		} finally {
+			await removeWithRetries(tempDir);
+		}
+	});
+
+	it("parses PlusCal content through the tlaplus language aliases", async () => {
+		const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "ast-grep-pluscal-"));
+		try {
+			const filePath = path.join(tempDir, "algo.tla");
+			await Bun.write(
+				filePath,
+				"---- MODULE Algo ----\n(*--algorithm Demo\nvariables x = 0;\nbegin\n  x := x + 1;\nend algorithm;*)\n====\n",
+			);
+			const tools = await createTools(createTestSession(tempDir));
+			const tool = tools.find(entry => entry.name === "ast_grep");
+			expect(tool).toBeDefined();
+
+			const result = await tool!.execute("ast-grep-pluscal", {
+				pat: "x",
+				path: filePath,
+				lang: "pluscal",
+			});
+			const details = result.details as { matchCount?: number } | undefined;
+			expect(details?.matchCount).toBeGreaterThan(0);
 		} finally {
 			await removeWithRetries(tempDir);
 		}
diff --git a/packages/coding-agent/test/tools/bash-interceptor.test.ts b/packages/coding-agent/test/tools/bash-interceptor.test.ts
index 649b4184e..07ab41939 100644
--- a/packages/coding-agent/test/tools/bash-interceptor.test.ts
+++ b/packages/coding-agent/test/tools/bash-interceptor.test.ts
@@ -111,8 +111,8 @@ describe("default echo/printf redirect rule", () => {
 	});
 });
 
-describe("default launch rules", () => {
-	const tools = ["launch"];
+describe("default hub start rules", () => {
+	const tools = ["hub"];
 
 	it.each([
 		"bun run dev",
@@ -121,10 +121,10 @@ describe("default launch rules", () => {
 		"bun test --watch",
 		"nohup server",
 		"server &",
-	])("routes %s to launch", command => {
+	])("routes %s to hub start", command => {
 		const result = checkBashInterception(command, tools, DEFAULT_BASH_INTERCEPTOR_RULES);
 		expect(result.block).toBe(true);
-		expect(result.suggestedTool).toBe("launch");
+		expect(result.suggestedTool).toBe("hub");
 	});
 
 	it.each([
diff --git a/packages/coding-agent/test/tools/grep-path-lists.test.ts b/packages/coding-agent/test/tools/grep-path-lists.test.ts
index 4a351bf47..17ab6597f 100644
--- a/packages/coding-agent/test/tools/grep-path-lists.test.ts
+++ b/packages/coding-agent/test/tools/grep-path-lists.test.ts
@@ -29,7 +29,7 @@ function createTestSession(cwd: string, overrides: Partial<ToolSession> = {}): T
 		hasUI: false,
 		getSessionFile: () => null,
 		getSessionSpawns: () => "*",
-		settings: Settings.isolated(),
+		settings: Settings.isolated({ "astGrep.enabled": true, "astEdit.enabled": true, "tools.xdev": false }),
 		...overrides,
 	};
 }
diff --git a/packages/coding-agent/test/tools/hub-wait.test.ts b/packages/coding-agent/test/tools/hub-wait.test.ts
new file mode 100644
index 000000000..3bba9101c
--- /dev/null
+++ b/packages/coding-agent/test/tools/hub-wait.test.ts
@@ -0,0 +1,112 @@
+/**
+ * Unified `hub` wait: one blocking primitive racing background jobs against
+ * incoming peer messages. These contracts are new to the merge — the halves
+ * (pure message wait, pure job poll) are covered by the pre-existing
+ * messaging/job suites.
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { AsyncJobManager } from "@oh-my-pi/pi-coding-agent/async/job-manager";
+import { IrcBus } from "@oh-my-pi/pi-coding-agent/irc/bus";
+import { AgentRegistry } from "@oh-my-pi/pi-coding-agent/registry/agent-registry";
+import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
+import { type CoordinationDetails, HubTool } from "@oh-my-pi/pi-coding-agent/tools/hub";
+
+const SELF_ID = "Main";
+
+function makeSession(manager: AsyncJobManager | undefined): ToolSession {
+	const stub = {
+		cwd: process.cwd(),
+		settings: {
+			get(key: string): unknown {
+				if (key === "async.pollWaitDuration") return "5m";
+				if (key === "irc.timeoutMs") return 120_000;
+				return undefined;
+			},
+		},
+		agentRegistry: AgentRegistry.global(),
+		asyncJobManager: manager,
+		getAgentId: () => SELF_ID,
+	};
+	// Structurally-partial test session: HubTool only touches the fields above.
+	return stub as unknown as ToolSession;
+}
+
+/** Register a job that never settles on its own; returns its id + resolver. */
+function registerHangingJob(manager: AsyncJobManager, label: string): { id: string; finish: (text: string) => void } {
+	const { promise, resolve } = Promise.withResolvers<string>();
+	const id = manager.register("bash", label, async () => promise, { ownerId: SELF_ID });
+	return { id, finish: resolve };
+}
+
+describe("hub unified wait", () => {
+	beforeEach(() => {
+		AgentRegistry.resetGlobalForTests();
+		IrcBus.resetGlobalForTests();
+	});
+	afterEach(() => {
+		AgentRegistry.resetGlobalForTests();
+		IrcBus.resetGlobalForTests();
+	});
+
+	test("an incoming message settles the wait while watched jobs keep running", async () => {
+		const registry = AgentRegistry.global();
+		registry.register({ id: SELF_ID, displayName: "main", kind: "main", session: null });
+		registry.register({ id: "Peer", displayName: "task", kind: "sub", parentId: SELF_ID, session: null });
+
+		const manager = new AsyncJobManager({ onJobComplete: () => {} });
+		const job = registerHangingJob(manager, "sleep forever");
+		const tool = new HubTool(makeSession(manager));
+
+		// The bus waiter is parked synchronously before execute()'s first
+		// suspension, so the send below cannot race the park.
+		const pending = tool.execute("call_1", { op: "wait" });
+		await IrcBus.global().send({ from: "Peer", to: SELF_ID, body: "shared file is yours" });
+
+		const result = await pending;
+		const details = result.details as CoordinationDetails;
+		expect(result.isError).not.toBe(true);
+		expect(details.op).toBe("wait");
+		expect(details.waited?.from).toBe("Peer");
+		expect(details.waited?.body).toBe("shared file is yours");
+		// The job was not consumed by the message win.
+		expect(manager.getJob(job.id)?.status).toBe("running");
+
+		manager.cancel(job.id);
+	});
+
+	test("a settling job returns the snapshot exactly like the old poll", async () => {
+		const registry = AgentRegistry.global();
+		registry.register({ id: SELF_ID, displayName: "main", kind: "main", session: null });
+		registry.register({ id: "Peer", displayName: "task", kind: "sub", parentId: SELF_ID, session: null });
+
+		const manager = new AsyncJobManager({ onJobComplete: () => {} });
+		const job = registerHangingJob(manager, "quick job");
+		const tool = new HubTool(makeSession(manager));
+
+		const pending = tool.execute("call_2", { op: "wait", ids: [job.id] });
+		job.finish("done output");
+
+		const result = await pending;
+		const details = result.details as CoordinationDetails;
+		expect(details.op).toBe("wait");
+		expect(details.jobs?.map(j => j.status)).toEqual(["completed"]);
+		expect(details.jobs?.[0]?.resultText).toBe("done output");
+		const text = result.content[0]?.type === "text" ? result.content[0].text : "";
+		expect(text).toContain("## Completed (1)");
+	});
+
+	test("bare wait with no jobs and no running peers returns immediately", async () => {
+		const registry = AgentRegistry.global();
+		registry.register({ id: SELF_ID, displayName: "main", kind: "main", session: null });
+		registry.register({ id: "Sleeper", displayName: "task", kind: "sub", session: null, status: "idle" });
+
+		const manager = new AsyncJobManager({ onJobComplete: () => {} });
+		const tool = new HubTool(makeSession(manager));
+
+		// A regression to a blocking message wait fails via the test timeout.
+		const result = await tool.execute("call_3", { op: "wait" });
+		const text = result.content[0]?.type === "text" ? result.content[0].text : "";
+		expect(text).toContain("No running background jobs to wait for.");
+		expect(result.useless).toBe(true);
+	});
+});
diff --git a/packages/coding-agent/test/tools/index.test.ts b/packages/coding-agent/test/tools/index.test.ts
index 4d895b60b..889d2e69c 100644
--- a/packages/coding-agent/test/tools/index.test.ts
+++ b/packages/coding-agent/test/tools/index.test.ts
@@ -40,32 +40,15 @@ function createActiveGoalState() {
 	};
 }
 
-function createDiscoverySessionHooks(): Partial<ToolSession> {
-	const selected: string[] = [];
-	return {
-		isMCPDiscoveryEnabled: () => true,
-		getDiscoverableTools: () => [],
-		getSelectedMCPToolNames: () => [...selected],
-		activateDiscoveredMCPTools: async toolNames => {
-			const activated: string[] = [];
-			for (const name of toolNames) {
-				if (!selected.includes(name)) {
-					selected.push(name);
-					activated.push(name);
-				}
-			}
-			return activated;
-		},
-	};
-}
-
 describe("createTools", () => {
 	afterEach(() => {
 		vi.restoreAllMocks();
 	});
 
 	it("creates all builtin tools by default", async () => {
-		const session = createTestSession();
+		// xdev mounting (default-on) would unmount discoverables like lsp and
+		// web_search into xd://; disable it to assert the full builtin set.
+		const session = createTestSession({ settings: createSettingsWithOverrides({ "tools.xdev": false }) });
 		const tools = await createTools(session);
 		const names = tools.map(t => t.name);
 
@@ -81,7 +64,6 @@ describe("createTools", () => {
 		expect(names).toContain("task");
 		expect(names).toContain("todo");
 		expect(names).toContain("web_search");
-		expect(names).toContain("resolve");
 		expect(names).not.toContain("fetch");
 		expect(names).not.toContain("vim");
 	});
@@ -95,7 +77,6 @@ describe("createTools", () => {
 
 		expect(names.filter(name => name === "grep")).toHaveLength(1);
 		expect(names).toContain("glob");
-		expect(names).toContain("resolve");
 		expect(names).not.toContain("search");
 		expect(names).not.toContain("find");
 	});
@@ -141,7 +122,6 @@ describe("createTools", () => {
 		const names = tools.map(t => t.name);
 
 		expect(names).toContain("eval");
-		expect(names).toContain("resolve");
 	});
 
 	it("excludes lsp tool when session disables LSP", async () => {
@@ -149,7 +129,7 @@ describe("createTools", () => {
 		const tools = await createTools(session, ["read", "lsp", "write"]);
 		const names = tools.map(t => t.name);
 
-		expect(names).toEqual(["read", "write", "resolve"]);
+		expect(names).toEqual(["read", "write"]);
 	});
 
 	it("excludes lsp tool when disabled", async () => {
@@ -165,7 +145,7 @@ describe("createTools", () => {
 		const tools = await createTools(session, ["read", "write"]);
 		const names = tools.map(t => t.name);
 
-		expect(names).toEqual(["read", "write", "resolve"]);
+		expect(names).toEqual(["read", "write"]);
 	});
 
 	it("lowercases requested tool subset", async () => {
@@ -173,15 +153,15 @@ describe("createTools", () => {
 		const tools = await createTools(session, ["Read", "Write"]);
 		const names = tools.map(t => t.name);
 
-		expect(names).toEqual(["read", "write", "resolve"]);
+		expect(names).toEqual(["read", "write"]);
 	});
 
 	it("includes hidden tools when explicitly requested", async () => {
 		const session = createTestSession();
-		const tools = await createTools(session, ["report_finding"]);
+		const tools = await createTools(session, ["yield"]);
 		const names = tools.map(t => t.name);
 
-		expect(names).toEqual(["report_finding", "resolve"]);
+		expect(names).toEqual(["yield"]);
 	});
 
 	it("includes yield tool when required", async () => {
@@ -227,7 +207,7 @@ describe("createTools", () => {
 		expect(tools.map(t => t.name)).not.toContain("ask");
 
 		const requested = await createTools(session, ["ask", "read"]);
-		expect(requested.map(t => t.name)).toEqual(["read", "resolve"]);
+		expect(requested.map(t => t.name)).toEqual(["read", "write"]);
 	});
 
 	it("includes ask tool when ask.enabled is true and hasUI is true", async () => {
@@ -267,23 +247,9 @@ describe("createTools", () => {
 		expect(names).not.toContain("inspect_image");
 
 		const requestedTools = await createTools(session, ["bash", "read"]);
-		expect(requestedTools.map(t => t.name)).toEqual(["read", "resolve"]);
+		expect(requestedTools.map(t => t.name)).toEqual(["read", "write"]);
 	});
 
-	it("always includes resolve regardless of plan-mode setting", async () => {
-		const session = createTestSession({
-			settings: createSettingsWithOverrides({
-				"plan.enabled": false,
-			}),
-		});
-
-		const defaultTools = await createTools(session);
-		expect(defaultTools.map(t => t.name)).toContain("resolve");
-		expect(defaultTools.map(t => t.name)).not.toContain("exit_plan_mode");
-
-		const requestedTools = await createTools(session, ["read"]);
-		expect(requestedTools.map(t => t.name)).toEqual(["read", "resolve"]);
-	});
 	it("auto-includes goal when goal mode is active", async () => {
 		const session = createTestSession({
 			settings: createSettingsWithOverrides({
@@ -294,7 +260,7 @@ describe("createTools", () => {
 		const tools = await createTools(session, ["read"]);
 		const names = tools.map(t => t.name);
 
-		expect(names).toEqual(["read", "goal", "resolve"]);
+		expect(names).toEqual(["read", "goal"]);
 	});
 
 	it("records active tools on the original session object", async () => {
@@ -306,48 +272,7 @@ describe("createTools", () => {
 		expect(session.isToolActive?.("read")).toBe(false);
 	});
 
-	it("renders bash guidance from the live active tool predicate", async () => {
-		const activeToolNames = new Set<string>();
-		const session = createTestSession({
-			isToolActive: name => activeToolNames.has(name),
-			setActiveToolNames: names => {
-				activeToolNames.clear();
-				for (const name of names) {
-					activeToolNames.add(name);
-				}
-			},
-		});
-
-		const tools = await createTools(session, ["bash", "grep", "read", "glob"]);
-		const bash = tools.find(tool => tool.name === "bash");
-
-		expect(bash?.description).toContain("`grep` tool");
-		session.setActiveToolNames?.(["bash"]);
-		expect(bash?.description).not.toContain("`grep` tool");
-		expect(bash?.description).not.toContain("`ls` → `read`");
-		expect(bash?.description).not.toContain("`find` → the `glob` tool");
-	});
-
-	it("includes search_tool_bm25 when MCP tool discovery is enabled and executable", async () => {
-		const session = createTestSession({
-			settings: createSettingsWithOverrides({
-				"mcp.discoveryMode": true,
-			}),
-			...createDiscoverySessionHooks(),
-		});
-		const tools = await createTools(session);
-		const names = tools.map(t => t.name);
-
-		expect(names).toContain("search_tool_bm25");
-	});
-
-	it("HIDDEN_TOOLS contains review tools and goal", () => {
-		expect(Object.keys(HIDDEN_TOOLS).sort()).toEqual([
-			"goal",
-			"report_finding",
-			"report_tool_issue",
-			"resolve",
-			"yield",
-		]);
+	it("HIDDEN_TOOLS contains yield and goal", () => {
+		expect(Object.keys(HIDDEN_TOOLS).sort()).toEqual(["goal", "yield"]);
 	});
 });
diff --git a/packages/coding-agent/test/tools/irc-renderer.test.ts b/packages/coding-agent/test/tools/irc-renderer.test.ts
index e22740612..acc1a6ba2 100644
--- a/packages/coding-agent/test/tools/irc-renderer.test.ts
+++ b/packages/coding-agent/test/tools/irc-renderer.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect, it } from "bun:test";
 import type { IrcMessage } from "@oh-my-pi/pi-coding-agent/irc/bus";
 import { getThemeByName } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
-import { type IrcDetails, ircToolRenderer } from "@oh-my-pi/pi-coding-agent/tools/irc";
+import { type CoordinationDetails, hubToolRenderer } from "@oh-my-pi/pi-coding-agent/tools/hub";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
 
 async function theme() {
@@ -22,11 +22,11 @@ const msg = (overrides: Partial<IrcMessage>): IrcMessage => ({
 	...overrides,
 });
 
-describe("ircToolRenderer send", () => {
+describe("hubToolRenderer send", () => {
 	it("folds a single delivery outcome into the header and shows the awaited reply", async () => {
 		const uiTheme = await theme();
 		const rendered = lines(
-			ircToolRenderer.renderResult(
+			hubToolRenderer.renderResult(
 				{
 					content: [{ type: "text", text: "" }],
 					details: {
@@ -35,7 +35,7 @@ describe("ircToolRenderer send", () => {
 						to: "AuthLoader",
 						receipts: [{ to: "AuthLoader", outcome: "revived" }],
 						waited: msg({ body: "go ahead, auth.ts is yours." }),
-					} satisfies IrcDetails,
+					} satisfies CoordinationDetails,
 				},
 				{ expanded: false, isPartial: false },
 				uiTheme,
@@ -51,7 +51,7 @@ describe("ircToolRenderer send", () => {
 	it("lists per-recipient outcomes with error text when a broadcast partially fails", async () => {
 		const uiTheme = await theme();
 		const rendered = lines(
-			ircToolRenderer.renderResult(
+			hubToolRenderer.renderResult(
 				{
 					content: [{ type: "text", text: "" }],
 					details: {
@@ -62,7 +62,7 @@ describe("ircToolRenderer send", () => {
 							{ to: "AuthLoader", outcome: "woken" },
 							{ to: "RateLimiter", outcome: "failed", error: 'unknown agent "RateLimiter"' },
 						],
-					} satisfies IrcDetails,
+					} satisfies CoordinationDetails,
 				},
 				{ expanded: false, isPartial: false },
 				uiTheme,
@@ -81,7 +81,7 @@ describe("ircToolRenderer send", () => {
 	it("flags an awaited send whose reply timed out", async () => {
 		const uiTheme = await theme();
 		const rendered = lines(
-			ircToolRenderer.renderResult(
+			hubToolRenderer.renderResult(
 				{
 					content: [{ type: "text", text: "" }],
 					details: {
@@ -90,7 +90,7 @@ describe("ircToolRenderer send", () => {
 						to: "AuthLoader",
 						receipts: [{ to: "AuthLoader", outcome: "injected" }],
 						waited: null,
-					} satisfies IrcDetails,
+					} satisfies CoordinationDetails,
 				},
 				{ expanded: false, isPartial: false },
 				uiTheme,
@@ -104,10 +104,10 @@ describe("ircToolRenderer send", () => {
 	it("surfaces pre-delivery validation failures as an error detail", async () => {
 		const uiTheme = await theme();
 		const rendered = lines(
-			ircToolRenderer.renderResult(
+			hubToolRenderer.renderResult(
 				{
 					content: [{ type: "text", text: '`to` is required for op="send".' }],
-					details: { op: "send", from: "Main" } satisfies IrcDetails,
+					details: { op: "send", from: "Main" } satisfies CoordinationDetails,
 					isError: true,
 				},
 				{ expanded: false, isPartial: false },
@@ -119,14 +119,14 @@ describe("ircToolRenderer send", () => {
 	});
 });
 
-describe("ircToolRenderer wait", () => {
+describe("hubToolRenderer wait", () => {
 	it("renders the consumed message under a sender header", async () => {
 		const uiTheme = await theme();
 		const rendered = lines(
-			ircToolRenderer.renderResult(
+			hubToolRenderer.renderResult(
 				{
 					content: [{ type: "text", text: "" }],
-					details: { op: "wait", from: "Main", waited: msg({}) } satisfies IrcDetails,
+					details: { op: "wait", from: "Main", waited: msg({}) } satisfies CoordinationDetails,
 				},
 				{ expanded: false, isPartial: false },
 				uiTheme,
@@ -140,10 +140,10 @@ describe("ircToolRenderer wait", () => {
 	it("marks a timed-out wait without inventing a message", async () => {
 		const uiTheme = await theme();
 		const rendered = lines(
-			ircToolRenderer.renderResult(
+			hubToolRenderer.renderResult(
 				{
 					content: [{ type: "text", text: "No message from AuthLoader within 2m." }],
-					details: { op: "wait", from: "Main", waited: null } satisfies IrcDetails,
+					details: { op: "wait", from: "Main", waited: null } satisfies CoordinationDetails,
 				},
 				{ expanded: false, isPartial: false },
 				uiTheme,
@@ -155,11 +155,11 @@ describe("ircToolRenderer wait", () => {
 	});
 });
 
-describe("ircToolRenderer inbox", () => {
+describe("hubToolRenderer inbox", () => {
 	it("lists each message with sender and body preview", async () => {
 		const uiTheme = await theme();
 		const rendered = lines(
-			ircToolRenderer.renderResult(
+			hubToolRenderer.renderResult(
 				{
 					content: [{ type: "text", text: "" }],
 					details: {
@@ -169,7 +169,7 @@ describe("ircToolRenderer inbox", () => {
 							msg({ from: "AuthLoader", body: "bus landed." }),
 							msg({ from: "RateLimiter", body: "receipts carry outcome.", replyTo: "7181122334455667791" }),
 						],
-					} satisfies IrcDetails,
+					} satisfies CoordinationDetails,
 				},
 				{ expanded: false, isPartial: false },
 				uiTheme,
@@ -184,11 +184,11 @@ describe("ircToolRenderer inbox", () => {
 	});
 });
 
-describe("ircToolRenderer list", () => {
+describe("hubToolRenderer list", () => {
 	it("summarizes status counts and flags unread peers", async () => {
 		const uiTheme = await theme();
 		const rendered = lines(
-			ircToolRenderer.renderResult(
+			hubToolRenderer.renderResult(
 				{
 					content: [{ type: "text", text: "" }],
 					details: {
@@ -214,7 +214,7 @@ describe("ircToolRenderer list", () => {
 								lastActivity: Date.now() - 2 * 60_000,
 							},
 						],
-					} satisfies IrcDetails,
+					} satisfies CoordinationDetails,
 				},
 				{ expanded: false, isPartial: false },
 				uiTheme,
@@ -235,7 +235,7 @@ describe("ircToolRenderer list", () => {
 	it("renders a peer's role displayName and current activity in the row", async () => {
 		const uiTheme = await theme();
 		const rendered = lines(
-			ircToolRenderer.renderResult(
+			hubToolRenderer.renderResult(
 				{
 					content: [{ type: "text", text: "" }],
 					details: {
@@ -253,7 +253,7 @@ describe("ircToolRenderer list", () => {
 								activity: "auditing the token refresh path",
 							},
 						],
-					} satisfies IrcDetails,
+					} satisfies CoordinationDetails,
 				},
 				{ expanded: false, isPartial: false },
 				uiTheme,
@@ -267,22 +267,22 @@ describe("ircToolRenderer list", () => {
 	});
 });
 
-describe("ircToolRenderer body truncation", () => {
+describe("hubToolRenderer body truncation", () => {
 	it("collapses long bodies with an elision counter and expands on demand", async () => {
 		const uiTheme = await theme();
 		const body = Array.from({ length: 6 }, (_, i) => `reply line ${i + 1}`).join("\n");
-		const details: IrcDetails = { op: "wait", from: "Main", waited: msg({ body }) };
+		const details: CoordinationDetails = { op: "wait", from: "Main", waited: msg({ body }) };
 		const result = { content: [{ type: "text", text: "" }], details };
 
 		const collapsed = lines(
-			ircToolRenderer.renderResult(result, { expanded: false, isPartial: false }, uiTheme, { op: "wait" }),
+			hubToolRenderer.renderResult(result, { expanded: false, isPartial: false }, uiTheme, { op: "wait" }),
 		);
 		expect(collapsed.some(line => line.includes("reply line 2"))).toBe(true);
 		expect(collapsed.some(line => line.includes("reply line 3"))).toBe(false);
 		expect(collapsed.some(line => line.includes("+4 more lines"))).toBe(true);
 
 		const expanded = lines(
-			ircToolRenderer.renderResult(result, { expanded: true, isPartial: false }, uiTheme, { op: "wait" }),
+			hubToolRenderer.renderResult(result, { expanded: true, isPartial: false }, uiTheme, { op: "wait" }),
 		);
 		expect(expanded.some(line => line.includes("reply line 6"))).toBe(true);
 		expect(expanded.some(line => line.includes("more lines"))).toBe(false);
diff --git a/packages/coding-agent/test/tools/irc-roster-activity.test.ts b/packages/coding-agent/test/tools/irc-roster-activity.test.ts
index 40667039a..7495c0cfe 100644
--- a/packages/coding-agent/test/tools/irc-roster-activity.test.ts
+++ b/packages/coding-agent/test/tools/irc-roster-activity.test.ts
@@ -4,7 +4,7 @@ import { IrcBus } from "@oh-my-pi/pi-coding-agent/irc/bus";
 import { AgentLifecycleManager } from "@oh-my-pi/pi-coding-agent/registry/agent-lifecycle";
 import { AgentRegistry } from "@oh-my-pi/pi-coding-agent/registry/agent-registry";
 import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
-import { IrcTool } from "@oh-my-pi/pi-coding-agent/tools/irc";
+import { HubTool } from "@oh-my-pi/pi-coding-agent/tools/hub";
 
 // Contract: the work-aware roster (`irc list`) surfaces each peer's role
 // (via displayName) and current activity gist, and a peer with no activity
@@ -23,7 +23,7 @@ function makeToolSession(registry: AgentRegistry, agentId: string): ToolSession
 }
 
 async function listText(registry: AgentRegistry, selfId: string): Promise<string> {
-	const tool = new IrcTool(makeToolSession(registry, selfId));
+	const tool = new HubTool(makeToolSession(registry, selfId));
 	const result = await tool.execute("call", { op: "list" });
 	return result.content.find(part => part.type === "text")?.text ?? "";
 }
diff --git a/packages/coding-agent/test/tools/irc.test.ts b/packages/coding-agent/test/tools/irc.test.ts
index aa3bb01ec..73138e637 100644
--- a/packages/coding-agent/test/tools/irc.test.ts
+++ b/packages/coding-agent/test/tools/irc.test.ts
@@ -9,7 +9,7 @@ import { AgentSession, type AgentSessionEvent } from "@oh-my-pi/pi-coding-agent/
 import type { CustomMessage } from "@oh-my-pi/pi-coding-agent/session/messages";
 import { SessionManager } from "@oh-my-pi/pi-coding-agent/session/session-manager";
 import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
-import { IrcTool } from "@oh-my-pi/pi-coding-agent/tools/irc";
+import { type CoordinationDetails, HubTool, isIrcEnabled } from "@oh-my-pi/pi-coding-agent/tools/hub";
 
 interface FakeSession {
 	session: AgentSession;
@@ -372,40 +372,44 @@ describe("IRC", () => {
 		});
 	});
 
-	describe("IrcTool", () => {
-		it("createIf returns null for a top-level session that cannot spawn tasks", () => {
-			const session: ToolSession = {
-				cwd: "/tmp",
-				hasUI: false,
-				getSessionFile: () => null,
-				getSessionSpawns: () => "*",
-				settings: Settings.isolated(),
-				agentRegistry: registry,
-				getAgentId: () => "0-Main",
-			};
+	describe("HubTool", () => {
+		it("isIrcEnabled returns false for a top-level session that cannot spawn tasks", () => {
+			const settings = Settings.isolated();
 			// Depth 0 with spawning gated off: no peers exist or can be created.
-			session.settings.set("task.maxRecursionDepth", 0);
-			expect(IrcTool.createIf(session)).toBeNull();
+			settings.set("task.maxRecursionDepth", 0);
+			expect(isIrcEnabled(settings, 0)).toBe(false);
 		});
 
-		it("createIf enables interruptible irc while the task tool is available", () => {
-			const session: ToolSession = {
-				cwd: "/tmp",
-				hasUI: false,
-				getSessionFile: () => null,
-				getSessionSpawns: () => "*",
-				settings: Settings.isolated(),
-				agentRegistry: registry,
-				getAgentId: () => "0-Main",
-			};
+		it("isIrcEnabled returns true while the task tool is available", () => {
+			const settings = Settings.isolated();
 			// Default task.maxRecursionDepth (2) at depth 0: task can spawn, and a
 			// finished subagent must stay reachable.
-			const tool = IrcTool.createIf(session);
-			expect(tool).toBeInstanceOf(IrcTool);
-			expect(tool?.interruptible).toBe(true);
+			expect(isIrcEnabled(settings, 0)).toBe(true);
 		});
 
-		it("createIf enables irc for a subagent even at the recursion-depth cap", () => {
+		it("isIrcEnabled returns true for a subagent even at the recursion-depth cap", () => {
+			const settings = Settings.isolated();
+			// A leaf subagent cannot spawn, but its parent (and siblings) exist.
+			settings.set("task.maxRecursionDepth", 2);
+			expect(isIrcEnabled(settings, 2)).toBe(true);
+		});
+
+		it("returns an error result for messaging ops on a session without registry/agentId", async () => {
+			const session: ToolSession = {
+				cwd: "/tmp",
+				hasUI: false,
+				getSessionFile: () => null,
+				getSessionSpawns: () => "*",
+				settings: Settings.isolated(),
+			};
+			const tool = new HubTool(session);
+			const result = await tool.execute("call", { op: "list" });
+			expect(result.isError).toBe(true);
+			const text = result.content[0]?.type === "text" ? result.content[0].text : "";
+			expect(text).toContain("Peer messaging is unavailable");
+		});
+
+		it("the tool is marked interruptible", () => {
 			const session: ToolSession = {
 				cwd: "/tmp",
 				hasUI: false,
@@ -413,23 +417,10 @@ describe("IRC", () => {
 				getSessionSpawns: () => "*",
 				settings: Settings.isolated(),
 				agentRegistry: registry,
-				getAgentId: () => "0-Leaf",
-				taskDepth: 2,
+				getAgentId: () => "0-Main",
 			};
-			// A leaf subagent cannot spawn, but its parent (and siblings) exist.
-			session.settings.set("task.maxRecursionDepth", 2);
-			expect(IrcTool.createIf(session)).toBeInstanceOf(IrcTool);
-		});
-
-		it("createIf returns null without registry/agentId", () => {
-			const session: ToolSession = {
-				cwd: "/tmp",
-				hasUI: false,
-				getSessionFile: () => null,
-				getSessionSpawns: () => "*",
-				settings: Settings.isolated(),
-			};
-			expect(IrcTool.createIf(session)).toBeNull();
+			const tool = new HubTool(session);
+			expect(tool.interruptible).toBe(true);
 		});
 
 		it("op=list includes parked peers, unread counts, and parent ids", async () => {
@@ -447,10 +438,11 @@ describe("IRC", () => {
 			sub.setError(new Error("temporarily unavailable"));
 			await bus.send({ from: "0-Main", to: "0-AuthLoader", body: "unread one" });
 
-			const tool = new IrcTool(makeToolSession(registry, "0-Main"));
+			const tool = new HubTool(makeToolSession(registry, "0-Main"));
 			const result = await tool.execute("call-1", { op: "list" });
-			expect(result.details?.op).toBe("list");
-			expect(result.details?.peers).toMatchObject([
+			const details = result.details as CoordinationDetails | undefined;
+			expect(details?.op).toBe("list");
+			expect(details?.peers).toMatchObject([
 				{ id: "0-AuthLoader", status: "running", parentId: "0-Main", unread: 1 },
 				{ id: "0-Parked", status: "parked", unread: 0 },
 			]);
@@ -469,9 +461,10 @@ describe("IRC", () => {
 				status: "parked",
 			});
 
-			const tool = new IrcTool(makeToolSession(registry, "0-Main"));
+			const tool = new HubTool(makeToolSession(registry, "0-Main"));
 			const result = await tool.execute("call-1", { op: "list" });
-			const peerIds = result.details?.peers?.map(peer => peer.id) ?? [];
+			const details = result.details as CoordinationDetails | undefined;
+			const peerIds = details?.peers?.map(peer => peer.id) ?? [];
 			expect(peerIds).toContain("0-Worker");
 			expect(peerIds).not.toContain("0-Main/advisor");
 		});
@@ -480,11 +473,12 @@ describe("IRC", () => {
 			const sub = makeFakeSession();
 			registry.register({ id: "0-Sub", displayName: "task", kind: "sub", session: sub.session });
 
-			const tool = new IrcTool(makeToolSession(registry, "0-Main"));
+			const tool = new HubTool(makeToolSession(registry, "0-Main"));
 			const result = await tool.execute("call-1", { op: "send", to: "0-Sub", message: "ping" });
+			const details = result.details as CoordinationDetails | undefined;
 			expect(result.isError).toBeFalsy();
-			expect(result.details?.receipts).toEqual([{ to: "0-Sub", outcome: "injected" }]);
-			expect(result.details?.waited).toBeUndefined();
+			expect(details?.receipts).toEqual([{ to: "0-Sub", outcome: "injected" }]);
+			expect(details?.waited).toBeUndefined();
 			expect(sub.delivered.map(msg => msg.body)).toEqual(["ping"]);
 		});
 
@@ -496,10 +490,11 @@ describe("IRC", () => {
 			registry.register({ id: "0-B", displayName: "task", kind: "sub", session: b.session });
 			registry.register({ id: "0-Parked", displayName: "task", kind: "sub", session: null, status: "parked" });
 
-			const tool = new IrcTool(makeToolSession(registry, "0-Main"));
+			const tool = new HubTool(makeToolSession(registry, "0-Main"));
 			const result = await tool.execute("call-1", { op: "send", to: "all", message: "anyone there?" });
+			const details = result.details as CoordinationDetails | undefined;
 			// Broadcast skips parked agents; one failure does not block the other delivery.
-			expect(result.details?.receipts).toEqual([
+			expect(details?.receipts).toEqual([
 				{ to: "0-A", outcome: "injected" },
 				{ to: "0-B", outcome: "failed", error: "kaput" },
 			]);
@@ -513,7 +508,7 @@ describe("IRC", () => {
 			registry.register({ id: "0-B", displayName: "task", kind: "sub", session: b.session });
 			registry.register({ id: "0-A", displayName: "task", kind: "sub", session: makeFakeSession().session });
 
-			const tool = new IrcTool(makeToolSession(registry, "0-A"));
+			const tool = new HubTool(makeToolSession(registry, "0-A"));
 			await tool.execute("call-1", { op: "send", to: "all", message: "anyone there?" });
 
 			// Main receives the broadcast directly (its own incoming card) ...
@@ -539,9 +534,10 @@ describe("IRC", () => {
 				void bus.send({ from: "0-Sub", to: msg.from, body: "pong", replyTo: msg.id });
 			});
 
-			const tool = new IrcTool(makeToolSession(registry, "0-Main"));
+			const tool = new HubTool(makeToolSession(registry, "0-Main"));
 			const result = await tool.execute("call-1", { op: "send", to: "0-Sub", message: "ping", await: true });
-			expect(result.details?.waited?.body).toBe("pong");
+			const details = result.details as CoordinationDetails | undefined;
+			expect(details?.waited?.body).toBe("pong");
 			const text = result.content[0]?.type === "text" ? result.content[0].text : "";
 			expect(text).toContain("pong");
 		});
@@ -557,10 +553,10 @@ describe("IRC", () => {
 				void bus.send({ from: "0-Sub", to: msg.from, body: "fresh reply", replyTo: msg.id });
 			});
 
-			const tool = new IrcTool(makeToolSession(registry, "0-Main"));
+			const tool = new HubTool(makeToolSession(registry, "0-Main"));
 			const result = await tool.execute("call-1", { op: "send", to: "0-Sub", message: "ping", await: true });
-
-			expect(result.details?.waited?.body).toBe("fresh reply");
+			const details = result.details as CoordinationDetails | undefined;
+			expect(details?.waited?.body).toBe("fresh reply");
 			expect(bus.inbox("0-Main").map(msg => msg.body)).toEqual(["old buffered reply"]);
 		});
 
@@ -568,7 +564,7 @@ describe("IRC", () => {
 			const sub = makeFakeSession();
 			registry.register({ id: "0-Sub", displayName: "task", kind: "sub", session: sub.session });
 
-			const tool = new IrcTool(makeToolSession(registry, "0-Main"));
+			const tool = new HubTool(makeToolSession(registry, "0-Main"));
 			const result = await tool.execute("call-1", {
 				op: "send",
 				to: "0-Sub",
@@ -578,7 +574,8 @@ describe("IRC", () => {
 				timeoutMs: 5,
 			});
 			expect(result.isError).toBeFalsy();
-			expect(result.details?.waited).toBeNull();
+			const details = result.details as CoordinationDetails | undefined;
+			expect(details?.waited).toBeNull();
 			const text = result.content[0]?.type === "text" ? result.content[0].text : "";
 			expect(text).toContain("No reply from 0-Sub");
 		});
@@ -592,7 +589,7 @@ describe("IRC", () => {
 			const sub = makeFakeSession();
 			registry.register({ id: "0-Sub", displayName: "task", kind: "sub", session: sub.session });
 
-			const tool = new IrcTool(makeToolSession(registry, "0-Main"));
+			const tool = new HubTool(makeToolSession(registry, "0-Main"));
 			const controller = new AbortController();
 			// Abort once delivery reaches the peer, mimicking a steering / IRC interrupt
 			// landing between the send resolving and the reply arriving.
@@ -606,49 +603,54 @@ describe("IRC", () => {
 
 			expect(result.isError).toBeFalsy();
 			expect(sub.delivered.map(msg => msg.body)).toEqual(["ping"]);
-			expect(result.details?.receipts?.[0]?.outcome).toBe("injected");
+			const details = result.details as CoordinationDetails | undefined;
+			expect(details?.receipts?.[0]?.outcome).toBe("injected");
 			const text = result.content[0]?.type === "text" ? result.content[0].text : "";
 			expect(text).toContain("Send delivered");
 			expect(text).toContain("interrupted");
 		});
 
 		it("op=send rejects await with to=all and self-sends", async () => {
-			const tool = new IrcTool(makeToolSession(registry, "0-Main"));
+			const tool = new HubTool(makeToolSession(registry, "0-Main"));
 			const broadcast = await tool.execute("call-1", { op: "send", to: "all", message: "x", await: true });
 			expect(broadcast.isError).toBe(true);
 			const self = await tool.execute("call-2", { op: "send", to: "0-Main", message: "x" });
 			expect(self.isError).toBe(true);
+			const selfText = self.content[0]?.type === "text" ? self.content[0].text : "";
+			expect(selfText).toContain("Cannot send a message to yourself.");
 		});
 
 		it("op=send returns a failed receipt for unknown targets", async () => {
-			const tool = new IrcTool(makeToolSession(registry, "0-Main"));
+			const tool = new HubTool(makeToolSession(registry, "0-Main"));
 			const result = await tool.execute("call-1", { op: "send", to: "0-Ghost", message: "ping" });
 			expect(result.isError).toBe(true);
-			expect(result.details?.receipts?.[0]?.outcome).toBe("failed");
+			const details = result.details as CoordinationDetails | undefined;
+			expect(details?.receipts?.[0]?.outcome).toBe("failed");
 		});
 
 		it("op=wait returns a clean non-error timeout result", async () => {
 			const fake = makeFakeSession();
 			registry.register({ id: "0-Sub", displayName: "sub", kind: "sub", session: fake.session, status: "running" });
-			const tool = new IrcTool(makeToolSession(registry, "0-Main"));
+			const tool = new HubTool(makeToolSession(registry, "0-Main"));
 			const result = await tool.execute("call-1", { op: "wait", timeoutMs: 5 });
 			expect(result.isError).toBeFalsy();
-			expect(result.details?.waited).toBeNull();
+			const details = result.details as CoordinationDetails | undefined;
+			expect(details?.waited).toBeNull();
 			const text = result.content[0]?.type === "text" ? result.content[0].text : "";
 			expect(text).toContain("No message");
 		});
 
-		it("op=wait returns an error if no active agents exist", async () => {
-			const tool = new IrcTool(makeToolSession(registry, "0-Main"));
+		it("op=wait returns a clean result if no active agents exist", async () => {
+			const tool = new HubTool(makeToolSession(registry, "0-Main"));
 			const result = await tool.execute("call-1", { op: "wait", timeoutMs: 5 });
-			expect(result.isError).toBe(true);
+			expect(result.isError).toBeFalsy();
 			const text = result.content[0]?.type === "text" ? result.content[0].text : "";
-			expect(text).toContain("no running peers remain");
+			expect(text).toContain("No running background jobs to wait for.");
 		});
 
 		it("op=wait returns an error if the requested specific 'from' agent is not active", async () => {
 			registry.register({ id: "0-Sub", displayName: "sub", kind: "sub", session: null, status: "parked" });
-			const tool = new IrcTool(makeToolSession(registry, "0-Main"));
+			const tool = new HubTool(makeToolSession(registry, "0-Main"));
 			const result = await tool.execute("call-1", { op: "wait", from: "0-Sub", timeoutMs: 5 });
 			expect(result.isError).toBe(true);
 			const text = result.content[0]?.type === "text" ? result.content[0].text : "";
@@ -670,14 +672,14 @@ describe("IRC", () => {
 			});
 			expect(delivery).toBe("injected");
 
-			const tool = new IrcTool(makeToolSession(registry, "0-Running"));
+			const tool = new HubTool(makeToolSession(registry, "0-Running"));
 			const controller = new AbortController();
 			controller.abort(new Error("queued IRC interrupt"));
-
 			const result = await tool.execute("call-1", { op: "wait", timeoutMs: 30_000 }, controller.signal);
 
 			expect(result.isError).toBeFalsy();
-			expect(result.details?.waited).toMatchObject({
+			const details = result.details as CoordinationDetails | undefined;
+			expect(details?.waited).toMatchObject({
 				id: "msg-wait-pending",
 				from: "0-Main",
 				to: "0-Running",
@@ -687,7 +689,8 @@ describe("IRC", () => {
 			expect(text).toContain("queued interrupt note");
 
 			const empty = await tool.execute("call-2", { op: "inbox" });
-			expect(empty.details?.inbox).toEqual([]);
+			const emptyDetails = empty.details as CoordinationDetails | undefined;
+			expect(emptyDetails?.inbox).toEqual([]);
 		});
 
 		it("op=inbox drains IRC asides that arrived while the caller was running", async () => {
@@ -705,10 +708,10 @@ describe("IRC", () => {
 			});
 			expect(delivery).toBe("injected");
 
-			const tool = new IrcTool(makeToolSession(registry, "0-Running"));
+			const tool = new HubTool(makeToolSession(registry, "0-Running"));
 			const result = await tool.execute("call-1", { op: "inbox" });
-
-			expect(result.details?.inbox?.map(msg => msg.body)).toEqual(["parallel note"]);
+			const details = result.details as CoordinationDetails | undefined;
+			expect(details?.inbox?.map((msg: IrcMessage) => msg.body)).toEqual(["parallel note"]);
 			const text = result.content[0]?.type === "text" ? result.content[0].text : "";
 			expect(text).toContain("parallel note");
 		});
@@ -727,16 +730,17 @@ describe("IRC", () => {
 				ts: Date.now(),
 			});
 
-			const tool = new IrcTool(makeToolSession(registry, "0-Running"));
+			const tool = new HubTool(makeToolSession(registry, "0-Running"));
 			const peeked = await tool.execute("call-1", { op: "inbox", peek: true });
-			expect(peeked.details?.inbox?.map(msg => msg.body)).toEqual(["peeked note"]);
+			const peekedDetails = peeked.details as CoordinationDetails | undefined;
+			expect(peekedDetails?.inbox?.map((msg: IrcMessage) => msg.body)).toEqual(["peeked note"]);
 
 			// The peek surfaced the body via the tool result, so the aside-channel
 			// copy must NOT also be auto-injected at the next step: a second drain
 			// returns nothing (the pending aside was consumed out of the
-			// auto-inject queue when peek surfaced it).
 			const second = await tool.execute("call-2", { op: "inbox" });
-			expect(second.details?.inbox).toEqual([]);
+			const secondDetails = second.details as CoordinationDetails | undefined;
+			expect(secondDetails?.inbox).toEqual([]);
 		});
 
 		it("op=inbox drains the caller's mailbox", async () => {
@@ -747,13 +751,16 @@ describe("IRC", () => {
 			main.setError(new Error("temporarily unavailable"));
 			await bus.send({ from: "0-Sub", to: "0-Main", body: "fyi" });
 
-			const tool = new IrcTool(makeToolSession(registry, "0-Main"));
+			const tool = new HubTool(makeToolSession(registry, "0-Main"));
 			const peeked = await tool.execute("call-1", { op: "inbox", peek: true });
-			expect(peeked.details?.inbox?.map(msg => msg.body)).toEqual(["fyi"]);
+			const peekedDetails = peeked.details as CoordinationDetails | undefined;
+			expect(peekedDetails?.inbox?.map((msg: IrcMessage) => msg.body)).toEqual(["fyi"]);
 			const drained = await tool.execute("call-2", { op: "inbox" });
-			expect(drained.details?.inbox?.map(msg => msg.body)).toEqual(["fyi"]);
+			const drainedDetails = drained.details as CoordinationDetails | undefined;
+			expect(drainedDetails?.inbox?.map((msg: IrcMessage) => msg.body)).toEqual(["fyi"]);
 			const empty = await tool.execute("call-3", { op: "inbox" });
-			expect(empty.details?.inbox).toEqual([]);
+			const emptyDetails = empty.details as CoordinationDetails | undefined;
+			expect(emptyDetails?.inbox).toEqual([]);
 		});
 	});
 
diff --git a/packages/coding-agent/test/tools/launch-renderer.test.ts b/packages/coding-agent/test/tools/launch-renderer.test.ts
index fea9522ce..a0572a5d1 100644
--- a/packages/coding-agent/test/tools/launch-renderer.test.ts
+++ b/packages/coding-agent/test/tools/launch-renderer.test.ts
@@ -8,7 +8,7 @@ import { describe, expect, it } from "bun:test";
 import type { DaemonSnapshot } from "@oh-my-pi/pi-coding-agent/launch/protocol";
 import { renderTerminalOutput } from "@oh-my-pi/pi-coding-agent/launch/terminal-output";
 import { getThemeByName } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
-import { type LaunchToolDetails, launchToolRenderer } from "@oh-my-pi/pi-coding-agent/tools/launch";
+import { hubToolRenderer, type LaunchToolDetails } from "@oh-my-pi/pi-coding-agent/tools/hub";
 import { toolRenderers } from "@oh-my-pi/pi-coding-agent/tools/renderers";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
 
@@ -35,16 +35,16 @@ const daemon = (overrides: Partial<DaemonSnapshot>): DaemonSnapshot => ({
 	...overrides,
 });
 
-describe("launchToolRenderer", () => {
+describe("hub launch rendering", () => {
 	it("is registered with merged call/result so the pending header is replaced, not stacked", () => {
-		expect(Object.is(toolRenderers.launch.renderResult, launchToolRenderer.renderResult)).toBe(true);
-		expect(toolRenderers.launch.mergeCallAndResult).toBe(true);
+		expect(Object.is(toolRenderers.hub.renderResult, hubToolRenderer.renderResult)).toBe(true);
+		expect(toolRenderers.hub.mergeCallAndResult).toBe(true);
 	});
 
 	it("folds a stop result into one header with op, name, and exit state", async () => {
 		const uiTheme = await theme();
 		const rendered = lines(
-			launchToolRenderer.renderResult(
+			hubToolRenderer.renderResult(
 				{
 					content: [{ type: "text", text: "Stopped pyc-profile-run: exited exit=0 uptime=22.6s restarts=0" }],
 					details: {
@@ -67,7 +67,7 @@ describe("launchToolRenderer", () => {
 	it("renders log lines without the trailing cursor-status suffix, surfacing it as header meta", async () => {
 		const uiTheme = await theme();
 		const rendered = lines(
-			launchToolRenderer.renderResult(
+			hubToolRenderer.renderResult(
 				{
 					content: [{ type: "text", text: "line one\nline two\n[web: running; cursor=2210]" }],
 					details: { op: "logs", cursor: 2210, timedOut: false, state: "running" } satisfies LaunchToolDetails,
@@ -99,7 +99,7 @@ describe("launchToolRenderer", () => {
 		expect(Bun.stripANSI(terminalRows[0] ?? "")).toBe("           ready");
 
 		const uiTheme = await theme();
-		const component = launchToolRenderer.renderResult(
+		const component = hubToolRenderer.renderResult(
 			{
 				content: [{ type: "text", text: "ready\n[web: running; cursor=2210]" }],
 				details: {
@@ -125,14 +125,14 @@ describe("launchToolRenderer", () => {
 		const uiTheme = await theme();
 		const daemons = Array.from({ length: 11 }, (_, i) => daemon({ name: `svc-${i}`, id: `d-${i}` }));
 		const rendered = lines(
-			launchToolRenderer.renderResult(
+			hubToolRenderer.renderResult(
 				{
 					content: [{ type: "text", text: "" }],
 					details: { op: "list", daemons } satisfies LaunchToolDetails,
 				},
 				{ expanded: false, isPartial: false },
 				uiTheme,
-				{ op: "list" },
+				{ op: "ps" },
 			),
 		);
 		expect(rendered[0]).toContain("11 processes");
@@ -144,7 +144,7 @@ describe("launchToolRenderer", () => {
 	it("marks a failed start with the daemon's exit reason even though the result is not an error", async () => {
 		const uiTheme = await theme();
 		const rendered = lines(
-			launchToolRenderer.renderResult(
+			hubToolRenderer.renderResult(
 				{
 					content: [{ type: "text", text: "Failed to launch web: failed exit=127" }],
 					details: {
@@ -170,7 +170,7 @@ describe("launchToolRenderer", () => {
 	it("names the unmet readiness condition instead of a contradictory Ready + timed-out pair", async () => {
 		const uiTheme = await theme();
 		const rendered = lines(
-			launchToolRenderer.renderResult(
+			hubToolRenderer.renderResult(
 				{
 					content: [{ type: "text", text: "" }],
 					details: {
diff --git a/packages/coding-agent/test/tools/provider-schema-compatibility.test.ts b/packages/coding-agent/test/tools/provider-schema-compatibility.test.ts
index 60e099649..849962311 100644
--- a/packages/coding-agent/test/tools/provider-schema-compatibility.test.ts
+++ b/packages/coding-agent/test/tools/provider-schema-compatibility.test.ts
@@ -24,7 +24,7 @@ function createTestSession(): ToolSession {
 		hasUI: true,
 		getSessionFile: () => null,
 		getSessionSpawns: () => "*",
-		settings: Settings.isolated(),
+		settings: Settings.isolated({ "tools.xdev": false }),
 	};
 }
 
@@ -154,10 +154,10 @@ describe("builtin tool schemas provider compatibility", () => {
 		expect(typeSchema?.anyOf).toBeUndefined();
 	});
 
-	it("asserts that browser tool schema root has 'type: \"object\"' for Codex and OpenAI Responses compatibility", async () => {
+	it('asserts that browser tool schema root stays `type: "object"` when discoverable tools are mounted', async () => {
 		const toolSchemas = await collectToolSchemas();
 		const browserEntry = toolSchemas.find(tool => tool.name === "browser");
 		expect(browserEntry).toBeDefined();
-		expect(browserEntry?.schema.type).toBe("object");
+		expect(asSchemaObject(browserEntry?.schema)?.type).toBe("object");
 	});
 });
diff --git a/packages/coding-agent/test/tools/report-tool-issue.test.ts b/packages/coding-agent/test/tools/report-tool-issue.test.ts
index 0853b044f..7f6e8179c 100644
--- a/packages/coding-agent/test/tools/report-tool-issue.test.ts
+++ b/packages/coding-agent/test/tools/report-tool-issue.test.ts
@@ -1,10 +1,15 @@
 import { Database } from "bun:sqlite";
 import { afterEach, beforeEach, describe, expect, it, vi } from "bun:test";
 import { Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
+import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
+import * as reportIssue from "@oh-my-pi/pi-coding-agent/tools/report-tool-issue";
 import {
+	__resetAutoQaConsentForTests,
 	__resetAutoQaFlushStateForTests,
+	dispatchReportIssueDevice,
 	flushGrievances,
 	isAutoQaEnabled,
+	reportIssueDeviceUsage,
 } from "@oh-my-pi/pi-coding-agent/tools/report-tool-issue";
 import * as piUtils from "@oh-my-pi/pi-utils";
 import { mockFetch } from "../helpers/fetch-mock";
@@ -78,7 +83,6 @@ describe("flushGrievances", () => {
 		__resetAutoQaFlushStateForTests();
 		originalPiAutoQa = Bun.env.PI_AUTO_QA;
 		delete Bun.env.PI_AUTO_QA;
-		vi.spyOn(piUtils, "getInstallId").mockReturnValue("11111111-2222-3333-4444-555555555555");
 		db = openTempDb();
 	});
 
@@ -138,6 +142,7 @@ describe("flushGrievances", () => {
 	});
 
 	it("posts pending rows with bearer header and marks them pushed=1 on 200", async () => {
+		vi.spyOn(piUtils, "getInstallId").mockReturnValue("11111111-2222-3333-4444-555555555555");
 		insertGrievance(db, "glob", "weird ordering");
 		insertGrievance(db, "read", "selector ignored");
 
@@ -325,3 +330,54 @@ describe("flushGrievances", () => {
 		expect(selectUnpushedIds(db).length).toBe(secondBatch);
 	});
 });
+
+describe("dispatchReportIssueDevice", () => {
+	afterEach(() => {
+		__resetAutoQaConsentForTests();
+	});
+
+	it("records a grievance from `<tool>: <report>` text", async () => {
+		Bun.env.PI_AUTO_QA = "1";
+		const db = openTempDb();
+		const openSpy = vi.spyOn(reportIssue, "openAutoQaDb").mockReturnValue(db);
+		try {
+			const session = { settings: Settings.isolated({ "dev.autoqa": true }) } as ToolSession;
+			const { result, xdev } = await dispatchReportIssueDevice(
+				session,
+				"read: selector parse dropped trailing line",
+			);
+			const first = result.content[0];
+			expect(first?.type).toBe("text");
+			if (first?.type === "text") expect(first.text).toBe("Noted, thanks!");
+			expect(xdev.tool).toBe("report_issue");
+			expect(selectIds(db)).toHaveLength(1);
+			const row = db.prepare("SELECT tool, report FROM grievances").get() as { tool: string; report: string };
+			expect(row).toEqual({ tool: "read", report: "selector parse dropped trailing line" });
+		} finally {
+			openSpy.mockRestore();
+			db.close();
+		}
+	});
+
+	it("accepts the two-line fallback body format", async () => {
+		Bun.env.PI_AUTO_QA = "1";
+		const db = openTempDb();
+		const openSpy = vi.spyOn(reportIssue, "openAutoQaDb").mockReturnValue(db);
+		try {
+			const session = { settings: Settings.isolated({ "dev.autoqa": true }) } as ToolSession;
+			await dispatchReportIssueDevice(session, "grep\nreported matches include a deleted file");
+			const row = db.prepare("SELECT tool, report FROM grievances").get() as { tool: string; report: string };
+			expect(row).toEqual({ tool: "grep", report: "reported matches include a deleted file" });
+		} finally {
+			openSpy.mockRestore();
+			db.close();
+		}
+	});
+
+	it("rejects malformed body text with a usage hint", async () => {
+		const session = { settings: Settings.isolated({ "dev.autoqa": true }) } as ToolSession;
+		await expect(dispatchReportIssueDevice(session, "just a vague sentence")).rejects.toThrow(
+			reportIssueDeviceUsage(),
+		);
+	});
+});
diff --git a/packages/coding-agent/test/tools/resolve.test.ts b/packages/coding-agent/test/tools/resolve.test.ts
index 55149845f..1b0ded674 100644
--- a/packages/coding-agent/test/tools/resolve.test.ts
+++ b/packages/coding-agent/test/tools/resolve.test.ts
@@ -2,18 +2,39 @@ import { describe, expect, it } from "bun:test";
 import { Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
 import { getThemeByName } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
 import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
-import { ResolveTool, resolveToolRenderer } from "@oh-my-pi/pi-coding-agent/tools/resolve";
+import {
+	dispatchResolutionDevice,
+	isPreviewResolutionToolCall,
+	isProposeToolCall,
+	type PlanProposalHandler,
+	PROPOSE_DEVICE_NAME,
+	PROPOSE_DEVICE_PATH,
+	REJECT_DEVICE_NAME,
+	REJECT_DEVICE_PATH,
+	RESOLVE_DEVICE_NAME,
+	RESOLVE_DEVICE_PATH,
+	resolutionDeviceUsage,
+	resolveRenderer,
+	writeDeviceDispatch,
+} from "@oh-my-pi/pi-coding-agent/tools/resolve";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
 
-function createSession(handler?: (input: unknown) => Promise<unknown>, clearPendingInvokers?: () => void): ToolSession {
+function createSession(
+	options: {
+		handler?: (input: unknown) => Promise<unknown>;
+		proposalHandler?: PlanProposalHandler;
+		clearPendingInvokers?: () => void;
+	} = {},
+): ToolSession {
 	return {
 		cwd: "/tmp",
 		hasUI: false,
 		getSessionFile: () => null,
 		getSessionSpawns: () => "*",
 		settings: Settings.isolated(),
-		peekQueueInvoker: handler ? () => handler : () => undefined,
-		clearPendingInvokers,
+		peekQueueInvoker: options.handler ? () => options.handler : () => undefined,
+		peekPlanProposalHandler: options.proposalHandler ? () => options.proposalHandler : () => undefined,
+		clearPendingInvokers: options.clearPendingInvokers,
 	};
 }
 
@@ -21,108 +42,109 @@ function getText(result: { content: Array<{ type: string; text?: string }> }): s
 	return result.content.find(part => part.type === "text")?.text ?? "";
 }
 
-function getRequiredFields(schema: { json?: { required?: Array<{ key: string }> } }): string[] {
-	const required: string[] = [];
-	if (schema.json?.required && Array.isArray(schema.json.required)) {
-		required.push(...schema.json.required.map(item => item.key));
-	}
-	return required.sort();
-}
-
-describe("ResolveTool", () => {
-	it("requires action and reason in schema", () => {
-		const tool = new ResolveTool(createSession());
-		const required = getRequiredFields(tool.parameters as { json?: { required?: Array<{ key: string }> } });
-		expect(required).toEqual(["action", "reason"]);
+describe("dispatchResolutionDevice", () => {
+	it("returns usage text for each device", () => {
+		expect(resolutionDeviceUsage(RESOLVE_DEVICE_NAME)).toContain(RESOLVE_DEVICE_PATH);
+		expect(resolutionDeviceUsage(REJECT_DEVICE_NAME)).toContain(REJECT_DEVICE_PATH);
+		expect(resolutionDeviceUsage(PROPOSE_DEVICE_NAME)).toContain(PROPOSE_DEVICE_PATH);
 	});
 
-	it("errors and clears stale pending markers when apply has no invoker", async () => {
+	it("errors and clears stale pending markers when resolve has no invoker", async () => {
 		let clearRuns = 0;
-		const tool = new ResolveTool(
-			createSession(undefined, () => {
+		const session = createSession({
+			clearPendingInvokers: () => {
 				clearRuns++;
-			}),
-		);
-		await expect(tool.execute("call-none", { action: "apply", reason: "looks correct" })).rejects.toThrow(
-			"No pending action to resolve. Nothing to apply or discard.",
-		);
-		expect(clearRuns).toBe(1);
-	});
-
-	it("treats discard with no pending action as a successful cancellation and clears stale markers", async () => {
-		let clearRuns = 0;
-		const tool = new ResolveTool(
-			createSession(undefined, () => {
-				clearRuns++;
-			}),
-		);
-		const result = await tool.execute("call-discard-none", {
-			action: "discard",
-			reason: "Abandoning the staged edit.",
+			},
 		});
-		expect(result.isError ?? false).toBe(false);
-		expect(getText(result)).toContain("Nothing to discard");
-		expect(result.details).toMatchObject({ action: "discard", reason: "Abandoning the staged edit." });
+		await expect(dispatchResolutionDevice(session, RESOLVE_DEVICE_NAME, "looks correct")).rejects.toThrow(
+			`No pending action to apply — ${RESOLVE_DEVICE_PATH} is only valid while a staged preview is pending.`,
+		);
 		expect(clearRuns).toBe(1);
 	});
 
-	it("discards pending action and clears store", async () => {
-		let discardedReason: string | undefined;
+	it("treats reject with no pending action as a successful cancellation and clears stale markers", async () => {
+		let clearRuns = 0;
+		const session = createSession({
+			clearPendingInvokers: () => {
+				clearRuns++;
+			},
+		});
+		const { result, xdev } = await dispatchResolutionDevice(
+			session,
+			REJECT_DEVICE_NAME,
+			"Abandoning the staged edit.",
+		);
+		expect(result.isError ?? false).toBe(false);
+		expect(getText(result)).toContain("Nothing to reject");
+		expect(result.details).toMatchObject({ action: "discard", reason: "Abandoning the staged edit." });
+		expect(xdev.inner).toMatchObject({ action: "discard" });
+		expect(clearRuns).toBe(1);
+	});
+
+	it("rejects through the pending invoker", async () => {
+		let rejectedReason: string | undefined;
 		const handler = async (input: unknown) => {
-			const p = input as { action: string; reason: string };
-			if (p.action === "discard") {
-				discardedReason = p.reason;
+			if (!input || typeof input !== "object" || !("action" in input) || !("reason" in input)) {
+				throw new Error("invalid test input");
+			}
+			const action = input.action;
+			const reason = input.reason;
+			if (action === "discard" && typeof reason === "string") {
+				rejectedReason = reason;
 			}
 			return {
 				content: [{ type: "text", text: "Rejected pending preview." }],
 				details: {
-					action: p.action,
-					reason: p.reason,
+					action,
+					reason,
 					sourceToolName: "ast_edit",
 					label: "AST Edit: 2 replacements in 1 file",
 				},
 			};
 		};
-		const session = createSession(handler);
-		const tool = new ResolveTool(session);
-		const result = await tool.execute("call-discard", {
-			action: "discard",
-			reason: "Preview changed wrong callsites",
-		});
+		const { result, xdev } = await dispatchResolutionDevice(
+			createSession({ handler }),
+			REJECT_DEVICE_NAME,
+			"Preview changed wrong callsites",
+		);
 
 		expect(getText(result)).toContain("Rejected pending preview.");
-		expect(discardedReason).toBe("Preview changed wrong callsites");
+		expect(rejectedReason).toBe("Preview changed wrong callsites");
 		expect(result.details).toEqual({
 			action: "discard",
 			reason: "Preview changed wrong callsites",
 			sourceToolName: "ast_edit",
 			label: "AST Edit: 2 replacements in 1 file",
 		});
+		expect(xdev.tool).toBe(REJECT_DEVICE_NAME);
 	});
 
-	it("applies pending action and clears store", async () => {
+	it("applies through the pending invoker and carries dispatch metadata", async () => {
 		let appliedReason: string | undefined;
 		const handler = async (input: unknown) => {
-			const p = input as { action: string; reason: string };
-			if (p.action === "apply") {
-				appliedReason = p.reason;
+			if (!input || typeof input !== "object" || !("action" in input) || !("reason" in input)) {
+				throw new Error("invalid test input");
+			}
+			const action = input.action;
+			const reason = input.reason;
+			if (action === "apply" && typeof reason === "string") {
+				appliedReason = reason;
 			}
 			return {
 				content: [{ type: "text", text: "Applied 1 replacement in 1 file." }],
 				details: {
-					action: p.action,
-					reason: p.reason,
+					action,
+					reason,
 					sourceToolName: "ast_edit",
 					label: "AST Edit: 1 replacement in 1 file",
 				},
 			};
 		};
-		const session = createSession(handler);
-		const tool = new ResolveTool(session);
-		const result = await tool.execute("call-apply", {
-			action: "apply",
-			reason: "Preview is correct",
-		});
+		const { result, xdev } = await dispatchResolutionDevice(
+			createSession({ handler }),
+			RESOLVE_DEVICE_NAME,
+			"Preview is correct",
+		);
 
 		expect(appliedReason).toBe("Preview is correct");
 		expect(getText(result)).toContain("Applied 1 replacement in 1 file.");
@@ -132,6 +154,42 @@ describe("ResolveTool", () => {
 			sourceToolName: "ast_edit",
 			label: "AST Edit: 1 replacement in 1 file",
 		});
+		expect(writeDeviceDispatch("write", { details: { xdev } })?.tool).toBe(RESOLVE_DEVICE_NAME);
+	});
+
+	it("routes propose to the plan proposal handler", async () => {
+		let proposedTitle = "";
+		const proposalHandler: PlanProposalHandler = async (title: string) => {
+			proposedTitle = title;
+			return {
+				content: [{ type: "text", text: "Plan ready for approval." }],
+				details: { planFilePath: "local://demo-plan.md", title, planExists: true },
+			};
+		};
+		const { result, xdev } = await dispatchResolutionDevice(
+			createSession({ proposalHandler }),
+			PROPOSE_DEVICE_NAME,
+			"demo",
+		);
+		expect(proposedTitle).toBe("demo");
+		expect(getText(result)).toContain("Plan ready for approval.");
+		expect(xdev).toMatchObject({ tool: PROPOSE_DEVICE_NAME, mode: "execute", args: { title: "demo" } });
+	});
+});
+
+describe("device tool-call predicates", () => {
+	it("matches only writes targeting the preview-resolution devices", () => {
+		expect(isPreviewResolutionToolCall({ name: "write", arguments: { path: RESOLVE_DEVICE_PATH } })).toBe(true);
+		expect(isPreviewResolutionToolCall({ name: "write", arguments: { path: REJECT_DEVICE_PATH } })).toBe(true);
+		expect(isPreviewResolutionToolCall({ name: "write", arguments: { path: PROPOSE_DEVICE_PATH } })).toBe(false);
+		expect(isPreviewResolutionToolCall({ name: "write", arguments: { path: "/tmp/notes.md" } })).toBe(false);
+		expect(isPreviewResolutionToolCall({ name: "edit", arguments: { path: RESOLVE_DEVICE_PATH } })).toBe(false);
+	});
+
+	it("matches only writes targeting xd://propose for plan decisions", () => {
+		expect(isProposeToolCall({ name: "write", arguments: { path: PROPOSE_DEVICE_PATH } })).toBe(true);
+		expect(isProposeToolCall({ name: "write", arguments: { path: RESOLVE_DEVICE_PATH } })).toBe(false);
+		expect(isProposeToolCall({ name: "ask", arguments: {} })).toBe(false);
 	});
 });
 
@@ -140,7 +198,7 @@ it("renders a highlighted apply summary", async () => {
 	expect(theme).toBeDefined();
 	const uiTheme = theme!;
 
-	const component = resolveToolRenderer.renderResult(
+	const component = resolveRenderer.renderResult(
 		{
 			content: [{ type: "text", text: "Applied 2 replacements in 1 file." }],
 			details: {
@@ -168,7 +226,7 @@ it("keeps the inverse block color across the full line (no mid-line fg reset)",
 	expect(theme).toBeDefined();
 	const uiTheme = theme!;
 
-	const component = resolveToolRenderer.renderResult(
+	const component = resolveRenderer.renderResult(
 		{
 			content: [{ type: "text", text: "Applied 2 replacements in 1 file." }],
 			details: {
@@ -182,10 +240,6 @@ it("keeps the inverse block color across the full line (no mid-line fg reset)",
 		uiTheme,
 	);
 
-	// Each line is inverse(fg(color, ...)): under inverse the fg paints the block
-	// background, so an embedded fg reset (e.g. a styledSymbol icon's \x1b[39m)
-	// turns everything after it white. Exactly one reset — the outer close — may
-	// appear per line.
 	for (const line of component.render(90)) {
 		expect(line.split("\x1b[39m")).toHaveLength(2);
 	}
diff --git a/packages/coding-agent/test/tools/review.test.ts b/packages/coding-agent/test/tools/review.test.ts
index 7c7547717..10213f202 100644
--- a/packages/coding-agent/test/tools/review.test.ts
+++ b/packages/coding-agent/test/tools/review.test.ts
@@ -1,13 +1,11 @@
 import { describe, expect, it } from "bun:test";
-import { finalizeSubprocessOutput } from "@oh-my-pi/pi-coding-agent/task/executor";
-import { subprocessToolRegistry } from "@oh-my-pi/pi-coding-agent/task/subprocess-tool-registry";
-import { parseReportFindingDetails, toReviewFinding } from "@oh-my-pi/pi-coding-agent/tools/review";
+import { parseFindingDetails } from "@oh-my-pi/pi-coding-agent/tools/review";
 
-describe("report_finding subprocess extraction", () => {
+describe("parseFindingDetails", () => {
 	it("returns undefined for malformed finding details", () => {
-		expect(parseReportFindingDetails({})).toBeUndefined();
+		expect(parseFindingDetails({})).toBeUndefined();
 		expect(
-			parseReportFindingDetails({
+			parseFindingDetails({
 				title: "[P1] Missing file path",
 				body: "Body",
 				priority: "P1",
@@ -18,284 +16,25 @@ describe("report_finding subprocess extraction", () => {
 		).toBeUndefined();
 	});
 
-	it("ignores error events and extracts valid details", () => {
-		const handler = subprocessToolRegistry.getHandler("report_finding");
-		if (!handler?.extractData) {
-			throw new Error("report_finding handler is not registered");
-		}
-
-		const validDetails = {
+	it("parses a complete finding, coercing numeric priority", () => {
+		expect(
+			parseFindingDetails({
+				title: "[P1] Example finding",
+				body: "Body",
+				priority: 1,
+				confidence: 0.9,
+				file_path: "/tmp/example.ts",
+				line_start: 10,
+				line_end: 12,
+			}),
+		).toEqual({
 			title: "[P1] Example finding",
-			body: "Details",
-			priority: "P1" as const,
-			confidence: 0.95,
+			body: "Body",
+			priority: "P1",
+			confidence: 0.9,
 			file_path: "/tmp/example.ts",
 			line_start: 10,
 			line_end: 12,
-		};
-
-		expect(
-			handler.extractData({
-				toolName: "report_finding",
-				toolCallId: "call-1",
-				result: {
-					content: [{ type: "text", text: "Finding recorded" }],
-					details: validDetails,
-				},
-				isError: false,
-			}),
-		).toEqual(validDetails);
-
-		expect(
-			handler.extractData({
-				toolName: "report_finding",
-				toolCallId: "call-2",
-				result: {
-					content: [{ type: "text", text: "Validation failed" }],
-					details: {},
-				},
-				isError: true,
-			}),
-		).toBeUndefined();
-	});
-});
-
-describe("toReviewFinding", () => {
-	const base = {
-		title: "[P0] Example finding",
-		body: "Details",
-		confidence: 0.95,
-		file_path: "/tmp/example.ts",
-		line_start: 10,
-		line_end: 12,
-	} as const;
-
-	it("maps the priority string enum to its numeric ordinal", () => {
-		expect(toReviewFinding({ ...base, priority: "P0" }).priority).toBe(0);
-		expect(toReviewFinding({ ...base, priority: "P1" }).priority).toBe(1);
-		expect(toReviewFinding({ ...base, priority: "P2" }).priority).toBe(2);
-		expect(toReviewFinding({ ...base, priority: "P3" }).priority).toBe(3);
-	});
-
-	it("passes JTD validation against the reviewer agent's numeric priority schema (#1350)", () => {
-		// Mirrors the bundled reviewer agent's output schema. Before the fix the
-		// string priority from `report_finding` short-circuited every successful
-		// review run with `findings.0.priority: expected number, received string`.
-		const reviewerSchema = {
-			properties: {
-				overall_correctness: { enum: ["correct", "incorrect"] },
-				explanation: { type: "string" },
-				confidence: { type: "number" },
-			},
-			optionalProperties: {
-				findings: {
-					elements: {
-						properties: {
-							title: { type: "string" },
-							body: { type: "string" },
-							priority: { type: "number" },
-							confidence: { type: "number" },
-							file_path: { type: "string" },
-							line_start: { type: "number" },
-							line_end: { type: "number" },
-						},
-					},
-				},
-			},
-		};
-
-		const result = finalizeSubprocessOutput({
-			rawOutput: "",
-			exitCode: 0,
-			stderr: "",
-			doneAborted: false,
-			signalAborted: false,
-			yieldItems: [
-				{
-					status: "success",
-					data: {
-						overall_correctness: "incorrect",
-						explanation: "Found one bug",
-						confidence: 0.9,
-					},
-				},
-			],
-			reportFindings: [toReviewFinding({ ...base, priority: "P2" })],
-			outputSchema: reviewerSchema,
-		});
-
-		expect(result.exitCode).toBe(0);
-		expect(result.stderr).toBe("");
-		const parsed = JSON.parse(result.rawOutput) as {
-			findings: Array<{ priority: number }>;
-		};
-		expect(parsed.findings[0].priority).toBe(2);
-	});
-});
-
-describe("findings injection respects active output schema", () => {
-	const finding = toReviewFinding({
-		title: "[P0] Example finding",
-		body: "Details",
-		priority: "P0",
-		confidence: 0.95,
-		file_path: "/tmp/example.ts",
-		line_start: 10,
-		line_end: 12,
-	});
-
-	// Reproduces #2070: a caller-supplied JSON Schema with
-	// `additionalProperties: false` and no `findings` property is silently
-	// rejected post-mortem after the in-tool yield accepted it, because the
-	// executor auto-injects `findings` from `report_finding`. The injection
-	// must respect the active schema so that "accepted in-tool ⇒ accepted
-	// post-mortem" is honored.
-	it("suppresses findings injection when the schema forbids additional properties", () => {
-		const callerSchema = {
-			type: "object",
-			additionalProperties: false,
-			required: ["verdict", "acceptance_summary"],
-			properties: {
-				verdict: { enum: ["accept", "needs-work", "honest-stop"] },
-				acceptance_summary: { type: "string" },
-			},
-		};
-		const data = { verdict: "accept", acceptance_summary: "All good." };
-
-		const result = finalizeSubprocessOutput({
-			rawOutput: "",
-			exitCode: 0,
-			stderr: "",
-			doneAborted: false,
-			signalAborted: false,
-			yieldItems: [{ status: "success", data }],
-			reportFindings: [finding],
-			outputSchema: callerSchema,
-		});
-
-		expect(result.exitCode).toBe(0);
-		expect(result.stderr).toBe("");
-		const parsed = JSON.parse(result.rawOutput) as Record<string, unknown>;
-		expect(parsed).toEqual(data);
-		expect("findings" in parsed).toBe(false);
-	});
-
-	it("still injects findings when the schema declares them (bundled reviewer JTD)", () => {
-		// Mirrors the bundled reviewer agent's output: findings live under
-		// `optionalProperties`, so injection must continue to flow through.
-		const reviewerSchema = {
-			properties: {
-				overall_correctness: { enum: ["correct", "incorrect"] },
-				explanation: { type: "string" },
-				confidence: { type: "number" },
-			},
-			optionalProperties: {
-				findings: {
-					elements: {
-						properties: {
-							title: { type: "string" },
-							body: { type: "string" },
-							priority: { type: "number" },
-							confidence: { type: "number" },
-							file_path: { type: "string" },
-							line_start: { type: "number" },
-							line_end: { type: "number" },
-						},
-					},
-				},
-			},
-		};
-		const data = {
-			overall_correctness: "incorrect",
-			explanation: "Found one bug",
-			confidence: 0.9,
-		};
-
-		const result = finalizeSubprocessOutput({
-			rawOutput: "",
-			exitCode: 0,
-			stderr: "",
-			doneAborted: false,
-			signalAborted: false,
-			yieldItems: [{ status: "success", data }],
-			reportFindings: [finding],
-			outputSchema: reviewerSchema,
-		});
-
-		expect(result.exitCode).toBe(0);
-		expect(result.stderr).toBe("");
-		const parsed = JSON.parse(result.rawOutput) as { findings: Array<{ priority: number }> };
-		expect(parsed.findings).toHaveLength(1);
-		expect(parsed.findings[0].priority).toBe(0);
-	});
-
-	it("still injects findings when no schema is declared (legacy free-form)", () => {
-		const data = { note: "freeform" };
-
-		const result = finalizeSubprocessOutput({
-			rawOutput: "",
-			exitCode: 0,
-			stderr: "",
-			doneAborted: false,
-			signalAborted: false,
-			yieldItems: [{ status: "success", data }],
-			reportFindings: [finding],
-			outputSchema: undefined,
-		});
-
-		expect(result.exitCode).toBe(0);
-		const parsed = JSON.parse(result.rawOutput) as { findings?: unknown[] };
-		expect(parsed.findings).toHaveLength(1);
-	});
-
-	it("still injects findings when additionalProperties is open", () => {
-		const openSchema = {
-			type: "object",
-			required: ["verdict"],
-			properties: { verdict: { type: "string" } },
-		};
-		const data = { verdict: "accept" };
-
-		const result = finalizeSubprocessOutput({
-			rawOutput: "",
-			exitCode: 0,
-			stderr: "",
-			doneAborted: false,
-			signalAborted: false,
-			yieldItems: [{ status: "success", data }],
-			reportFindings: [finding],
-			outputSchema: openSchema,
-		});
-
-		expect(result.exitCode).toBe(0);
-		const parsed = JSON.parse(result.rawOutput) as { findings?: unknown[]; verdict: string };
-		expect(parsed.verdict).toBe("accept");
-		expect(parsed.findings).toHaveLength(1);
-	});
-
-	it("suppresses injection on the fallback (no-yield) path when the schema forbids it", () => {
-		const callerSchema = {
-			type: "object",
-			additionalProperties: false,
-			required: ["verdict"],
-			properties: { verdict: { type: "string" } },
-		};
-		const rawJson = JSON.stringify({ data: { verdict: "accept" } });
-
-		const result = finalizeSubprocessOutput({
-			rawOutput: rawJson,
-			exitCode: 0,
-			stderr: "",
-			doneAborted: false,
-			signalAborted: false,
-			yieldItems: undefined,
-			reportFindings: [finding],
-			outputSchema: callerSchema,
-		});
-
-		expect(result.exitCode).toBe(0);
-		expect(result.stderr).toBe("");
-		const parsed = JSON.parse(result.rawOutput) as Record<string, unknown>;
-		expect(parsed).toEqual({ verdict: "accept" });
+		});
 	});
 });
diff --git a/packages/coding-agent/test/tools/root-path-alias.test.ts b/packages/coding-agent/test/tools/root-path-alias.test.ts
index a19de9749..63ebd9163 100644
--- a/packages/coding-agent/test/tools/root-path-alias.test.ts
+++ b/packages/coding-agent/test/tools/root-path-alias.test.ts
@@ -14,7 +14,7 @@ function createTestSession(cwd: string, overrides: Partial<ToolSession> = {}): T
 		hasUI: false,
 		getSessionFile: () => null,
 		getSessionSpawns: () => "*",
-		settings: Settings.isolated(),
+		settings: Settings.isolated({ "astGrep.enabled": true, "astEdit.enabled": true, "tools.xdev": false }),
 		...overrides,
 	};
 }
diff --git a/packages/coding-agent/test/tools/schema-validation.test.ts b/packages/coding-agent/test/tools/schema-validation.test.ts
index 4bfdc2ae1..362064cda 100644
--- a/packages/coding-agent/test/tools/schema-validation.test.ts
+++ b/packages/coding-agent/test/tools/schema-validation.test.ts
@@ -272,9 +272,9 @@ describe("tool schema validation (post-sanitization)", () => {
 	it("hidden tools also have valid sanitized schemas", async () => {
 		const session = createTestSession();
 
-		for (const name in HIDDEN_TOOLS) {
-			if (!Object.hasOwn(HIDDEN_TOOLS, name)) continue;
-			const tool = await HIDDEN_TOOLS[name](session);
+		// Object.entries keeps the factory typed without an index cast.
+		for (const [name, factory] of Object.entries(HIDDEN_TOOLS)) {
+			const tool = await factory(session);
 			if (!tool) continue;
 
 			const schema = tool.parameters;
diff --git a/packages/coding-agent/test/tools/search-tool-bm25.test.ts b/packages/coding-agent/test/tools/search-tool-bm25.test.ts
deleted file mode 100644
index d4648ce77..000000000
--- a/packages/coding-agent/test/tools/search-tool-bm25.test.ts
+++ /dev/null
@@ -1,264 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
-import {
-	buildDiscoverableToolSearchIndex,
-	type DiscoverableTool,
-	type DiscoverableToolSearchIndex,
-} from "@oh-my-pi/pi-coding-agent/tool-discovery/tool-index";
-import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
-import { renderSearchToolBm25Description, SearchToolBm25Tool } from "@oh-my-pi/pi-coding-agent/tools/search-tool-bm25";
-
-type DiscoveryToolSession = ToolSession & {
-	isMCPDiscoveryEnabled: () => boolean;
-	getDiscoverableTools: (filter?: { source?: DiscoverableTool["source"] }) => DiscoverableTool[];
-	getDiscoverableToolSearchIndex?: () => DiscoverableToolSearchIndex;
-	getSelectedMCPToolNames: () => string[];
-	activateDiscoveredMCPTools: (toolNames: string[]) => Promise<string[]>;
-	getSelected: () => string[];
-};
-
-function createSession(tools: DiscoverableTool[], overrides: Partial<DiscoveryToolSession> = {}): DiscoveryToolSession {
-	const selected: string[] = [];
-	return {
-		cwd: "/tmp/test",
-		hasUI: false,
-		getSessionFile: () => null,
-		getSessionSpawns: () => "*",
-		settings: Settings.isolated({ "mcp.discoveryMode": true }),
-		isMCPDiscoveryEnabled: () => true,
-		getDiscoverableTools: () => tools,
-		getSelectedMCPToolNames: () => [...selected],
-		activateDiscoveredMCPTools: async (toolNames: string[]) => {
-			for (const name of toolNames) {
-				if (!selected.includes(name)) {
-					selected.push(name);
-				}
-			}
-			return toolNames;
-		},
-		getSelected: () => [...selected],
-		...overrides,
-	};
-}
-
-/** Helper to create a discoverable MCP tool. */
-function mcpTool(
-	name: string,
-	serverName: string,
-	mcpToolName: string,
-	summary: string,
-	schemaKeys: string[],
-): DiscoverableTool {
-	return {
-		name,
-		label: `${serverName}/${mcpToolName}`,
-		summary,
-		source: "mcp",
-		serverName,
-		mcpToolName,
-		schemaKeys,
-	};
-}
-
-/** Helper to create a discoverable built-in tool. */
-function builtinTool(name: string, summary: string, schemaKeys: string[] = []): DiscoverableTool {
-	return {
-		name,
-		label: name,
-		summary,
-		source: "builtin",
-		schemaKeys,
-	};
-}
-
-describe("SearchToolBm25Tool", () => {
-	const discoverableTools: DiscoverableTool[] = [
-		mcpTool(
-			"mcp__github_create_issue",
-			"github",
-			"create_issue",
-			"Create a GitHub issue in the selected repository",
-			["owner", "repo", "title", "body"],
-		),
-		mcpTool("mcp__github_list_pull_requests", "github", "list_pull_requests", "List pull requests for a repository", [
-			"owner",
-			"repo",
-			"state",
-		]),
-		mcpTool("mcp__slack_post_message", "slack", "post_message", "Post a message to a Slack channel", [
-			"channel",
-			"text",
-		]),
-	];
-
-	it("uses the session-provided cached search index during execution", async () => {
-		let rawToolsCalls = 0;
-		let searchIndexCalls = 0;
-		const searchIndex = buildDiscoverableToolSearchIndex(discoverableTools);
-		const session = createSession(discoverableTools, {
-			getDiscoverableTools: () => {
-				rawToolsCalls++;
-				return discoverableTools;
-			},
-			getDiscoverableToolSearchIndex: () => {
-				searchIndexCalls++;
-				return searchIndex;
-			},
-		});
-		const tool = new SearchToolBm25Tool(session);
-		expect(rawToolsCalls).toBe(0);
-
-		const result = await tool.execute("call-index", { query: "github" });
-		expect(searchIndexCalls).toBe(1);
-		expect(rawToolsCalls).toBe(0);
-		expect(result.details?.tools.map(match => match.name)).toEqual([
-			"mcp__github_create_issue",
-			"mcp__github_list_pull_requests",
-		]);
-		expect(result.content).toEqual([
-			{
-				type: "text",
-				text: JSON.stringify({
-					query: "github",
-					activated_tools: ["mcp__github_create_issue", "mcp__github_list_pull_requests"],
-					match_count: 2,
-					total_tools: 3,
-				}),
-			},
-		]);
-	});
-
-	it("returns ranked matches and unions activated tools across repeated searches", async () => {
-		const session = createSession(discoverableTools);
-		const tool = new SearchToolBm25Tool(session);
-
-		const firstResult = await tool.execute("call-1", { query: "github issue", limit: 1 });
-		const firstDetails = firstResult.details;
-		expect(firstDetails?.tools.map(match => match.name)).toEqual(["mcp__github_create_issue"]);
-		expect(firstDetails?.active_selected_tools).toEqual(["mcp__github_create_issue"]);
-		expect(session.getSelected()).toEqual(["mcp__github_create_issue"]);
-
-		const secondResult = await tool.execute("call-2", { query: "slack message", limit: 1 });
-		const secondDetails = secondResult.details;
-		expect(secondDetails?.tools.map(match => match.name)).toEqual(["mcp__slack_post_message"]);
-		expect(secondDetails?.active_selected_tools).toEqual(["mcp__github_create_issue", "mcp__slack_post_message"]);
-		expect(session.getSelected()).toEqual(["mcp__github_create_issue", "mcp__slack_post_message"]);
-	});
-
-	it("skips already-selected matches before applying limit", async () => {
-		const session = createSession(discoverableTools);
-		const tool = new SearchToolBm25Tool(session);
-
-		const firstResult = await tool.execute("call-github-1", { query: "github", limit: 1 });
-		expect(firstResult.details?.tools.map(match => match.name)).toEqual(["mcp__github_create_issue"]);
-		expect(firstResult.details?.activated_tools).toEqual(["mcp__github_create_issue"]);
-
-		const secondResult = await tool.execute("call-github-2", { query: "github", limit: 1 });
-		expect(secondResult.details?.tools.map(match => match.name)).toEqual(["mcp__github_list_pull_requests"]);
-		expect(secondResult.details?.activated_tools).toEqual(["mcp__github_list_pull_requests"]);
-		expect(secondResult.details?.active_selected_tools).toEqual([
-			"mcp__github_create_issue",
-			"mcp__github_list_pull_requests",
-		]);
-
-		const exhaustedResult = await tool.execute("call-github-3", { query: "github", limit: 1 });
-		expect(exhaustedResult.details?.tools).toEqual([]);
-		expect(exhaustedResult.details?.activated_tools).toEqual([]);
-		expect(exhaustedResult.details?.active_selected_tools).toEqual([
-			"mcp__github_create_issue",
-			"mcp__github_list_pull_requests",
-		]);
-	});
-
-	it("rejects invalid input", async () => {
-		const tool = new SearchToolBm25Tool(createSession(discoverableTools));
-
-		await expect(tool.execute("call-empty", { query: "   " })).rejects.toThrow(
-			"Query is required and must not be empty.",
-		);
-		await expect(tool.execute("call-limit", { query: "github", limit: 0 as never })).rejects.toThrow(
-			"Limit must be a positive integer.",
-		);
-	});
-
-	it("rejects execution when discovery mode is disabled", async () => {
-		const tool = new SearchToolBm25Tool(
-			createSession(discoverableTools, {
-				isMCPDiscoveryEnabled: () => false,
-				settings: Settings.isolated({ "mcp.discoveryMode": false }),
-			}),
-		);
-
-		await expect(tool.execute("call-disabled", { query: "github" })).rejects.toThrow("Tool discovery is disabled.");
-	});
-
-	it("discovers built-in tools when using the new tools.discoveryMode=all setting", async () => {
-		const builtinTools: DiscoverableTool[] = [
-			builtinTool("glob", "Find files and directories matching a glob pattern"),
-			builtinTool("grep", "Search file contents using ripgrep"),
-		];
-		const allTools = [...discoverableTools, ...builtinTools];
-		const session = createSession(discoverableTools, {
-			settings: Settings.isolated({ "tools.discoveryMode": "all" }),
-			getDiscoverableTools: () => allTools,
-		});
-		const tool = new SearchToolBm25Tool(session);
-
-		const result = await tool.execute("call-builtin", { query: "find files" });
-		const names = result.details?.tools.map(t => t.name) ?? [];
-		expect(names).toContain("glob");
-	});
-});
-
-describe("renderSearchToolBm25Description", () => {
-	function lineWith(rendered: string, prefix: string): string | undefined {
-		return rendered.split("\n").find(line => line.startsWith(prefix));
-	}
-
-	it("lists discoverable built-in tool names alphabetically without leaking them into the MCP server line", () => {
-		const rendered = renderSearchToolBm25Description([
-			builtinTool("write", "Create or overwrite a file"),
-			builtinTool("glob", "Find files by name"),
-			builtinTool("grep", "Search file contents"),
-			mcpTool("mcp__github_create_issue", "github", "create_issue", "Create a GitHub issue", ["owner"]),
-			mcpTool("mcp__slack_post_message", "slack", "post_message", "Post a message to Slack", ["channel"]),
-		]);
-
-		// Built-in names are present verbatim, alphabetically ordered, on their own line.
-		expect(lineWith(rendered, "Discoverable built-in tools:")).toBe(
-			"Discoverable built-in tools: glob, grep, write.",
-		);
-
-		// Built-in names must not bleed into the MCP server-summary line.
-		const mcpLine = lineWith(rendered, "Discoverable MCP servers");
-		expect(mcpLine).toBe("Discoverable MCP servers in this session: github (1 tool), slack (1 tool).");
-		expect(mcpLine).not.toContain("write");
-		expect(mcpLine).not.toContain("glob");
-		expect(rendered).toContain(
-			"Discoverable MCP servers in this session: github (1 tool), slack (1 tool).\n" +
-				"Discoverable built-in tools: glob, grep, write.\n" +
-				"Total discoverable tools available: 5.",
-		);
-	});
-
-	it("omits the built-in line when the corpus has no built-ins (mcp-only mode)", () => {
-		const rendered = renderSearchToolBm25Description([
-			mcpTool("mcp__github_create_issue", "github", "create_issue", "Create a GitHub issue", ["owner"]),
-		]);
-
-		expect(rendered).not.toContain("Discoverable built-in tools:");
-		expect(rendered).toContain(
-			"Discoverable MCP servers in this session: github (1 tool).\nTotal discoverable tools available: 1.",
-		);
-	});
-
-	it("keeps built-ins counted in the total discoverable tools line", () => {
-		const rendered = renderSearchToolBm25Description([
-			builtinTool("write", "Create or overwrite a file"),
-			builtinTool("glob", "Find files by name"),
-			mcpTool("mcp__slack_post_message", "slack", "post_message", "Post a message to Slack", ["channel"]),
-		]);
-
-		expect(rendered).toContain("Total discoverable tools available: 3.");
-	});
-});
diff --git a/packages/coding-agent/test/tools/search-url-paths.test.ts b/packages/coding-agent/test/tools/search-url-paths.test.ts
index cd0f197b3..ca81898e0 100644
--- a/packages/coding-agent/test/tools/search-url-paths.test.ts
+++ b/packages/coding-agent/test/tools/search-url-paths.test.ts
@@ -21,7 +21,14 @@ function createSession(testDir: string): ToolSession {
 			const id = String(nextArtifactId++);
 			return { id, path: path.join(artifactsDir, `${id}.${toolType}.log`) };
 		},
-		settings: Settings.isolated({ "fetch.enabled": true, "grep.contextBefore": 0, "grep.contextAfter": 0 }),
+		settings: Settings.isolated({
+			"fetch.enabled": true,
+			"grep.contextBefore": 0,
+			"grep.contextAfter": 0,
+			"astGrep.enabled": true,
+			"astEdit.enabled": true,
+			"tools.xdev": false,
+		}),
 	};
 }
 
diff --git a/packages/coding-agent/test/tools/ssh-commit-stability.test.ts b/packages/coding-agent/test/tools/ssh-commit-stability.test.ts
deleted file mode 100644
index 6f115b57c..000000000
--- a/packages/coding-agent/test/tools/ssh-commit-stability.test.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import { beforeAll, describe, expect, it } from "bun:test";
-import { resetSettingsForTest, Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
-import { ToolExecutionComponent } from "@oh-my-pi/pi-coding-agent/modes/components/tool-execution";
-import { initTheme } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
-import type { TUI } from "@oh-my-pi/pi-tui";
-
-const uiStub = { requestRender() {}, requestComponentRender() {}, resetDisplay() {} } as unknown as TUI;
-
-function makeSshComponent() {
-	return new ToolExecutionComponent("ssh", { host: "sccpu", command: "uptime" }, {}, undefined, uiStub);
-}
-
-function result(text: string) {
-	return { content: [{ type: "text" as const, text }] };
-}
-
-function expectLive(component: ToolExecutionComponent): void {
-	expect(component.isTranscriptBlockFinalized()).toBe(false);
-	expect(component.getNativeScrollbackLiveRegionStart()).toBe(0);
-}
-
-function expectFinal(component: ToolExecutionComponent): void {
-	expect(component.isTranscriptBlockFinalized()).toBe(true);
-	expect(component.getNativeScrollbackLiveRegionStart()).toBeUndefined();
-}
-
-describe("ssh tool transcript finalization", () => {
-	beforeAll(async () => {
-		resetSettingsForTest();
-		await Settings.init({ inMemory: true });
-		await initTheme();
-	});
-
-	it("keeps partial SSH results in the native-scrollback live region", () => {
-		const component = makeSshComponent();
-
-		component.updateResult(result("connecting…"), true);
-
-		expectLive(component);
-	});
-
-	it("keeps pending SSH previews in the live region before a result arrives", () => {
-		for (const expanded of [false, true]) {
-			const component = makeSshComponent();
-			component.setExpanded(expanded);
-			component.setArgsComplete();
-
-			expectLive(component);
-		}
-	});
-
-	it("moves the block out of the live region as soon as the SSH result settles", () => {
-		const component = makeSshComponent();
-		component.updateResult(result("connecting…"), true);
-		expectLive(component);
-
-		component.updateResult(result("done\n"), false);
-
-		expectFinal(component);
-	});
-});
diff --git a/packages/coding-agent/test/tools/ssh-description.test.ts b/packages/coding-agent/test/tools/ssh-description.test.ts
deleted file mode 100644
index e46b5bb10..000000000
--- a/packages/coding-agent/test/tools/ssh-description.test.ts
+++ /dev/null
@@ -1,135 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "bun:test";
-import type { SSHHost } from "@oh-my-pi/pi-coding-agent/capability/ssh";
-import type { SourceMeta } from "@oh-my-pi/pi-coding-agent/capability/types";
-import * as discovery from "@oh-my-pi/pi-coding-agent/discovery";
-import type { SSHHostInfo } from "@oh-my-pi/pi-coding-agent/ssh/connection-manager";
-import * as connectionManager from "@oh-my-pi/pi-coding-agent/ssh/connection-manager";
-import * as sshExecutor from "@oh-my-pi/pi-coding-agent/ssh/ssh-executor";
-import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
-import { loadSshTool } from "@oh-my-pi/pi-coding-agent/tools/ssh";
-
-const SOURCE: SourceMeta = {
-	provider: "test",
-	providerName: "Test",
-	path: "/dev/null",
-	level: "user",
-};
-
-// Unique names so no persisted host-info cache file can exist for them.
-const RUN_ID = `${Date.now()}-${process.pid}`;
-const HOST_A: SSHHost = { name: `a-omp-test-${RUN_ID}`, host: "alpha.example.com", _source: SOURCE };
-const HOST_B: SSHHost = { name: `b-omp-test-${RUN_ID}`, host: "beta.example.com", _source: SOURCE };
-const LINUX_BASH_INFO: SSHHostInfo = { version: 4, os: "linux", shell: "bash", compatEnabled: false };
-const WINDOWS_CMD_INFO: SSHHostInfo = { version: 4, os: "windows", shell: "cmd", compatEnabled: false };
-
-function mockHosts(hosts: SSHHost[]): void {
-	vi.spyOn(discovery, "loadCapability").mockResolvedValue({
-		items: hosts,
-		all: hosts,
-		warnings: [],
-		providers: ["test"],
-	});
-}
-
-function createSession(): ToolSession {
-	return { cwd: "/tmp" } as unknown as ToolSession;
-}
-
-async function loadTestTool(hosts: SSHHost[] = [HOST_A]) {
-	mockHosts(hosts);
-	const tool = await loadSshTool(createSession());
-	if (!tool) {
-		throw new Error("expected SSH tool");
-	}
-	return tool;
-}
-
-function stubSshExecute() {
-	return vi.spyOn(sshExecutor, "executeSSH").mockResolvedValue({
-		output: "ok",
-		exitCode: 0,
-		cancelled: false,
-		truncated: false,
-		totalLines: 1,
-		totalBytes: 2,
-		outputLines: 1,
-		outputBytes: 2,
-	});
-}
-
-function stubSshRun(info: SSHHostInfo) {
-	vi.spyOn(connectionManager, "ensureHostInfo").mockResolvedValue(info);
-	return stubSshExecute();
-}
-
-describe("loadSshTool description", () => {
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it("returns null when no hosts are configured", async () => {
-		mockHosts([]);
-		expect(await loadSshTool(createSession())).toBeNull();
-	});
-
-	it("renders uncached hosts with the detecting placeholder, sorted by name, without probing", async () => {
-		mockHosts([HOST_B, HOST_A]);
-		const tool = await loadSshTool(createSession());
-		expect(tool).not.toBeNull();
-		expect(tool?.description.startsWith("Runs commands on remote hosts.")).toBe(true);
-		expect(tool?.description).toContain("NEVER use `~` or `~/…`");
-		expect(
-			tool?.description.endsWith(
-				`\n\nAvailable hosts:\n- ${HOST_A.name} (${HOST_A.host}) | detecting...\n- ${HOST_B.name} (${HOST_B.host}) | detecting...`,
-			),
-		).toBe(true);
-	});
-});
-
-describe("SshTool cwd handling", () => {
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it("rejects tilde cwd values before probing or executing the host", async () => {
-		const ensureSpy = vi.spyOn(connectionManager, "ensureHostInfo").mockResolvedValue(LINUX_BASH_INFO);
-		const executeSpy = stubSshExecute();
-		const tool = await loadTestTool();
-
-		await expect(tool.execute("call-tilde", { host: HOST_A.name, command: "pwd", cwd: "~" })).rejects.toThrow(
-			"SSH cwd must be an absolute remote path",
-		);
-		await expect(
-			tool.execute("call-tilde-path", { host: HOST_A.name, command: "pwd", cwd: "~/src" }),
-		).rejects.toThrow("SSH cwd must be an absolute remote path");
-
-		expect(ensureSpy).not.toHaveBeenCalled();
-		expect(executeSpy).not.toHaveBeenCalled();
-	});
-
-	it("quotes valid POSIX absolute cwd values in the remote command", async () => {
-		const executeSpy = stubSshRun(LINUX_BASH_INFO);
-		const tool = await loadTestTool();
-
-		await tool.execute("call-absolute", { host: HOST_A.name, command: "pwd", cwd: "/srv/app" });
-
-		expect(executeSpy).toHaveBeenCalledWith(
-			HOST_A,
-			"cd -- '/srv/app' && pwd",
-			expect.objectContaining({ compatEnabled: false, timeout: 60000 }),
-		);
-	});
-
-	it("preserves native Windows cwd command generation", async () => {
-		const executeSpy = stubSshRun(WINDOWS_CMD_INFO);
-		const tool = await loadTestTool();
-
-		await tool.execute("call-windows", { host: HOST_A.name, command: "dir", cwd: "C:\\Users\\me" });
-
-		expect(executeSpy).toHaveBeenCalledWith(
-			HOST_A,
-			'cd /d "C:\\Users\\me" && dir',
-			expect.objectContaining({ compatEnabled: false, timeout: 60000 }),
-		);
-	});
-});
diff --git a/packages/coding-agent/test/tools/ssh-render.test.ts b/packages/coding-agent/test/tools/ssh-render.test.ts
deleted file mode 100644
index 438d292bb..000000000
--- a/packages/coding-agent/test/tools/ssh-render.test.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-import { beforeAll, describe, expect, it } from "bun:test";
-import { getThemeByName, initTheme } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
-import { previewWindowRows } from "@oh-my-pi/pi-coding-agent/tools/render-utils";
-import { sshToolRenderer } from "@oh-my-pi/pi-coding-agent/tools/ssh";
-import { sanitizeText } from "@oh-my-pi/pi-utils";
-
-beforeAll(async () => {
-	await initTheme();
-});
-
-describe("sshToolRenderer", () => {
-	it("keeps the status header on one line when the command spans multiple lines", async () => {
-		const uiTheme = (await getThemeByName("dark"))!;
-		expect(uiTheme).toBeDefined();
-		const command = ["set -e", "cat > /etc/apt/sources.list <<'EOF'", "# mirrors", "EOF"].join("\n");
-		const component = sshToolRenderer.renderResult(
-			{ content: [{ type: "text", text: "" }] },
-			{ expanded: false, isPartial: false },
-			uiTheme,
-			{ host: "router", command },
-		);
-		const rendered = component.render(120);
-		const sanitized = rendered.map(line => sanitizeText(line));
-		// First visible row is the status header, and it MUST remain a single line.
-		// It carries the host but NOT the command — the command lives in the body.
-		const header = sanitized[0]!;
-		expect(header).toContain("SSH");
-		expect(header).toContain("[router]");
-		expect(header).not.toContain("set -e");
-		expect(header).not.toContain("EOF");
-		// Every command line still appears, inside the framed body.
-		const body = sanitized.slice(1).join("\n");
-		expect(body).toContain("$ set -e");
-		expect(body).toContain("cat > /etc/apt/sources.list <<'EOF'");
-		expect(body).toContain("# mirrors");
-		expect(body).toContain("EOF");
-	});
-
-	it("keeps the pending-call header on one line for multiline commands", async () => {
-		const uiTheme = (await getThemeByName("dark"))!;
-		expect(uiTheme).toBeDefined();
-		const command = "set -e\ndo-something";
-		const component = sshToolRenderer.renderCall(
-			{ host: "router", command },
-			{ expanded: false, isPartial: true },
-			uiTheme,
-		);
-		const rendered = component.render(120);
-		const sanitized = rendered.map(line => sanitizeText(line));
-		const header = sanitized[0]!;
-		expect(header).toContain("SSH");
-		expect(header).toContain("[router]");
-		expect(header).not.toContain("set -e");
-		expect(header).not.toContain("do-something");
-		const body = sanitized.slice(1).join("\n");
-		expect(body).toContain("$ set -e");
-		expect(body).toContain("do-something");
-	});
-
-	it("keeps partial results pending until the final SSH result", async () => {
-		const uiTheme = (await getThemeByName("dark"))!;
-		expect(uiTheme).toBeDefined();
-		const renderHeader = (isPartial: boolean) =>
-			sanitizeText(
-				sshToolRenderer
-					.renderResult(
-						{ content: [{ type: "text", text: isPartial ? "streaming" : "done" }] },
-						{ expanded: false, isPartial },
-						uiTheme,
-						{ host: "sccpu", command: "uptime" },
-					)
-					.render(120)[0]!,
-			);
-
-		expect(renderHeader(true)).toContain("⏳ SSH: [sccpu]");
-		expect(renderHeader(false)).toContain("⇄ SSH: [sccpu]");
-	});
-	it("renders the collapsed command as a viewport tail window in every state — no stream→final expansion", async () => {
-		const uiTheme = (await getThemeByName("dark"))!;
-		expect(uiTheme).toBeDefined();
-		const total = previewWindowRows() + 5;
-		const command = Array.from({ length: total }, (_, i) => `step_${i}`).join("\n");
-		const render = (opts: { expanded: boolean; isPartial: boolean }) =>
-			sanitizeText(
-				sshToolRenderer
-					.renderResult({ content: [{ type: "text", text: "" }] }, opts, uiTheme, { host: "router", command })
-					.render(120)
-					.join("\n"),
-			);
-
-		// Identical tail window streaming and final: the end stays visible, the
-		// head is elided behind an "earlier lines" marker. Only ctrl+o uncaps.
-		for (const rendered of [
-			render({ expanded: false, isPartial: true }),
-			render({ expanded: false, isPartial: false }),
-		]) {
-			expect(rendered).toContain(`step_${total - 1}`);
-			expect(rendered).toContain("earlier line");
-			expect(rendered).not.toContain("step_0");
-		}
-
-		const expandedFinal = render({ expanded: true, isPartial: false });
-		expect(expandedFinal).toContain("$ step_0");
-		expect(expandedFinal).not.toContain("earlier line");
-	});
-});
diff --git a/packages/coding-agent/test/write-streaming-preview-expand.test.ts b/packages/coding-agent/test/write-streaming-preview-expand.test.ts
index f0db92c08..e54f67969 100644
--- a/packages/coding-agent/test/write-streaming-preview-expand.test.ts
+++ b/packages/coding-agent/test/write-streaming-preview-expand.test.ts
@@ -89,6 +89,7 @@ describe("write streaming preview honors Ctrl+O expansion", () => {
 			options,
 			uiTheme!,
 		);
+		if (!component) throw new Error("expected a rendered component for a non-xdev write path");
 
 		component.render(80);
 		component.render(120);
@@ -108,6 +109,7 @@ describe("write streaming preview honors Ctrl+O expansion", () => {
 			{ expanded: true, isPartial: true, spinnerFrame: 0 },
 			uiTheme,
 		);
+		if (!component) throw new Error("expected a rendered component for a non-xdev write path");
 
 		const rendered = stripAnsi(component.render(120).join("\n"));
 		expect(rendered).toContain("object first");
diff --git a/packages/coding-agent/test/write-xdev-dispatch.test.ts b/packages/coding-agent/test/write-xdev-dispatch.test.ts
new file mode 100644
index 000000000..e491ca708
--- /dev/null
+++ b/packages/coding-agent/test/write-xdev-dispatch.test.ts
@@ -0,0 +1,108 @@
+import { describe, expect, it } from "bun:test";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
+import * as themeModule from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
+import { ToolChoiceQueue } from "@oh-my-pi/pi-coding-agent/session/tool-choice-queue";
+import { createTools, type ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
+import { writeToolRenderer } from "@oh-my-pi/pi-coding-agent/tools/write";
+import { removeWithRetries } from "@oh-my-pi/pi-utils";
+
+// xdev mounting is default-on: discoverable tools like ast_edit unmount into
+// xd://, and a plain `write xd://ast_edit` dispatches them. These guard the
+// resolution-device symbols write.ts pulls from ./resolve — a missing import
+// threw `ReferenceError: isResolutionDeviceName is not defined` on *every*
+// xd:// write, in both the executor (approval + execute) and the streaming
+// renderer (surfacing as the error text inside a generic Write frame).
+function xdevSession(cwd: string, overrides: Partial<ToolSession> = {}): ToolSession {
+	return {
+		cwd,
+		hasUI: true,
+		getSessionFile: () => null,
+		getSessionSpawns: () => "*",
+		settings: Settings.isolated({}),
+		...overrides,
+	};
+}
+
+describe("read and write route xd:// device URLs", () => {
+	it("lists, documents, and dispatches an ast_edit device", async () => {
+		const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "write-xdev-"));
+		try {
+			const filePath = path.join(tempDir, "legacy.ts");
+			await Bun.write(filePath, "legacyWrap(x, value)\n");
+			const queue = new ToolChoiceQueue();
+
+			const tools = await createTools(
+				xdevSession(tempDir, {
+					getToolChoiceQueue: () => queue,
+					buildToolChoice: () => ({ type: "tool" as const, name: "resolve" }),
+					steer: () => {},
+				}),
+			);
+			// xdev on: ast_edit is unmounted into xd://; write stays in the toolset.
+			const write = tools.find(entry => entry.name === "write");
+			const read = tools.find(entry => entry.name === "read");
+			expect(read).toBeDefined();
+			expect(write).toBeDefined();
+			expect(tools.some(entry => entry.name === "ast_edit")).toBe(false);
+
+			const listing = await read!.execute("read-xd-list", { path: "xd://" });
+			expect(listing.content.find(entry => entry.type === "text")?.text).toContain("xd://ast_edit");
+			const docs = await read!.execute("read-xd-docs", { path: "xd://ast_edit" });
+			expect(docs.content.find(entry => entry.type === "text")?.text).toContain("# ast_edit");
+
+			const content = JSON.stringify({
+				ops: [{ pat: "legacyWrap($A, $B)", out: "modernWrap($A, $B)" }],
+				paths: [filePath],
+			});
+
+			// Approval resolves a tier instead of throwing. A mounted tool whose own
+			// approval is a function (unresolvable statically) falls back to exec.
+			const approval = write!.approval;
+			expect(typeof approval).toBe("function");
+			if (typeof approval === "function") {
+				expect(approval({ path: "xd://ast_edit", content })).toBe("exec");
+			}
+
+			// Execute dispatches through the xdev registry to the mounted ast_edit,
+			// staging a preview (not a direct apply).
+			const previewResult = await write!.execute("write-xdev-preview", { path: "xd://ast_edit", content });
+			expect(previewResult.isError).toBeUndefined();
+			expect(previewResult.details?.xdev?.tool).toBe("ast_edit");
+			expect(previewResult.details?.xdev?.mode).toBe("execute");
+			const previewText = previewResult.content.find(entry => entry.type === "text")?.text ?? "";
+			expect(previewText).toContain("modernWrap");
+
+			// The staged preview applies through the resolve queue and rewrites disk.
+			const invoker = queue.peekPendingInvoker();
+			expect(invoker).toBeDefined();
+			await invoker!({ action: "apply", reason: "apply xdev ast edit" });
+			expect(await Bun.file(filePath).text()).toContain("modernWrap(x, value)");
+		} finally {
+			await removeWithRetries(tempDir);
+		}
+	});
+
+	it("renderCall withholds a partial xd:// URL, then delegates once settled", async () => {
+		await themeModule.initTheme();
+		const uiTheme = (await themeModule.getThemeByName("dark")) ?? (await themeModule.getThemeByName("light"));
+		if (!uiTheme) throw new Error("expected an initialized theme");
+		const options = { expanded: false, isPartial: true };
+
+		const content = JSON.stringify({
+			ops: [{ pat: "legacyWrap($A, $B)", out: "modernWrap($A, $B)" }],
+			paths: ["/tmp/legacy.ts"],
+		});
+
+		// Path still streaming (no content field yet): render nothing so the user
+		// never sees a half-typed "xd://ast_" frame.
+		expect(writeToolRenderer.renderCall({ path: "xd://ast_e" }, options, uiTheme)).toBeUndefined();
+
+		// Path settled + content streaming: delegate to the mounted tool's renderer
+		// instead of throwing ReferenceError inside a generic Write frame.
+		const rendered = writeToolRenderer.renderCall({ path: "xd://ast_edit", content }, options, uiTheme);
+		expect(rendered).toBeDefined();
+	});
+});
diff --git a/packages/collab-web/CHANGELOG.md b/packages/collab-web/CHANGELOG.md
index 642dcee90..1da2b59c3 100644
--- a/packages/collab-web/CHANGELOG.md
+++ b/packages/collab-web/CHANGELOG.md
@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+### Changed
+
+- Replaced the `irc`/`job` tool renderers (and their legacy `await`/`poll`/`cancel_job` aliases) with a single `hub` renderer that dispatches per op family — messaging, background jobs, and process supervision — keeping the existing irc/job visuals.
+- Collab-web renders successful `xd://` device dispatches through the inner tool's renderer: a `write` result carrying `details.xdev` (execute mode) resolves the renderer by `xdev.tool`, uses `xdev.args`, and swaps in `xdev.inner` as details, with the card labeled `xd://<tool>` (preserves generated-image thumbnails and MCP/autoresearch presentation).
+
+### Removed
+
+- Removed custom visualization for `search_tool_bm25` tool; falls back to generic rendering
+
 ## [16.5.1] - 2026-07-14
 
 ### Fixed
diff --git a/packages/collab-web/src/tool-render/ToolView.tsx b/packages/collab-web/src/tool-render/ToolView.tsx
index 843ffaf81..220126bed 100644
--- a/packages/collab-web/src/tool-render/ToolView.tsx
+++ b/packages/collab-web/src/tool-render/ToolView.tsx
@@ -36,15 +36,33 @@ function normalizeArgs(raw: unknown): { args: Record<string, unknown>; intent: s
 	return { args, intent };
 }
 
+interface XdevDispatch {
+	tool: string;
+	args: Record<string, unknown>;
+	inner: unknown;
+}
+
+function executeXdevDispatch(props: ToolViewProps): XdevDispatch | null {
+	if (props.name !== "write" || props.result?.isError === true || !isRecord(props.result?.details)) return null;
+	const xdev = props.result.details.xdev;
+	if (!isRecord(xdev) || xdev.mode !== "execute" || typeof xdev.tool !== "string") return null;
+	return { tool: xdev.tool, args: isRecord(xdev.args) ? xdev.args : {}, inner: xdev.inner };
+}
+
 export function ToolView(props: ToolViewProps): ReactNode {
 	const [open, setOpen] = useState(props.defaultOpen ?? false);
+	const xdev = executeXdevDispatch(props);
 	const { args, intent: argIntent } = normalizeArgs(props.args);
 	const intent = props.intent?.trim() || argIntent;
-	const renderer = resolveToolRenderer(props.name);
+	const name = xdev?.tool ?? props.name;
+	const result = xdev
+		? { content: props.result!.content, details: xdev.inner, isError: props.result!.isError }
+		: props.result;
+	const renderer = resolveToolRenderer(name);
 	const renderProps: ToolRenderProps = {
-		name: props.name,
-		args,
-		result: props.result,
+		name,
+		args: xdev?.args ?? args,
+		result,
 		running: props.running,
 		host: props.host,
 	};
@@ -67,7 +85,7 @@ export function ToolView(props: ToolViewProps): ReactNode {
 				) : (
 					<span className={`tv-status tv-status--${status}`} aria-hidden="true" />
 				)}
-				<span className="tv-name">{props.name}</span>
+				<span className="tv-name">{xdev ? `xd://${name}` : name}</span>
 				<span className="tv-sum">
 					<renderer.Summary {...renderProps} />
 				</span>
diff --git a/packages/collab-web/src/tool-render/registry.ts b/packages/collab-web/src/tool-render/registry.ts
index a59ee1d87..518e734d7 100644
--- a/packages/collab-web/src/tool-render/registry.ts
+++ b/packages/collab-web/src/tool-render/registry.ts
@@ -17,19 +17,15 @@ import { githubRenderer } from "./tools/github";
 import { globRenderer } from "./tools/glob";
 import { goalRenderer } from "./tools/goal";
 import { grepRenderer } from "./tools/grep";
+import { hubRenderer } from "./tools/hub";
 import { inspectImageRenderer } from "./tools/inspect-image";
-import { ircRenderer } from "./tools/irc";
-import { jobRenderer } from "./tools/job";
 import { lspRenderer } from "./tools/lsp";
 import { recallRenderer } from "./tools/memory-recall";
 import { reflectRenderer } from "./tools/memory-reflect";
 import { retainRenderer } from "./tools/memory-retain";
 import { readRenderer } from "./tools/read";
-import { reportFindingRenderer } from "./tools/report-finding";
 import { reportToolIssueRenderer } from "./tools/report-tool-issue";
 import { resolveRenderer } from "./tools/resolve";
-import { searchBm25Renderer } from "./tools/search-bm25";
-import { sshRenderer } from "./tools/ssh";
 import { taskRenderer } from "./tools/task";
 import { todoRenderer } from "./tools/todo";
 import { webSearchRenderer } from "./tools/web-search";
@@ -58,23 +54,16 @@ const RENDERERS: Record<string, ToolRenderer> = {
 	github: githubRenderer,
 	goal: goalRenderer,
 	inspect_image: inspectImageRenderer,
-	irc: ircRenderer,
-	job: jobRenderer,
-	await: jobRenderer,
-	poll: jobRenderer,
-	cancel_job: jobRenderer,
+	hub: hubRenderer,
 	lsp: lspRenderer,
 	recall: recallRenderer,
 	reflect: reflectRenderer,
 	retain: retainRenderer,
 	read: readRenderer,
-	report_finding: reportFindingRenderer,
 	report_tool_issue: reportToolIssueRenderer,
 	resolve: resolveRenderer,
 	grep: grepRenderer,
 	search: grepRenderer,
-	search_tool_bm25: searchBm25Renderer,
-	ssh: sshRenderer,
 	task: taskRenderer,
 	todo: todoRenderer,
 	web_search: webSearchRenderer,
diff --git a/packages/collab-web/src/tool-render/tools/hub.tsx b/packages/collab-web/src/tool-render/tools/hub.tsx
new file mode 100644
index 000000000..2502e62d9
--- /dev/null
+++ b/packages/collab-web/src/tool-render/tools/hub.tsx
@@ -0,0 +1,84 @@
+/**
+ * `hub` — merged agent-coordination surface: peer messaging (irc rendering),
+ * background jobs (job rendering), and process supervision (generic rendering,
+ * matching the pre-merge launch tool). Dispatches per op family so each
+ * result keeps its original look.
+ */
+import type { ReactNode } from "react";
+import { genericRenderer } from "../generic";
+import type { ToolRenderer, ToolRenderProps } from "../types";
+import { detailsRecord } from "../util";
+import { ircRenderer } from "./irc";
+import { jobRenderer } from "./job";
+
+const LAUNCH_OPS = new Set(["start", "ps", "logs", "stop", "restart", "describe"]);
+
+type Family = "launch" | "jobs" | "messaging";
+
+/** Results dispatch on what actually happened; calls fall back to the arg shape. */
+function familyOf({ args, result }: ToolRenderProps): Family {
+	const details = detailsRecord(result);
+	if (details) {
+		// `state`/`cursor` cover logs results, which may carry neither a daemon
+		// snapshot nor terminal rows; coordination details never define these keys.
+		if (
+			"daemon" in details ||
+			"daemons" in details ||
+			"terminalRows" in details ||
+			"spec" in details ||
+			"state" in details ||
+			"cursor" in details
+		) {
+			return "launch";
+		}
+		if (Array.isArray(details.jobs) || Array.isArray(details.agents)) return "jobs";
+		if ("receipts" in details || "waited" in details || "inbox" in details || "peers" in details) {
+			return "messaging";
+		}
+	}
+	const op = typeof args.op === "string" ? args.op : "";
+	if (LAUNCH_OPS.has(op)) return "launch";
+	const name = typeof args.name === "string" && args.name.length > 0;
+	const to = typeof args.to === "string" && args.to.length > 0;
+	const from = typeof args.from === "string" && args.from.length > 0;
+	if ((op === "send" || op === "wait") && name && !to && !from) return "launch";
+	if (op === "jobs" || op === "cancel") return "jobs";
+	if (op === "wait" && !from) return "jobs";
+	return "messaging";
+}
+
+/** Hub args → legacy job-renderer arg shape (`poll`/`cancel`/`list`). */
+function toJobProps(props: ToolRenderProps): ToolRenderProps {
+	const op = typeof props.args.op === "string" ? props.args.op : "";
+	const args: Record<string, unknown> =
+		op === "cancel" ? { cancel: props.args.ids } : op === "jobs" ? { list: true } : { poll: props.args.ids };
+	return { ...props, args };
+}
+
+function Summary(props: ToolRenderProps): ReactNode {
+	switch (familyOf(props)) {
+		case "launch":
+			return <genericRenderer.Summary {...props} />;
+		case "jobs": {
+			const jobProps = toJobProps(props);
+			return <jobRenderer.Summary {...jobProps} />;
+		}
+		default:
+			return <ircRenderer.Summary {...props} />;
+	}
+}
+
+function Body(props: ToolRenderProps): ReactNode {
+	switch (familyOf(props)) {
+		case "launch":
+			return genericRenderer.Body ? <genericRenderer.Body {...props} /> : null;
+		case "jobs": {
+			const jobProps = toJobProps(props);
+			return jobRenderer.Body ? <jobRenderer.Body {...jobProps} /> : null;
+		}
+		default:
+			return ircRenderer.Body ? <ircRenderer.Body {...props} /> : null;
+	}
+}
+
+export const hubRenderer: ToolRenderer = { Summary, Body };
diff --git a/packages/collab-web/src/tool-render/tools/report-finding.tsx b/packages/collab-web/src/tool-render/tools/report-finding.tsx
deleted file mode 100644
index 08c7077c9..000000000
--- a/packages/collab-web/src/tool-render/tools/report-finding.tsx
+++ /dev/null
@@ -1,54 +0,0 @@
-/** `report_finding` — a structured code-review finding from a reviewer agent. */
-import type { ReactNode } from "react";
-import type { Tone } from "../parts";
-import { Badge, Badges, Output, PathText, ResultText } from "../parts";
-import type { ToolRenderer, ToolRenderProps } from "../types";
-import { num, str, truncate } from "../util";
-
-function priorityTone(priority: string): Tone | undefined {
-	switch (priority) {
-		case "P0":
-			return "err";
-		case "P1":
-			return "warn";
-		case "P3":
-			return "accent";
-		default:
-			return undefined;
-	}
-}
-
-function Summary({ args }: ToolRenderProps): ReactNode {
-	const priority = str(args.priority);
-	const title = str(args.title);
-	return (
-		<>
-			{priority && <Badge tone={priorityTone(priority)}>{priority}</Badge>}
-			{title && <span> {truncate(title.replace(/^\[P\d\]\s*/, ""), 80)}</span>}
-		</>
-	);
-}
-
-function Body({ args, result }: ToolRenderProps): ReactNode {
-	const priority = str(args.priority);
-	const confidence = num(args.confidence);
-	const filePath = str(args.file_path);
-	const lineStart = num(args.line_start);
-	const lineEnd = num(args.line_end);
-	const body = str(args.body);
-	return (
-		<>
-			<Badges
-				items={[
-					priority && <Badge tone={priorityTone(priority)}>{priority}</Badge>,
-					confidence !== null && <Badge>confidence {(confidence * 100).toFixed(0)}%</Badge>,
-					filePath && <PathText path={filePath} from={lineStart ?? undefined} to={lineEnd ?? undefined} />,
-				]}
-			/>
-			{body && <Output text={body} maxLines={12} />}
-			{result?.isError && <ResultText result={result} maxLines={6} />}
-		</>
-	);
-}
-
-export const reportFindingRenderer: ToolRenderer = { Summary, Body };
diff --git a/packages/collab-web/src/tool-render/tools/search-bm25.tsx b/packages/collab-web/src/tool-render/tools/search-bm25.tsx
deleted file mode 100644
index 67ac45a47..000000000
--- a/packages/collab-web/src/tool-render/tools/search-bm25.tsx
+++ /dev/null
@@ -1,118 +0,0 @@
-/** `search_tool_bm25` — BM25 tool discovery: query in, ranked tool matches out. */
-import type { ReactNode } from "react";
-import { Badge, Badges, InvalidArg, Kv, KvGrid, Note, ResultText, Row } from "../parts";
-import type { ToolRenderer, ToolRenderProps } from "../types";
-import { detailsRecord, isRecord, normalizeWs, num, str, truncate } from "../util";
-
-interface Bm25Match {
-	name: string;
-	label: string;
-	description: string;
-	serverName: string | null;
-	score: number | null;
-}
-
-function matchOf(value: unknown): Bm25Match | null {
-	if (!isRecord(value)) return null;
-	const name = str(value.name) ?? "";
-	const label = str(value.label) ?? name;
-	if (!label) return null;
-	return {
-		name,
-		label,
-		description: str(value.description) ?? "",
-		serverName: str(value.server_name),
-		score: num(value.score),
-	};
-}
-
-function strList(value: unknown): string[] {
-	if (!Array.isArray(value)) return [];
-	const out: string[] = [];
-	for (const item of value) {
-		if (typeof item === "string" && item) out.push(item);
-	}
-	return out;
-}
-
-function Summary({ args, result }: ToolRenderProps): ReactNode {
-	const query = str(args.query);
-	const limit = num(args.limit);
-	const details = detailsRecord(result);
-	const tools = details && Array.isArray(details.tools) ? details.tools : null;
-	return (
-		<>
-			{query !== null ? (
-				<span className="tv-pattern">{truncate(normalizeWs(query), 64) || "(empty query)"}</span>
-			) : (
-				<InvalidArg what="query" />
-			)}
-			{limit !== null && <Badge>limit:{limit}</Badge>}
-			{tools && (
-				<Badge tone={tools.length > 0 ? "ok" : "warn"}>
-					{tools.length} match{tools.length === 1 ? "" : "es"}
-				</Badge>
-			)}
-		</>
-	);
-}
-
-function Body({ args, result }: ToolRenderProps): ReactNode {
-	const details = detailsRecord(result);
-	const query = str(details?.query) ?? str(args.query);
-	const limit = num(details?.limit) ?? num(args.limit);
-	const totalTools = num(details?.total_tools);
-	const activated = strList(details?.activated_tools);
-	const activeSelected = strList(details?.active_selected_tools);
-	const matches: Bm25Match[] = [];
-	if (details && Array.isArray(details.tools)) {
-		for (const item of details.tools) {
-			const match = matchOf(item);
-			if (match) matches.push(match);
-		}
-	}
-	return (
-		<>
-			<KvGrid>
-				<Kv k="query">
-					{query !== null ? <span className="tv-pattern">{query}</span> : <InvalidArg what="query" />}
-				</Kv>
-				{limit !== null && <Kv k="limit">{limit}</Kv>}
-				{details && (
-					<Kv k="tools">
-						{matches.length} matched
-						{activeSelected.length > 0 && ` · ${activeSelected.length} active`}
-						{totalTools !== null && ` · ${totalTools} total`}
-					</Kv>
-				)}
-				{activated.length > 0 && (
-					<Kv k="activated">
-						<Badges items={activated} />
-					</Kv>
-				)}
-			</KvGrid>
-			{details && !result?.isError && matches.length === 0 && (
-				<Note tone="warn">
-					{totalTools === 0 ? "No discoverable tools are currently loaded." : "No matching tools found."}
-				</Note>
-			)}
-			{matches.length > 0 && (
-				<div className="tv-list">
-					{matches.map((match, i) => (
-						<Row key={i} k={match.score !== null ? match.score.toFixed(3) : undefined}>
-							<span className="tv-pattern">{match.label}</span>
-							{match.serverName && <Badge>{match.serverName}</Badge>}
-							{match.name && match.name !== match.label && <span className="tv-faint"> {match.name}</span>}
-							{match.description && (
-								<span className="tv-muted"> — {truncate(normalizeWs(match.description), 140)}</span>
-							)}
-						</Row>
-					))}
-				</div>
-			)}
-			{(!details || result?.isError) && <ResultText result={result} maxLines={10} />}
-		</>
-	);
-}
-
-export const searchBm25Renderer: ToolRenderer = { Summary, Body };
diff --git a/packages/collab-web/src/tool-render/tools/ssh.tsx b/packages/collab-web/src/tool-render/tools/ssh.tsx
deleted file mode 100644
index 626b22bce..000000000
--- a/packages/collab-web/src/tool-render/tools/ssh.tsx
+++ /dev/null
@@ -1,104 +0,0 @@
-/** `ssh` — remote command execution on a configured SSH host. */
-import type { ReactNode } from "react";
-import { Badge, Badges, InvalidArg, Note, Output, ResultText } from "../parts";
-import type { ToolRenderer, ToolRenderProps } from "../types";
-import {
-	detailsRecord,
-	isRecord,
-	normalizeWs,
-	num,
-	replaceTabs,
-	resultTextOf,
-	shortenPath,
-	str,
-	truncate,
-} from "../util";
-
-/** Subset of the coding-agent `TruncationMeta` we surface. */
-interface TruncationInfo {
-	totalLines: number | null;
-	outputLines: number | null;
-	artifactId: string | null;
-}
-
-function truncationOf(result: ToolRenderProps["result"]): TruncationInfo | null {
-	const meta = detailsRecord(result)?.meta;
-	if (!isRecord(meta) || !isRecord(meta.truncation)) return null;
-	const t = meta.truncation;
-	return {
-		totalLines: num(t.totalLines),
-		outputLines: num(t.outputLines),
-		artifactId: str(t.artifactId),
-	};
-}
-
-/**
- * The tool wrapper bakes a trailing `[Showing lines …]` notice into the
- * LLM-facing text. Like the TUI, drop it when we render our own styled
- * truncation note. Only called when truncation meta is present.
- */
-function stripTruncationNotice(text: string): string {
-	const trimmed = text.trimEnd();
-	if (!trimmed.endsWith("]")) return trimmed;
-	const idx = trimmed.lastIndexOf("\n[Showing ");
-	if (idx >= 0) return trimmed.slice(0, idx).trimEnd();
-	return trimmed.startsWith("[Showing ") && !trimmed.includes("\n") ? "" : trimmed;
-}
-
-function Summary({ args }: ToolRenderProps): ReactNode {
-	const host = str(args.host);
-	const command = str(args.command);
-	return (
-		<>
-			<Badge tone="accent">{host ?? "…"}</Badge>{" "}
-			{command !== null
-				? truncate(normalizeWs(command), 80)
-				: args.command !== undefined && <InvalidArg what="command" />}
-		</>
-	);
-}
-
-function Body({ args, result }: ToolRenderProps): ReactNode {
-	const host = str(args.host);
-	const command = str(args.command);
-	const cwd = str(args.cwd);
-	const timeout = num(args.timeout);
-	const trunc = truncationOf(result);
-	const stripped =
-		trunc !== null && result?.isError !== true ? stripTruncationNotice(resultTextOf(result).trim()) : null;
-	return (
-		<>
-			<Badges
-				items={[
-					host !== null ? <Badge tone="accent">{host}</Badge> : <InvalidArg what="host" />,
-					cwd !== null && <Badge>cwd {shortenPath(cwd)}</Badge>,
-					timeout !== null && <Badge>timeout {timeout}s</Badge>,
-				]}
-			/>
-			{command !== null ? (
-				<div className="tv-cmd">
-					<span className="tv-cmd-prompt">$</span>
-					<span className="tv-cmd-text">{replaceTabs(command)}</span>
-				</div>
-			) : (
-				<InvalidArg what="command" />
-			)}
-			{stripped !== null ? (
-				stripped !== "" && <Output text={stripped} maxLines={12} />
-			) : (
-				<ResultText result={result} maxLines={12} />
-			)}
-			{trunc !== null && (
-				<Note tone="warn">
-					Output truncated
-					{trunc.outputLines !== null &&
-						trunc.totalLines !== null &&
-						` — showing ${trunc.outputLines} of ${trunc.totalLines} lines`}
-					{trunc.artifactId !== null && ` · full output at artifact://${trunc.artifactId}`}
-				</Note>
-			)}
-		</>
-	);
-}
-
-export const sshRenderer: ToolRenderer = { Summary, Body };
diff --git a/packages/collab-web/test/tool-view.test.tsx b/packages/collab-web/test/tool-view.test.tsx
new file mode 100644
index 000000000..8a6016427
--- /dev/null
+++ b/packages/collab-web/test/tool-view.test.tsx
@@ -0,0 +1,31 @@
+import { describe, expect, it } from "bun:test";
+import { renderToStaticMarkup } from "react-dom/server";
+import { ToolView } from "../src/tool-render/ToolView";
+
+describe("ToolView xd:// dispatches", () => {
+	it("renders successful execute-mode xdev writes as the inner generate_image tool", () => {
+		const html = renderToStaticMarkup(
+			<ToolView
+				name="write"
+				defaultOpen
+				result={{
+					content: [],
+					details: {
+						xdev: {
+							tool: "generate_image",
+							mode: "execute",
+							args: { subject: "alpine lake" },
+							inner: {
+								images: [{ data: "aW1hZ2U=", mimeType: "image/png" }],
+							},
+						},
+					},
+				}}
+			/>,
+		);
+
+		expect(html).toContain("xd://generate_image");
+		expect(html).toContain("alpine lake");
+		expect(html).toContain('src="data:image/png;base64,aW1hZ2U="');
+	});
+});
diff --git a/scripts/tool-prompt-usage.ts b/scripts/tool-prompt-usage.ts
index 009d9148b..4c48a0d46 100755
--- a/scripts/tool-prompt-usage.ts
+++ b/scripts/tool-prompt-usage.ts
@@ -41,7 +41,6 @@ const READ_ONLY_TOOL_NAMES: Record<string, true> = {
 	read: true,
 	recall: true,
 	reflect: true,
-	report_finding: true,
 	resolve: true,
 	retain: true,
 	rewind: true,