@bojackduy/opencode-loopd 1.9.3 → 1.9.5

package/commands/goal.md

@@ -20,7 +20,8 @@ When you have enough to write a concrete contract:
     - `workspaceWrite` — default `true` (safe — may touch the shared repo; only one active writer allowed — second `start`/`resume` fails with `already active`); set `false` explicitly for artifact-only/read-only work to allow concurrency
     - `checkCwd` — optional directory where `checks` run; writers default to project root, artifact-only jobs default to their `artifactDir`
     - `progressFile` — optional path to a markdown progress file (defaults to `<artifactDir>/progress.md`)
-    - limits — optional `maxTurns` (default 50), `maxNoProgress`, `maxFailures`, `compactEvery`, `timeoutMs`
+    - `costBudget` — max dollars before `budget_limited` (e.g. `0.5`); enforced continuously, worker aborted mid-turn when exceeded
+    - limits — optional `maxTurns` (default 50), `maxNoProgress`, `maxFailures`, `compactEvery`, `timeoutMs` (also `costBudget` / `tokenBudget` for hard caps)
 2. After it returns (`ok:true` with `goalID`/`artifactDir`/`defaultsApplied`, or `ok:false` with `errorCode: "missing_agent"|"missing_checks"|"already active"`), tell the user the goal is running in the background and they can monitor it with `/loop` (or <leader>o). On `missing_*`, explain the contract violation and ask for the missing piece; on `already active`, tell them to `pause`/`clear` the current writer or use `workspaceWrite:false`.
 
 Important: the worker session runs autonomously — do not try to do the goal's work in this chat. This chat only creates the goal. Completion is host-judged: if `checks` fail, the worker will see `HOST VERDICT: COMPLETION REJECTED` with exact `stderr` and must fix the behavior (not just rewrite evidence) before retrying.

package/dist/tui.js

@@ -1755,7 +1755,7 @@ function LoopDashboard(props) {
               return _el$162;
             })())] : (() => {
               var _el$165 = _$createElement("span");
-              _$insertNode(_el$165, _$createTextNode(`parent default`));
+              _$insertNode(_el$165, _$createTextNode(`parent`));
               _$effect((_$p) => _$setProp(_el$165, "style", {
                 fg: theme().textMuted
               }, _$p));
@@ -1793,7 +1793,7 @@ function LoopDashboard(props) {
               return _el$169;
             })()] : (() => {
               var _el$170 = _$createElement("span");
-              _$insertNode(_el$170, _$createTextNode(`session default`));
+              _$insertNode(_el$170, _$createTextNode(`parent`));
               _$effect((_$p) => _$setProp(_el$170, "style", {
                 fg: theme().textMuted
               }, _$p));
@@ -1815,29 +1815,29 @@ function LoopDashboard(props) {
               return _el$153;
             })(), (() => {
               var _el$155 = _$createElement("span");
-              _$insert(_el$155, () => formatTokens(goal().tokensUsed));
+              _$insert(_el$155, () => formatCost(goal().costUsed));
               _$effect((_$p) => _$setProp(_el$155, "style", {
-                fg: theme().warning,
+                fg: theme().success,
                 bold: true
               }, _$p));
               return _el$155;
             })(), (() => {
               var _el$156 = _$createElement("span");
-              _$insertNode(_el$156, _$createTextNode(` tokens \xB7 `));
+              _$insertNode(_el$156, _$createTextNode(` \xB7 `));
               _$effect((_$p) => _$setProp(_el$156, "style", {
                 fg: theme().textMuted
               }, _$p));
               return _el$156;
             })(), (() => {
               var _el$158 = _$createElement("span");
-              _$insert(_el$158, () => formatCost(goal().costUsed));
+              _$insert(_el$158, () => formatTokens(goal().tokensUsed));
               _$effect((_$p) => _$setProp(_el$158, "style", {
-                fg: theme().success,
+                fg: theme().warning,
                 bold: true
               }, _$p));
               return _el$158;
             })(), (() => {
-              var _el$159 = _$createElement("span"), _el$160 = _$createTextNode(` \xB7 `);
+              var _el$159 = _$createElement("span"), _el$160 = _$createTextNode(` tokens \xB7 `);
               _$insertNode(_el$159, _el$160);
               _$insert(_el$159, () => formatDuration(goal().timeUsedSeconds), null);
               _$effect((_$p) => _$setProp(_el$159, "style", {

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@bojackduy/opencode-loopd",
-  "version": "1.9.3",
+  "version": "1.9.5",
   "description": "Codex-inspired background goal engine for OpenCode — autonomous subagents, engine-driven loop, child worker sessions and modal TUI dashboard. Like Claude Code loop for OpenCode.",
   "type": "module",
   "license": "AGPL-3.0-or-later",

package/skills/loopd/SKILL.md

@@ -2,7 +2,7 @@
 name: loopd
 description: "Agent skill for loopd background goals. Teaches when to create goals, how to inspect/steer/pause them, and how to send instructions to workers."
 metadata:
-  version: "1.0.0"
+  version: "1.1.0"
   status: active
   tags: [opencode, loop, goal, background, automation]
 ---
@@ -38,26 +38,32 @@ created → active → complete
 
 Only `active` goals own live worker runs. `blocked`/`paused`/`budget_limited` wait for an explicit owner transition (`resume`/`retry`/`nudge`). The loop is engine-driven, not parent-driven.
 
+`abort_goal_worker` (TUI `A` / `abort_goal_worker` tool) aborts the worker *session only* — status stays the same, transcript remains browsable, the next active turn reuses the same session. Use it for compaction-spin or stuck runs that keep burning tokens without progress.
+
 ## Contract & Evaluation Semantics
 
 Every goal has an **immutable contract** at creation — the source of truth for completion:
 
 * **Objective** — semantic requirements (free text, self-contained). The worker derives concrete requirements from it.
 * **Checks** — deterministic shell commands that **must pass** for `complete_goal` to be accepted. For `workspaceWrite:true` goals they are **mandatory** (explicit `checks` or plugin `defaultChecks`), and they run from `checkCwd` (writers default to project root; artifact-only jobs run from their `artifactDir`).
-* **Agent** — which subagent model runs the worker (`sloppy-agent`, `smart-agent`, …). Required unless `defaultAgent` is configured in `opencode.jsonc` plugin options.
+* **Agent** — any OpenCode agent name: built-in (`build`, `plan`, `explore`, `general`), file `~/.config/opencode/agents/*.md`, or `opencode.jsonc` `agent.*`. Discover with `opencode agent list`. Prefer `subagent`-mode agents for workers; `primary`-mode agents work but may expect user interaction. Optional — falls back to parent session's agent, or plugin `defaultAgent`.
+* **Model** — any model as `"providerID/modelID"` (e.g. `openai/gpt-5.6-sol`, `ollama/qwen3.8:27b`, `openrouter/google/gemma-4-31b-it:free`). Discover with `opencode models [provider]`. Sent on every worker prompt; omit to use the agent/session default, or configure `defaultModel` in `opencode.jsonc`.
 * **WorkspaceWrite** — `true` (default) = may touch the shared repo; **only one active writer at a time** is allowed (enforced on `start`/`resume`/`retry` with rollback). Set `false` explicitly for artifact-only/read-only work to allow concurrency.
- * **Limits** — `maxTurns` (default 50), `maxNoProgress`, `maxFailures`, `maxEvaluatorRejections` (default 3), `timeoutMs`, `compactEvery`, `progressFile`.
+* **Budgets** — `tokenBudget` (tokens) and `costBudget` (dollars, e.g. `0.5`). When either is exceeded the engine aborts the worker mid-turn and sets `budget_limited`. The worker is stopped immediately, not just at the next turn boundary.
+* **Limits** — `maxTurns` (default 50), `maxNoProgress`, `maxFailures`, `maxEvaluatorRejections` (default 3), `timeoutMs`, `compactEvery`, `progressFile`.
 
 **Who decides completion:**
 * **Host is the acceptance authority** — it runs `checks` deterministically. If any check fails, `complete_goal` is **rejected** (`ok:false`, `rejectionCount++`, `freeRetryPending=true` for <3 rejections, `blocked` after 3). The worker gets the exact failure in the next steering.
 * **Model is the proposer** — it must self-audit via `## COMPLETION REVIEW` (derive requirements → locate evidence → judge `proves|contradicts|incomplete|missing`) and only call `complete_goal` when every requirement is proved. If objective and checks conflict, it must `block_goal`, not silently violate either.
 
-**Hardened loop guarantees (1da88dc):**
-* **Prompt correlation** — each turn’s prompt gets a `msg-` UUID (`activePromptMessageID`); the engine correlates `message.updated`/`message.part.updated` by that ID and by `runGeneration`. Stale events never release a newer lease.
-* **Generation fencing** — `idleCandidateAt` is tied to `idleCandidateGeneration`; a new prompt clears the candidate. Finalization also requires the transcript anchor: the latest user prompt must be the engine’s prompt **and** its assistant response must be completed.
-* **Maintenance (30s)** — auto-repairs `phase=idle + activeRunID` (stale lease), bounds `unknown` status polls (`unknownStatusCount` threshold 3 → one `notifyOwner` per episode, `workerUnreachableNotifiedAt` deduped), and recovers counters on success. `active`-only polling; `blocked`/`paused` never auto-continue.
-* **Per-goal mutex** — `withGoalOperation(goalID)` serializes `continueTurn`/`pause`/`resume`/`retry`/`clear`/`nudge` per goal, and `turn.acquire` re-checks `leaseIsValid` inside the transaction for exclusivity.
-* **Lease** — `acquireLease`/`releaseLease` + `timeoutMs` (default 5 min); prompt failures release the lease and schedule `waiting_retry` with exponential backoff.
+**Hardened loop guarantees:**
+* **Prompt correlation** — each turn’s prompt gets a `msg-` UUID (`activePromptMessageID`); the engine correlates `message.updated`/`message.part.updated` by that ID and by `runGeneration`. Stale events never release a newer lease. After an assistant message completes, trailing `part.updated` events no longer reset activity (they are rendering echoes, not work).
+* **Generation fencing** — `idleCandidateAt` is tied to `idleCandidateGeneration`; a new prompt clears the candidate. Finalization also requires the transcript anchor: the latest user prompt must be the engine’s prompt **and** its assistant response must be completed — unless the event anchor (`activeAssistantCompletedAt`) already proved completion, which covers long turns whose prompt aged out of the tail window.
+* **Idle-unconfirmed & stuck watchdogs** — `idle.confirm-failed` emits once per generation when a turn cannot confirm. If an idle-but-unconfirmable turn stays quiet for `idleUnconfirmedMs` (default 5m), the engine emits `run.stuck` and notifies once. If a `busy`/`retry` turn stays quiet past `stuckRunningMs` (default 10m) with an expired lease, it also notifies once. Both are notify-only; a separate auto-recovery path self-heals `running`-phase stalls on idle workers after `idleRecoverMs` (default 3m) by generation-fenced lease release and continuation (same as a manual `nudge`).
+* **Maintenance (30s)** — continuously folds live worker usage (tokens/cost/time) into goal totals, enforces budgets mid-turn (abort + `budget_limited`), auto-repairs `phase=idle + activeRunID` (stale lease), bounds `unknown` status polls (`unknownStatusCount` threshold 3 → one `notifyOwner` per episode, `workerUnreachableNotifiedAt` deduped), and recovers counters on success. `active`-only polling; `blocked`/`paused` never auto-continue.
+* **Per-goal mutex** — `withGoalOperation(goalID)` serializes `continueTurn`/`pause`/`resume`/`retry`/`clear`/`nudge`/`abortWorker`/`sendUserMessage` per goal, and `turn.acquire` re-checks `leaseIsValid` inside the transaction for exclusivity.
+* **Lease** — `acquireLease`/`releaseLease` + `timeoutMs` (default 5 min); prompt failures release the lease and schedule `waiting_retry` with exponential backoff. Terminal-class prompt errors (context overflow, unknown model/agent, auth) block immediately and abort the session instead of retrying.
+* **Interaction registry** — `src/domain/interaction-registry.ts` is the single source of truth. Every TUI key/slash and every agent tool for the same `LoopCommand` is defined once; `test/domain/parity.test.ts` fails CI if they drift.
 
 ## Creating a Goal
 
@@ -67,7 +73,9 @@ Use `loopd_create_goal` **after** clarifying the objective with the user (what /
 loopd_create_goal({
   name: "short-name",
   objective: "Detailed description of what the goal should accomplish.",
-  agent: "smart-agent",                    // required unless plugin defaultAgent is configured
+  agent: "researcher",                    // any agent name; optional, falls back to parent/defaultAgent
+  model: "openai/gpt-5.6-sol",            // any provider/model; optional, falls back to parent/defaultModel
+  costBudget: 0.5,                         // optional dollars; aborts worker when exceeded
   checks: ["npm test"],                    // mandatory if workspaceWrite:true (or configure defaultChecks)
   checkCwd: "/project/root",               // optional; writers default to project root, readers to artifactDir
   workspaceWrite: true,                    // default true; set false explicitly for artifact-only/read-only
@@ -81,9 +89,9 @@ loopd_create_goal({
 })
 ```
 
-Returns `ok:true` with `goalID`, `workerSessionID`, `artifactDir`, `agent`, `checks`, `workspaceWrite`, `defaultsApplied:{agent,checks}`. On contract violation you get `ok:false` with `errorCode: "missing_agent"` or `"missing_checks"` or `"already active"` (writer serialization).
+Returns `ok:true` with `goalID`, `workerSessionID`, `artifactDir`, `agent`, `model`, `costBudget`, `checks`, `workspaceWrite`, `defaultsApplied:{agent,model,checks}`. On contract violation you get `ok:false` with `errorCode: "missing_agent"` or `"missing_checks"` or `"already active"` (writer serialization) or `"invalid_cost_budget"`.
 
-The goal starts immediately. The user can monitor it via `/loop` (<leader>o). Plugin options `defaultAgent` / `defaultChecks` in `opencode.jsonc` can supply defaults so callers don’t have to repeat them.
+The goal starts immediately. The user can monitor it via `/loop` (<leader>o). Plugin options `defaultAgent` / `defaultModel` / `defaultChecks` in `opencode.jsonc` can supply defaults so callers don’t have to repeat them.
 
 ## Worker Tools (Running Inside the Goal)
 
@@ -127,23 +135,19 @@ block_goal({
 })
 ```
 
-### Worker questions vs send_goal_input
-
-| Tool | Who calls it | Direction | When to use |
-|------|-------------|-----------|-------------|
-| `question` (OpenCode builtin) | Worker (inside goal) | Worker → User | Worker needs info only the user can provide. Question appears in the TUI footer as a blocker tab. |
-| `send_goal_input` | Owner (parent chat) | User → Worker | Owner sends an instruction, answer, or redirect to the worker. |
+### Worker questions vs owner steering
 
-**question** — The worker uses OpenCode's built-in `question` tool when it's genuinely stuck or ambiguous. The question appears in the TUI footer (blocker tab) and the user answers there. No goal status change needed — the worker stays busy until answered.
+| Tool | Who calls it | Direction | Turns | When to use |
+|------|-------------|-----------|-------|-------------|
+| `question` (OpenCode builtin) | Worker (inside goal) | Worker → User | — | Worker needs info only the user can provide. Question appears in the TUI footer as a blocker tab. |
+| `send_goal_input` | Owner (parent chat) | User → Worker | **Bare, immediate** | Owner sends short words as their own turn — no steering wrapper, delivered now if active, queued if paused/blocked. For lightweight redirects. |
+| `nudge_goal` | Owner (parent chat) | User → Worker | **Full steering** | Owner forces a re-prompt with the full continuation prompt (contract + progress + verification). Use when the worker is stuck but healthy. |
 
-**send_goal_input** — The owner calls this to steer the worker. Messages are injected into the worker's next continuation prompt. Use it to:
-- Redirect the worker to a different approach
-- Refine scope or add constraints
-- Provide missing context
+**Two prompt kinds:** engine/nudge turns carry full steering (contract, history, verification); `:send` / `send_goal_input` turns carry *only* your words. Short directives therefore fit small-context models where a 100k steering bundle would overflow.
 
 ## Owner Tools (Parent Chat)
 
-All are filtered by `ownerSessionID` (only the session that created the goal sees it). They are the **only** way to recover a stuck worker — they mutate the engine state (Entity B) and, when needed, force the bridge to the real subagent session (Entity A).
+All are filtered by `ownerSessionID` (only the session that created the goal sees it). They are the **parity surface** for TUI — every TUI action has an equivalent tool here, enforced by the interaction registry.
 
 ### list_background_goals
 
@@ -151,7 +155,7 @@ Lists all `active` goals owned by this session (name, status, phase, turn, last
 
 ### inspect_background_goal
 
-Shows detailed contract + runtime: `objective`, `config{agent,checks,checkCwd,workspaceWrite,limits,artifactDir}`, `lastProgress`, `completionEvidence`, `blocker`, `runtime{phase,runCount,budgetTurnCount,runGeneration,evaluatorRejectionCount,lastActivityAt,activePromptMessageID,unknownStatusCount}`.
+Shows detailed contract + runtime: `objective`, `config{agent,model,checks,checkCwd,workspaceWrite,limits,artifactDir,costBudget}`, `lastProgress`, `completionEvidence`, `blocker`, `runtime{phase,runCount,budgetTurnCount,runGeneration,evaluatorRejectionCount,lastActivityAt,activePromptMessageID,unknownStatusCount,workerAbortedAt}`. Plus live `transcriptTail`, `activeToolCallIDs`, `progressHistory`, `artifactSummary`, `pendingInbox`.
 
 ### read_goal_transcript
 
@@ -159,11 +163,19 @@ Reads the last N messages from the worker session (`role`, `content`, `timestamp
 
 ### send_goal_input
 
-Appends to the goal’s inbox file; the next `continueTurn` injects it as `## USER INSTRUCTIONS`. **Does not itself re-prompt** — the engine does on next idle/maintenance.
+Sends bare words as their own turn (no steering wrapper). Delivers immediately if the goal is active, otherwise queues for the next active turn.
+
+```
+send_goal_input({ goal_id: "…", message: "use X, not Y" })
+```
 
 ### nudge_goal
 
-Force re-prompts a stuck worker even if `sessionStatus` is not `idle`. Clears stale `activeRunID`/`idleCandidateAt`/`activePromptMessageID`/lease, sets `phase=idle`, and calls `continueTurn({force:true})`. Use when `unknownStatusCount` ≥3 or the worker is `running` with no activity. Returns `{ok, message}`.
+Force re-prompts a stuck active worker with **full steering** even if `sessionStatus` is not `idle`. Clears stale `activeRunID`/`idleCandidateAt`/`activePromptMessageID`/lease, sets `phase=idle`, and calls `continueTurn({force:true})`. Use when the worker is `running` with no activity or the dashboard shows a stuck/worker-aborted state. Returns `{ok, message}`.
+
+### abort_goal_worker
+
+Abort the worker *session only* (`A` / `:abort` in TUI). Keeps goal+transcript+session browsable, clears the run lease. Use for compaction-spin or stuck runs that keep burning tokens without progress. Status unchanged; active goals resume next turn in the same session.
 
 ### pause_goal / resume_goal / retry / clear
 
@@ -172,52 +184,60 @@ Force re-prompts a stuck worker even if `sessionStatus` is not `idle`. Clears st
 * `retry` (via `resume` on `blocked`) — `blocked → active`, resets `consecutiveFailures`/`forceFinishRequested`.
 * `clear_goal` — aborts worker and removes `goal` + `runtime` + ledger entry (cannot be undone).
 
+### force_complete_goal / force_block_goal
+
+Owner-side equivalents of TUI `:force` / `:block`. Bypass checks — use only when you have verified manually that the artifact is correct or that the blocker is real.
+
 ## Dashboard Commands
 
 Open the dashboard with `/loop` or <leader>o.
 
 ### Keyboard Shortcuts (Normal Mode)
 
-| Key | Action |
-|-----|--------|
-| `j` / `k` | Move selection down / up |
-| `g` / `G` | Jump to top / bottom |
-| `o` | Open child (view details) |
-| `L` | Toggle log view |
-| `?` | Toggle help |
-| `Ctrl+N` | Switch to normal mode |
-| `:` | Enter command mode |
+| Key | Action | Agent equivalent |
+|-----|--------|-----------------|
+| `j` / `k` | Move selection down / up | — (UI only) |
+| `g` / `G` | Jump to top / bottom | — |
+| `o` | Open child (view details) | `read_goal_transcript` / `inspect_background_goal` |
+| `L` | Toggle log view | — |
+| `?` | Toggle help | — |
+| `c` | Toggle done (show/hide completed) | — |
+| `p` / `r` / `R` / `x` | Pause / resume / retry / clear | `pause_goal` / `resume_goal` / `clear_goal` |
+| `A` | Abort worker only (N / :abort) | `abort_goal_worker` |
+| `N` | Nudge with full steering | `nudge_goal` |
+| `Ctrl+N` | Switch to normal mode | — |
+| `:` | Enter command mode | — |
 
 ### Command Mode (`:` prefix)
 
-| Command | Description |
-|---------|-------------|
-| `:send <message>` | Send instruction to the selected goal's worker |
-| `:open` | Open the selected goal's child session |
-| `:force <summary> --evidence <text>` | Force-complete (bypass verification checks) |
-| `:block <reason> --needed <text>` | Force-block the selected goal |
-| `:pause` | Pause the selected goal |
-| `:resume` | Resume the paused goal |
-| `:retry` | Retry the blocked goal |
-| `:clear` | Clear the selected goal |
-| `:logs` | Toggle log view |
-| `:help` | Show help |
-| `:q` / `:close` | Close dashboard |
+| Command | Description | Agent equivalent |
+|---------|-------------|-----------------|
+| `:send <message>` | Send bare words now as their own turn (no steering) | `send_goal_input` |
+| `:nudge` | Force re-prompt now with full steering | `nudge_goal` |
+| `:open` | Open the selected goal's child session | — |
+| `:force <summary> --evidence <text>` | Force-complete (bypass verification checks) | `force_complete_goal` |
+| `:block <reason> --needed <text>` | Force-block the selected goal | `force_block_goal` |
+| `:abort` | Abort worker session now (status unchanged; A) | `abort_goal_worker` |
+| `:pause` / `:resume` / `:retry` / `:clear` | Quick controls (also p/r/R/x) | `pause_goal` / `resume_goal` / `clear_goal` |
+| `:logs` / `:help` / `:q` | Toggle logs / help / close | — |
 
 > Goal creation (`:goal start`) was removed from the dashboard — create goals via `/goal` in the parent chat so the agent can clarify the objective first.
 
+**Scrolling:** the goal list is a `<scrollbox>` capped at 10 rows — short lists sit compact with no gap, long lists scroll and follow `j`/`k`/`g`/`G` via `scrollChildIntoView`. Detail + input stay pinned below in both cases. Empty list shows the fallback tip.
+
 ## Safety Patterns
 
-1. **Always call `get_goal` first** — Read the full contract (objective + checks + limits) before doing any work. The `COMPLETION REVIEW` and `HOST VERDICT` in steering are authoritative.
+1. **Always call `get_goal` first** — Read the full contract (objective + checks + limits + budgets) before doing any work. The `COMPLETION REVIEW` and `HOST VERDICT` in steering are authoritative.
 2. **Progress after durable changes** — Call `report_goal_progress` after file writes or verifications (resets `consecutiveFailures`/`noProgressCount`), not after thinking.
 3. **Complete with evidence — host decides** — Never call `complete_goal` without concrete proof. The host will reject it if `checks` fail; you’ll get `Rejection #N` with exact `stderr` and a **free retry** (`budgetTurnCount` not charged for N<3). After 3 rejections the goal is `blocked`.
 4. **Block for real blockers only** — Don’t block for things you can figure out. If objective and `checks` appear contradictory, `block_goal` — don’t silently violate either.
 5. **Use checks for verification — mandatory for writers** — `workspaceWrite:true` goals **require** `checks` (explicit or `defaultChecks`). Checks run from `checkCwd` (writers → project root by default). `["npm test","bun run typecheck"]` is a good default.
 6. **Serialize workspace edits** — Keep `workspaceWrite:true` (the default) for code/repo changes. The engine allows **only one active writer**; a second `start`/`resume`/`retry` fails with `already active`. Use `workspaceWrite:false` explicitly for artifact-only research to allow concurrency.
-7. **Set safety budgets** — `maxTurns` (default 50), `maxNoProgress`, `maxFailures` prevent runaways. On `maxTurns`/`maxNoProgress` the engine injects `FINAL REPORT REQUIRED`; if ignored, it `blocked (force-finish ignored)` after the next idle.
+7. **Set safety budgets** — `maxTurns` (default 50), `costBudget` (dollars), `tokenBudget` (tokens), `maxNoProgress`, `maxFailures` prevent runaways. Budgets are enforced **continuously** in maintenance, not just at turn boundaries — the worker is aborted mid-turn when exceeded. On `maxTurns`/`maxNoProgress` the engine injects `FINAL REPORT REQUIRED`; if ignored, it `blocked (force-finish ignored)` after the next idle.
 8. **Compact periodically** — `compactEvery` keeps the worker session’s context manageable.
-9. **Recover stuck workers explicitly** — If `inspect` shows `phase=running` with `unknownStatusCount ≥3` or `lastActivityAt` far in the past, use `nudge_goal` (force re-prompt) or `pause`/`resume`. `send_goal_input` alone does not re-prompt.
+9. **Recover stuck workers explicitly** — If `inspect` shows `phase=running` with `unknownStatusCount ≥3` or `lastActivityAt` far in the past, use `nudge_goal` (full steering) for a healthy-but-stuck worker or `abort_goal_worker` for a spinning/burning one. `send_goal_input` alone is now immediate for active goals, but it is still bare words, not steering.
 10. **One writer, one check suite** — Don’t run concurrent `start` calls that touch the same files from parallel chats; chain them sequentially or mark the second as `workspaceWrite:false`.
+11. **Registry is the source of truth** — `src/domain/interaction-registry.ts` lists every `LoopCommand` with its TUI and agent bindings. `test/domain/parity.test.ts` fails CI if they drift. When adding an interaction: add one row to `INTERACTIONS`, one handler in `control-worker.ts`, and both surfaces light up.
 
 ## Example: Creating and Monitoring a Goal
 
@@ -234,7 +254,9 @@ Agent: Got it — creating with a contract.
 loopd_create_goal({
   name: "docs-write",
   objective: "Write a README.md covering: what it is, install, usage, architecture, and examples. Then create CHANGELOG.md with a v1.0.0 entry.",
-  agent: "smart-agent",
+  agent: "researcher",
+  model: "openai/gpt-5.6-sol",
+  costBudget: 0.5,
   checks: ["test -f README.md", "test -f CHANGELOG.md"],
   checkCwd: "/Users/you/project",           // explicit for writers; defaults to project root
   workspaceWrite: true,                     // default true — serialized
@@ -257,3 +279,16 @@ get_goal()  → reads objective
 # ... writes CHANGELOG.md
 complete_goal({ summary: "Docs complete", evidence: "README.md and CHANGELOG.md exist" })
 ```
+
+**Owner steering mid-run (either transport):**
+```
+# TUI:  :send use pnpm, not npm
+# Agent: send_goal_input({ message: "use pnpm, not npm" })
+# → bare turn, delivered now, no steering wrapper — fits small contexts
+
+# TUI:  N  or  :nudge        ↔  Agent: nudge_goal()
+# → full steering turn, forced even if not idle
+
+# TUI:  A  or  :abort        ↔  Agent: abort_goal_worker()
+# → kill the session only, keep transcript, next active turn reuses it
+```