mixdog 0.9.87 → 0.9.89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.87",
+  "version": "0.9.89",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -49,6 +49,8 @@
     "smoke:all": "npm run smoke && npm run smoke:boot && npm run smoke:patch && npm run smoke:output && npm run smoke:tui && npm run smoke:live-worker",
     "smoke:boot": "node scripts/boot-smoke.mjs",
     "smoke:compact": "node scripts/compact-smoke.mjs",
+    "test:compact": "node --test scripts/compact-active-turn-test.mjs scripts/compact-file-reattach-test.mjs scripts/compact-prior-context-flatten-test.mjs scripts/compact-recall-digest-test.mjs scripts/compact-pressure-test.mjs",
+    "test:context": "node --test scripts/context-mcp-metering-test.mjs scripts/v4a-context-miss-excerpt-test.mjs",
     "smoke:loop": "node scripts/smoke-loop.mjs",
     "smoke:loop:final": "node scripts/smoke-loop-report.mjs --require-complete --min-elapsed 5h --min-iterations 400 --max-gap 60s --max-smoke-ms 10000 --max-avg-smoke-ms 8500 --max-step-ms smoke.mjs=4000 --max-step-ms boot-smoke.mjs=8000 --max-rss-mb 140 --max-rss-growth-mb 50",
     "smoke:loop:report": "node scripts/smoke-loop-report.mjs",
@@ -61,12 +63,13 @@
     "smoke:live-worker": "node scripts/live-worker-smoke.mjs",
     "smoke:agent-tag-reuse": "node scripts/agent-tag-reuse-smoke.mjs",
     "test:agent-terminal-reap": "node scripts/agent-terminal-reap-test.mjs",
+    "test:agent-job-views": "node --test scripts/agent-job-terminal-view-test.mjs",
     "test:agent-fanout": "node scripts/agent-parallel-smoke.mjs && node --test scripts/agent-route-batch-test.mjs scripts/execution-completion-dedup-test.mjs",
     "test:toolcall": "node --test scripts/toolcall-args-test.mjs",
     "test:shipmode": "node --test scripts/ship-mode-test.mjs",
-    "test:shellhardening": "node --test scripts/shell-hardening-test.mjs scripts/shell-failure-diagnostics-test.mjs",
+    "test:shellhardening": "node --test scripts/shell-hardening-test.mjs scripts/shell-failure-diagnostics-test.mjs scripts/windows-hide-spawn-options-test.mjs",
     "test:placeholder": "node --test scripts/compacted-placeholder-scrub-test.mjs",
-    "test:providers": "node --test scripts/provider-toolcall-test.mjs scripts/provider-contract-test.mjs",
+    "test:providers": "node --test scripts/provider-toolcall-test.mjs scripts/provider-contract-test.mjs scripts/provider-stream-stall-test.mjs scripts/provider-stream-outcome-test.mjs scripts/stream-frame-fault-matrix-test.mjs scripts/gemini-provider-test.mjs scripts/anthropic-transport-policy-test.mjs scripts/anthropic-native-block-replay-test.mjs scripts/openai-oauth-ws-1006-retry-test.mjs scripts/openai-end-turn-signal-test.mjs",
     "test:provider-admission": "node --test scripts/provider-admission-scheduler-test.mjs",
     "test:resource-admission": "node --test scripts/resource-admission-test.mjs",
     "test:deferred-tools": "node --test scripts/deferred-tool-loading-test.mjs",
@@ -80,20 +83,23 @@
     "test:embedding-runtime:warmup": "node scripts/verify-embedding-runtime.mjs --warmup",
     "test:code-graph-dispatch": "node --test scripts/code-graph-dispatch-test.mjs",
     "test:code-graph-clean-cache": "node --test scripts/code-graph-dispatch-test.mjs",
-    "test:tui-queue": "node --test scripts/submit-commandbusy-race-test.mjs scripts/steering-drain-buckets-test.mjs scripts/abort-recovery-test.mjs scripts/execution-pending-resume-kick-test.mjs scripts/execution-resume-esc-integration-test.mjs",
+    "test:tui-queue": "node --test scripts/submit-commandbusy-race-test.mjs scripts/steering-drain-buckets-test.mjs scripts/abort-recovery-test.mjs scripts/execution-pending-resume-kick-test.mjs scripts/execution-resume-esc-integration-test.mjs scripts/pending-stale-injection-test.mjs",
     "test:tui-input-render": "node --test scripts/prompt-immediate-render-test.mjs",
     "test:tui-streaming-window": "node --test scripts/streaming-tail-window-test.mjs",
     "test:tui-ambiguous-width": "node --test scripts/tui-ambiguous-width-test.mjs",
     "test:release-assets": "node --check scripts/verify-release-assets.mjs && node --check scripts/verify-release-assets-test.mjs && node --check scripts/deploy-workflow-test.mjs && node --test scripts/verify-release-assets-test.mjs scripts/deploy-workflow-test.mjs",
-    "test:release-focused": "npm run test:release-assets && npm run test:tool-contracts && npm run test:placeholder && npm run smoke:patch && npm run test:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && node --test scripts/code-graph-root-federation-test.mjs scripts/code-graph-aggregate-cwd-test.mjs && npm run test:code-graph-dispatch && node --test scripts/code-graph-disk-hit-test.mjs && npm run test:shellhardening && node --test scripts/windows-hide-spawn-options-test.mjs && npm run test:session && npm run test:workflow-editor && npm run test:embedding-runtime && node --test scripts/tui-transcript-perf-test.mjs",
+    "test:release-focused": "npm run test:release-assets && npm run test:tool-contracts && npm run test:placeholder && npm run smoke:patch && npm run test:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && npm run test:compact && npm run test:context && node --test scripts/code-graph-root-federation-test.mjs scripts/code-graph-aggregate-cwd-test.mjs && npm run test:code-graph-dispatch && node --test scripts/code-graph-disk-hit-test.mjs && npm run test:shellhardening && npm run test:project-registry && npm run test:session && npm run test:workflow-editor && npm run test:embedding-runtime && node --test scripts/tui-transcript-perf-test.mjs",
     "test:native-edit-wire": "node --test scripts/native-edit-wire-test.mjs",
     "test:patch-binary-cache": "node --test scripts/patch-binary-cache-test.mjs",
-    "test:session": "node --test scripts/session-orphan-sweep-test.mjs scripts/interrupted-turn-history-test.mjs scripts/turn-checkpoint-crash-test.mjs scripts/session-heartbeat-lifecycle-test.mjs scripts/remote-transition-order-test.mjs",
+    "test:patch-parity": "node --test scripts/v4a-codex-parity-test.mjs",
+    "test:project-registry": "node --test scripts/project-registry-isolation-test.mjs",
+    "test:session": "node --test scripts/session-orphan-sweep-test.mjs scripts/interrupted-turn-history-test.mjs scripts/turn-checkpoint-crash-test.mjs scripts/turn-outcome-fault-matrix-test.mjs scripts/session-save-fault-store-test.mjs scripts/session-disk-authority-test.mjs scripts/session-load-cache-race-test.mjs scripts/agent-loop-complete-turn-test.mjs scripts/session-heartbeat-lifecycle-test.mjs scripts/remote-transition-order-test.mjs scripts/session-new-reset-test.mjs",
+    "test:live-canary": "node --test scripts/live-canary-test.mjs",
     "test:rebindtail": "node --test scripts/forwarder-rebind-tail-test.mjs",
     "test:workflow-editor": "node --test scripts/workflow-id-test.mjs scripts/workflow-pack-editor-test.mjs",
     "test:route-scope": "node --test scripts/route-scope-isolation-test.mjs",
     "test:schedule-reload": "node --test scripts/schedule-reload-arm-test.mjs",
-    "test:media": "node --test src/runtime/media/store.test.mjs",
+    "test:media": "node --test src/runtime/media/store.test.mjs src/runtime/media/renditions.test.mjs",
     "failures": "node scripts/tool-failures.mjs",
     "trace:llm": "node scripts/llm-trace-summary.mjs",
     "diag:sessions": "node scripts/session-diag.mjs",

package/scripts/tool-failures.mjs

@@ -88,6 +88,7 @@ function rowCategory(row) {
 }
 
 const sinceTs = parseSince(sinceArg);
+const onlyArg = String(argValue('--only', 'all') || 'all').toLowerCase();
 const rows = files.flatMap(readRows)
   .filter((row) => sinceTs == null || Number(row.ts || 0) >= sinceTs)
   .filter((row) => !toolFilter || rowTool(row) === toolFilter)
@@ -95,6 +96,11 @@ const rows = files.flatMap(readRows)
   .filter((row) => !categoryFilter || rowCategory(row) === categoryFilter)
   .sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0));
 const isCommandExit = (row) => rowCategory(row) === 'command-exit';
+// Absorbed-by-design outcomes (compacted-history placeholder preflight, etc.):
+// retained in the log and displayed, but never counted as actionable work.
+const isExpectedAbsorbed = (row) => /^expected-/.test(String(rowCategory(row)));
+const isPatchFailure = (row) => /^patch\//.test(String(rowCategory(row)));
+const categoryFamily = (row) => String(rowCategory(row)).split('/')[0] || '(uncategorized)';
 const rowLeadingErrorLine = (row) => [
   row.error_first_line,
   row.error_preview,
@@ -109,25 +115,41 @@ const isExpectedCancellation = (row) => {
   if (rowCategory(row) === 'expected-cancellation') return true;
   return /^Session\s+"[^"]+"\s+closed:\s*(?:aborted|closed)\s+during call\b/i.test(rowLeadingErrorLine(row));
 };
-const actionableRows = rows.filter((row) => !isCommandExit(row) && !isExpectedCancellation(row));
-const commandExitRows = rows.filter(isCommandExit);
+const cancellationRows = rows.filter(isExpectedCancellation);
+const liveRows = rows.filter((row) => !isExpectedCancellation(row));
+const commandExitRows = liveRows.filter(isCommandExit);
+// Ordinary non-zero test/command exits and absorbed preflights are reported
+// separately so a green-but-noisy run never reads as N tool/patch failures.
+const expectedRows = liveRows.filter((row) => !isCommandExit(row) && isExpectedAbsorbed(row));
+const actionableRows = liveRows.filter((row) => !isCommandExit(row) && !isExpectedAbsorbed(row));
+const patchRows = actionableRows.filter(isPatchFailure);
+const wants = (kind) => onlyArg === 'all' || onlyArg === kind;
 // Limit each partition independently so a burst of ordinary command exits
 // cannot crowd runtime/actionable failures out of the displayed report.
-const actionableRecent = actionableRows.slice(-limit);
-const commandExitRecent = commandExitRows.slice(-limit);
-const recent = [...actionableRecent, ...commandExitRecent]
+const actionableRecent = wants('actionable') ? actionableRows.slice(-limit) : [];
+const commandExitRecent = wants('exits') ? commandExitRows.slice(-limit) : [];
+const expectedRecent = wants('expected') ? expectedRows.slice(-limit) : [];
+const recent = [...actionableRecent, ...commandExitRecent, ...expectedRecent]
   .sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0));
-const byTool = new Map();
-const byCategory = new Map();
-const actionableByTool = new Map();
-const commandExitByTool = new Map();
-for (const row of recent) {
-  const tool = rowTool(row);
-  const category = rowCategory(row);
-  inc(byTool, tool);
-  inc(byCategory, `${tool} / ${category}`);
-  inc(isCommandExit(row) ? commandExitByTool : actionableByTool, tool);
+function tally(list, keyFn) {
+  const map = new Map();
+  for (const row of list) inc(map, keyFn(row));
+  return map;
 }
+const sortedEntries = (map) => [...map.entries()].sort((a, b) => b[1] - a[1]);
+const asObject = (map) => Object.fromEntries(sortedEntries(map));
+const asText = (map) => sortedEntries(map).map(([k, v]) => `${k}:${v}`).join(', ') || '(none)';
+// Aggregates cover every MATCHED row in the window (not just the displayed
+// tail) so `--since 24h` headline totals cannot be read as the whole picture
+// while a truncated tail hides the rest.
+const byTool = tally(recent, rowTool);
+const byCategory = tally(recent, (row) => `${rowTool(row)} / ${rowCategory(row)}`);
+const actionableByTool = tally(actionableRows, rowTool);
+const actionableByCategory = tally(actionableRows, rowCategory);
+const actionableByFamily = tally(actionableRows, categoryFamily);
+const commandExitByTool = tally(commandExitRows, rowTool);
+const expectedByCategory = tally(expectedRows, rowCategory);
+const patchByCategory = tally(patchRows, rowCategory);
 
 if (jsonMode) {
   console.log(JSON.stringify({
@@ -135,36 +157,50 @@ if (jsonMode) {
     matched: rows.length,
     actionable_failures: { shown: actionableRecent.length, matched: actionableRows.length },
     command_exits: { shown: commandExitRecent.length, matched: commandExitRows.length },
+    expected_absorbed: { shown: expectedRecent.length, matched: expectedRows.length },
+    session_cancellations: { shown: 0, matched: cancellationRows.length },
+    patch_failures: { matched: patchRows.length, categories: asObject(patchByCategory) },
     since: sinceTs ? new Date(sinceTs).toISOString() : null,
     filters: {
       tool: toolFilter,
       agent: agentFilter,
       category: categoryFilter,
+      only: onlyArg,
     },
     sources: files.filter(existsSync),
-    tools: Object.fromEntries([...byTool.entries()].sort((a, b) => b[1] - a[1])),
-    actionable_tools: Object.fromEntries([...actionableByTool.entries()].sort((a, b) => b[1] - a[1])),
-    command_exit_tools: Object.fromEntries([...commandExitByTool.entries()].sort((a, b) => b[1] - a[1])),
-    categories: Object.fromEntries([...byCategory.entries()].sort((a, b) => b[1] - a[1])),
+    tools: asObject(byTool),
+    actionable_tools: asObject(actionableByTool),
+    actionable_categories: asObject(actionableByCategory),
+    actionable_families: asObject(actionableByFamily),
+    command_exit_tools: asObject(commandExitByTool),
+    expected_categories: asObject(expectedByCategory),
+    categories: asObject(byCategory),
     rows: recent,
   }, null, 2));
   process.exit(0);
 }
 
-console.log(`actionable failures: ${actionableRecent.length}/${actionableRows.length} shown`);
-console.log(`command exits: ${commandExitRecent.length}/${commandExitRows.length} shown (retained)`);
+console.log(`actionable failures: ${actionableRecent.length}/${actionableRows.length} shown (excludes command exits, absorbed preflights, session cancellations)`);
+console.log(`command exits: ${commandExitRecent.length}/${commandExitRows.length} shown (retained) — ordinary non-zero test/command exits, not tool failures`);
+console.log(`expected/absorbed: ${expectedRecent.length}/${expectedRows.length} shown (retained) — absorbed by design, not actionable`);
+console.log(`session cancellations: ${cancellationRows.length} matched (not shown)`);
 console.log(`rows: ${recent.length}/${rows.length} shown`);
 if (sinceTs) console.log(`since: ${new Date(sinceTs).toISOString()}`);
 const filterParts = [
   toolFilter ? `tool=${toolFilter}` : '',
   agentFilter ? `agent=${agentFilter}` : '',
   categoryFilter ? `category=${categoryFilter}` : '',
+  onlyArg !== 'all' ? `only=${onlyArg}` : '',
 ].filter(Boolean);
 if (filterParts.length) console.log(`filters: ${filterParts.join(', ')}`);
 if (files.length > 0) console.log(`sources: ${files.filter(existsSync).join(', ') || '(none)'}`);
-console.log(`actionable tools: ${[...actionableByTool.entries()].sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(', ') || '(none)'}`);
-console.log(`command-exit tools: ${[...commandExitByTool.entries()].sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(', ') || '(none)'}`);
-console.log(`categories: ${[...byCategory.entries()].sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(', ') || '(none)'}`);
+console.log(`actionable tools (matched): ${asText(actionableByTool)}`);
+console.log(`actionable categories (matched): ${asText(actionableByCategory)}`);
+console.log(`actionable families (matched): ${asText(actionableByFamily)}`);
+console.log(`patch failures (matched): ${patchRows.length} — ${asText(patchByCategory)}`);
+console.log(`command-exit tools (matched): ${asText(commandExitByTool)}`);
+console.log(`expected/absorbed categories (matched): ${asText(expectedByCategory)}`);
+console.log(`shown categories: ${asText(byCategory)}`);
 for (const row of recent) {
   const tool = rowTool(row);
   const category = rowCategory(row);

package/src/agents/heavy-worker/AGENT.md

@@ -6,14 +6,13 @@ permission: read-write
 Own the assigned implementation slice through staged delivery.
 
 Break work into bounded, dependency-aware slices and execute them in sequence.
-At each checkpoint, run the narrowest relevant test or build before expanding
-the slice. Keep the smallest coherent change; control blast radius rather than
-rewriting adjacent systems.
+Keep the smallest coherent change; control blast radius rather than rewriting
+adjacent systems.
 
 EDIT-FIRST DISCIPLINE. Patch incrementally and stop at the first explicit
 boundary: unclear ownership, a missing dependency, or growing blast radius.
 Do not cross that boundary without a new bounded assignment; report blocked
 work with the relevant file:line.
 
-Self-verify each checkpoint and the final slice with shell (targeted test/build).
+Finish the slice and report the changed `file:line`; verification belongs to the Lead and Reviewer.
 

package/src/agents/worker/AGENT.md

@@ -12,6 +12,5 @@ smallest coherent patch. No drive-by cleanup or scope expansion.
 EDIT-FIRST DISCIPLINE. Patch promptly rather than repeating read-only turns;
 stop and report blocked when the assigned scope cannot be completed.
 
-Self-verify with a targeted check (for example, `node --check` or a focused
-test), then report the changed `file:line` and stop.
+Patch and report the changed `file:line`; verification belongs to the Lead and Reviewer.
 

package/src/cli.mjs

@@ -10,6 +10,14 @@ import { stagedChildExitCode } from './runtime/shared/staged-child-result.mjs';
 
 const argv = process.argv.slice(2);
 
+// V8 compile cache: the whole runtime loads via dynamic import below, so
+// enabling the cache here persists compiled bytecode across CLI launches
+// (measurable cold-start parse savings). Best-effort on older Node builds.
+try {
+  const { enableCompileCache } = await import('node:module');
+  enableCompileCache?.();
+} catch { /* launch-speed optimization only */ }
+
 // React/ink resolve their build flavor from NODE_ENV at require time. Unset
 // NODE_ENV loads react-reconciler's DEVELOPMENT build, whose per-commit debug
 // bookkeeping consumed ~16% of TUI frame CPU under transcript load (cpuprofile

package/src/defaults/cycle3-review-prompt.md

@@ -23,7 +23,7 @@ CORE is durable standing knowledge that lands in one of three layers:
 - **L3 — Current map:** one-line project-landscape summaries, live long-running
   goals, environment anchors documented nowhere else.
 
-Every entry must be ONE compact ENGLISH clause (≤120 chars), regardless of
+Every entry must be ONE compact ENGLISH clause, regardless of
 source language. Keep identifiers, paths, and exact phrases coined by the user
 verbatim. CORE is not a log.
 
@@ -52,7 +52,7 @@ or inconclusive, keep the CORE entry.
 
 - `keep` — durable and already one compact ENGLISH clause.
 - `update` — durable but verbose, multi-sentence, or non-English → rewrite as
-  one compact ≤120-char ENGLISH clause; keep identifiers, paths, and exact
+  one compact ENGLISH clause; keep identifiers, paths, and exact
   phrases coined by the user verbatim.
 - `merge` — duplicates another entry → fold into the survivor (same project pool).
 - `reclassify` — the entry is filed under the WRONG project pool. Its subject
@@ -86,7 +86,7 @@ or inconclusive, keep the CORE entry.
   "needs confirmation" and only removed on an explicit APPLY CYCLE3 run.
 
 A verbose, multi-sentence, or non-English durable entry is always `update`,
-never `keep`; rewrite it as a ≤120-char English clause while keeping
+never `keep`; rewrite it as a compact English clause while keeping
 identifiers, paths, and exact user-coined phrases verbatim.
 Delete is the rarest verdict. Prefer `keep` for durable rules/preferences and
 `update` for compression when the current behavior is still valid.
@@ -122,5 +122,5 @@ One line per entry id, any order:
 <id>|delete|<reason>
 ```
 
-`summary` ≤120 chars, one clause. No literal `|` or newline inside a field
+`summary` is one compact clause. No literal `|` or newline inside a field
 (replace `|` with `/`). No prose, no fences. First character is a digit.

package/src/rules/agent/00-core.md

@@ -10,3 +10,6 @@
   unrequested headings/tables, prose narration, raw logs/tool traces,
   speculative next checks, restated briefs, articles, or politeness.
 - Follow stricter role contracts and runtime wrap-up requirements.
+- Your final message ends the task: emit the handoff text only when the work is
+  done. If a tool failed and stays unresolved, fix and re-run it, or say so
+  explicitly in the handoff.

package/src/rules/agent/42-cycle3-agent.md

@@ -13,12 +13,11 @@ prose, or preamble.
 
 CORE is durable standing knowledge: rules, preferences, identity, goals, and
 current system/structure descriptions—not a log. Each entry is one short clause
-(≤120 chars). Current rule/preference/live structure = durable; a past event =
-not durable. When unsure, keep.
+without a hard character cap. Current rule/preference/live structure = durable;
+a past event = not durable. When unsure, keep.
 
 - `keep`: durable, already one short clause.
-- `update`: durable but verbose/multi-sentence; compress to one ≤120-char
-  clause.
+- `update`: durable but verbose/multi-sentence; compress to one short clause.
 - `merge`: duplicate; fold into its survivor in the same project pool.
 - `delete`: past event, not a current rule or structure.
 
@@ -29,7 +28,7 @@ Verbose durable is always `update`, never `keep`.
 `<id>|merge|<target_id>|<source_ids_csv>`
 `<id>|delete`
 
-IDs match input rows; never invent them. An `update` summary is one ≤120-char
-clause and its `element` is short. A `merge` retains `target_id`, absorbs
+IDs match input rows; never invent them. An `update` summary is one short
+clause and its `element` is compact. A `merge` retains `target_id`, absorbs
 sources, and stays within one `project_id`. Replace literal `|` with `/`;
 fields contain no newlines. Emit a digit-starting verdict for every input row.

package/src/rules/lead/01-general.md

@@ -6,3 +6,5 @@
   headings, labels, or routine lookup narration.
 - Destructive/hard-to-reverse action needs explicit confirmation.
 - Act proactively; ask only for decisions.
+- Your final message ends the turn: answer only when the work is done. After a
+  failed tool call, fix and re-run it, or state plainly that it is unresolved.

package/src/rules/shared/01-tool.md

@@ -6,41 +6,35 @@
   `find`; verified root+wildcard→
   `glob`; quoted/non-identifier literal or regex→`grep`; exact code
   identifier/relation→`code_graph` before grep; known file/span→`read`
-  directly without `grep`; verified directory→`list`; edit→`apply_patch`;
-  program/state change→`shell`; web/current external info→`search`. Use grep
-  only for a requested literal occurrence or after graph zero/error.
-- Batch compatible targets and combine variants, symbols, scopes, paths, and
-  queries. Parallelize distinct facets only, never alternative routes for one
-  facet. Put independent calls in one turn; they run concurrently regardless
-  of tool — shell included. Later turns are only for targets dependent on
-  prior results or unresolved facets. Only apply_patch executes in order.
-- After locator results, collect all known candidate files/regions before
-  inspection. Batch compatible reads, including same-file regions — real
-  `{path,offset,limit}` arrays covering the whole logical unit — in one
-  `path[]` call and graph targets in arrays. Parallelize independent
-  incompatible read-only inspections. Never page or reread returned spans,
-  and do not start a singleton while a known compatible candidate remains.
-  Put all new edits in one patch.
-- Project root, session cwd, user-provided and tool-returned paths are
-  verified. Use `find` first for every genuinely guessed path/name fragment, in
-  the same turn as independent probes. Never find verified roots or use
-  `path:"."` with guessed `src/**`. On ENOENT, find the basename; never retry
-  the guess. Unscoped root grep/glob/list requires no find.
+  directly without `grep`; verified directory→`list`; known edit→
+  `apply_patch` directly, with no preparatory `read`;
+  program/state change→`shell`; web/current external info→`search`.
+- Shortest total calls, maximum batching — every turn. Combine variants,
+  symbols, scopes, paths, and queries into one call; put all independent
+  calls (probes, reads, hypotheses, commands) in one message — concurrent
+  regardless of tool, shell included. Sequential singles only for a
+  genuinely dependent next step. Distinct facets, not alternative routes.
+  Only apply_patch executes in order.
+- Batch compatible reads — same-file regions as real `{path,offset,limit}`
+  arrays covering the whole logical unit — in one `path[]` call, and graph
+  targets in arrays. Don't reread returned spans. Put all new edits in one
+  patch.
+- Verified paths: project root, session cwd, user-provided, tool-returned.
+  `find` first for guessed path/name fragments (same turn as other probes);
+  on ENOENT, find the basename.
 - At task start, batch all `explore` facets in one `query[]` call, maximum 8,
   without rephrased duplicates. Retry `EXPLORATION_FAILED` once with changed
   tokens.
-- Stop when evidence covers the deliverable; never re-locate, re-verify, or
-  upgrade a sufficient anchor. A returned requested `path:line`
-  freezes the LOCATION only; when content was not returned,
-  read or code_graph detail inspection is valid — never re-locate it.
-- Give grep content mode enough `-C` to avoid rereads; a sufficient contextual
-  grep means no overlapping `read`. After `files_with_matches`, `count`,
-  capped, or insufficient context, inspect only missing content. A nonzero
-  `content_with_context` result resolves the concept; act directly without
-  re-search; only zero/error results permit token or scope changes.
-- Apply edits before verification, then verify in a separate shell turn and
-  consume results in order. Otherwise remain parallel.
-- A long-running command promoted to background is a decision point, not a
-  cue to wait: estimate whether observed progress can finish within budget;
-  otherwise diagnose the bottleneck and switch routes. Choose waiting
-  explicitly.
+- Stop when evidence covers the deliverable; don't re-locate or re-verify a
+  sufficient anchor. A returned `path:line` freezes the location; inspecting
+  its content with read/code_graph is valid.
+- A nonzero `content_with_context` result resolves that concept — act on it;
+  only zero/error results justify changed tokens or scope.
+- `apply_patch` is the primary edit tool: send the patch as soon as the target
+  path and new content are known. `read` is for discovery or for recovery
+  after a patch failed on insufficient context.
+- A shell placed after `apply_patch` in the same turn runs after the patch
+  lands — batch edits and their verification freely.
+- A command promoted to background is a decision point: continue only if
+  observed progress fits the budget, otherwise switch routes. Waiting is an
+  explicit choice.

package/src/runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs

@@ -24,8 +24,8 @@
 import { loadConfig } from '../config.mjs';
 import { resolveRuntimeSpec } from '../config.mjs';
 import { getHiddenAgent, resolveAgentSessionPermission } from '../internal-agents.mjs';
-import { isKnownProvider } from '../../../../standalone/provider-admin.mjs';
 import { prepareAgentSession } from './session-builder.mjs';
+import { resolveMaintenanceRoute } from './maintenance-route.mjs';
 import {
     askSession,
     updateSessionStatus,
@@ -43,6 +43,8 @@ import {
 } from './agent-progress-watchdog.mjs';
 import { resourceAdmission } from '../../../shared/resource-admission.mjs';
 
+export { resolveMaintenanceRoute } from './maintenance-route.mjs';
+
 // Cap agent role synthesis to ~3000 tokens (~12 KB at the 4 B/tok
 // working average). Pool B explore/recall/search answers occasionally land
 // 8-10k-token walls that then ride in the Lead context for the rest of the
@@ -153,56 +155,6 @@ export function resolveHiddenRoleSchemaAllowedTools(hidden) {
  * maintenance route → Main. The cycle1/2/3 agents share the memory knob via
  * their `maintKey: 'memory'` override. Scheduler and webhook are unchanged.
  */
-const DEFAULT_AGENT_ROUTE_PROVIDER = 'anthropic-oauth';
-
-function normalizeMaintenanceCandidate(candidate, config) {
-    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) return candidate || null;
-    const configuredProvider = String(config?.defaultProvider || '').trim();
-    const fallbackProvider = isKnownProvider(configuredProvider)
-        ? configuredProvider
-        : DEFAULT_AGENT_ROUTE_PROVIDER;
-    const provider = String(candidate.provider || fallbackProvider).trim();
-    const model = String(candidate.model || '').trim();
-    if (!provider || !model) return null;
-    return {
-        provider,
-        model,
-        effort: String(candidate.effort || '').trim() || undefined,
-        fast: candidate.fast === true,
-    };
-}
-
-export function resolveMaintenanceRoute({ preset, optsPreset, agent, config: cfgIn = null }) {
-    if (preset) return preset;
-    if (optsPreset) return optsPreset;
-    if (!agent) return null;
-    const hidden = getHiddenAgent(agent);
-    if (hidden) {
-        try {
-            const config = cfgIn || loadConfig({ secrets: false });
-            const maint = config?.maintenance || {};
-            const key = hidden.maintKey || hidden.slot;
-            const role = key === 'explore' ? 'explore' : (key === 'memory' ? 'maintainer' : '');
-            const workflowSlot = key === 'explore' ? 'explorer' : (key === 'memory' ? 'memory' : '');
-            if (!role) return maint[key] ?? null;
-            const candidates = [
-                role ? config?.agents?.[role] : null,
-                key === 'memory' ? config?.agents?.maintenance : null,
-                workflowSlot ? config?.workflowRoutes?.[workflowSlot] : null,
-                maint[key],
-                role ? config?.default : null,
-            ];
-            for (const candidate of candidates) {
-                const route = normalizeMaintenanceCandidate(candidate, config);
-                if (route) return route;
-            }
-            return null;
-        } catch { return null; }
-    }
-    return null;
-}
-
-
 // A maintenance slot value is a direct route when it carries provider+model.
 function maintenanceRouteToPreset(routeOrName, agent) {
     if (!routeOrName || typeof routeOrName !== 'object') return null;

package/src/runtime/agent/orchestrator/agent-runtime/maintenance-route.mjs

@@ -0,0 +1,59 @@
+import { isKnownProvider } from '../../../../standalone/provider-admin.mjs';
+import { loadConfig } from '../config.mjs';
+import { getHiddenAgent } from '../internal-agents.mjs';
+
+const DEFAULT_AGENT_ROUTE_PROVIDER = 'anthropic-oauth';
+
+function normalizeMaintenanceCandidate(candidate, config) {
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) return candidate || null;
+    const configuredProvider = String(config?.defaultProvider || '').trim();
+    const fallbackProvider = isKnownProvider(configuredProvider)
+        ? configuredProvider
+        : DEFAULT_AGENT_ROUTE_PROVIDER;
+    const provider = String(candidate.provider || fallbackProvider).trim();
+    const model = String(candidate.model || '').trim();
+    if (!provider || !model) return null;
+    return {
+        provider,
+        model,
+        effort: String(candidate.effort || '').trim() || undefined,
+        fast: candidate.fast === true,
+    };
+}
+
+/**
+ * Resolve the maintenance route for a hidden role without creating an agent
+ * session. Session-backed dispatch and tiny one-shot completions share this
+ * model-selection boundary.
+ */
+export function resolveMaintenanceRoute({ preset, optsPreset, agent, config: cfgIn = null }) {
+    if (preset) return preset;
+    if (optsPreset) return optsPreset;
+    if (!agent) return null;
+    const hidden = getHiddenAgent(agent);
+    if (hidden) {
+        try {
+            const config = cfgIn || loadConfig({ secrets: false });
+            const maint = config?.maintenance || {};
+            const key = hidden.maintKey || hidden.slot;
+            const role = key === 'explore' ? 'explore' : (key === 'memory' ? 'maintainer' : '');
+            const workflowSlot = key === 'explore' ? 'explorer' : (key === 'memory' ? 'memory' : '');
+            if (!role) return maint[key] ?? null;
+            const candidates = [
+                role ? config?.agents?.[role] : null,
+                key === 'memory' ? config?.agents?.maintenance : null,
+                workflowSlot ? config?.workflowRoutes?.[workflowSlot] : null,
+                maint[key],
+                role ? config?.default : null,
+            ];
+            for (const candidate of candidates) {
+                const route = normalizeMaintenanceCandidate(candidate, config);
+                if (route) return route;
+            }
+            return null;
+        } catch {
+            return null;
+        }
+    }
+    return null;
+}

package/src/runtime/agent/orchestrator/agent-runtime/session-builder.mjs

@@ -91,8 +91,8 @@ export function prepareAgentSession({
     // or fall through to the shared runaway guard (LEAD_MAX_LOOP_ITERATIONS).
     const effectiveMaxLoopIterations = maxLoopIterations;
     // Pass cwd through verbatim — null is the fixed agent sentinel meaning
-    // "no caller workspace context" (cycle1-agent shards, etc). Upgrading
-    // null → process.cwd() here would defeat cache-shard fork suppression.
+    // "no caller workspace context" (cycle1 agents, etc). Upgrading
+    // null → process.cwd() here would defeat cache-key fork suppression.
     // Downstream collectors (collect.mjs) handle null as "no project cwd".
     const effectiveCwd = cwd == null ? null : cwd;
     const effectiveOwnerSessionId = ownerSessionId === undefined

package/src/runtime/agent/orchestrator/agent-runtime/title-completion.mjs

@@ -0,0 +1,67 @@
+import { loadConfig } from '../config.mjs';
+import { getProvider, initProviders } from '../providers/registry.mjs';
+import { resolveMaintenanceRoute } from './maintenance-route.mjs';
+
+export const TITLE_SYSTEM_PROMPT = "Create a concise session title from the provided message or conversation. Output only one title on one line, at most 32 characters; no quotes, markdown, or trailing period.";
+
+export function titleSystemPrompt(locale = '') {
+    const systemLocale = String(locale || '').trim();
+    return systemLocale
+        ? `${TITLE_SYSTEM_PROMPT} System language/locale: ${systemLocale}. Prefer that language when the source is ambiguous; preserve a clearly different source language.`
+        : TITLE_SYSTEM_PROMPT;
+}
+
+function resultText(result) {
+    if (typeof result === 'string') return result;
+    if (typeof result?.content === 'string') return result.content;
+    if (Array.isArray(result?.content)) {
+        return result.content
+            .map((part) => part?.type === 'text' ? String(part.text || '') : '')
+            .filter(Boolean)
+            .join('\n');
+    }
+    return '';
+}
+
+export function createTitleCompletion(deps = {}) {
+    const load = deps.loadConfig || loadConfig;
+    const resolveRoute = deps.resolveMaintenanceRoute || resolveMaintenanceRoute;
+    const initialize = deps.initProviders || initProviders;
+    const providerFor = deps.getProvider || getProvider;
+
+    return async function generateSessionTitle(source, options = {}) {
+        const text = String(source || '').trim();
+        if (!text) return '';
+        const signal = options.signal || null;
+        const config = load();
+        const route = resolveRoute({
+            agent: 'title-agent',
+            config,
+        });
+        if (!route || typeof route !== 'object') {
+            throw new Error('Session title maintenance route is unresolved.');
+        }
+        const providerName = String(route.provider || '').trim();
+        const model = String(route.model || '').trim();
+        if (!providerName || !model) {
+            throw new Error('Session title maintenance route requires provider and model.');
+        }
+        await initialize(config.providers || {}, { signal });
+        const provider = providerFor(providerName);
+        if (!provider || typeof provider.send !== 'function') {
+            throw new Error(`Session title provider is unavailable: ${providerName}`);
+        }
+        const response = await provider.send([
+            { role: 'system', content: titleSystemPrompt(options.locale) },
+            { role: 'user', content: text },
+        ], model, undefined, {
+            signal,
+            effort: String(route.effort || '').trim() || 'low',
+            fast: route.fast === true,
+            maxOutputTokens: 128,
+        });
+        return resultText(response).trim();
+    };
+}
+
+export const generateSessionTitle = createTitleCompletion();