mixdog 0.9.91 → 0.9.92

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.91",
+  "version": "0.9.92",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/tool-overhead-microbench.mjs

@@ -0,0 +1,60 @@
+// Micro-bench: fixed per-call overhead of the shell tool path vs raw spawn.
+// Usage: node scripts/tool-overhead-microbench.mjs [bash|powershell] [N]
+// Prints per-call ms for executeBashTool('echo hi') and raw child spawn,
+// so (tool - raw) isolates our tool-layer overhead (policy, wrappers, I/O).
+import { spawn } from 'node:child_process';
+import { executeBashTool } from '../src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs';
+
+const shell = process.argv[2] || (process.platform === 'win32' ? 'powershell' : 'bash');
+const N = Number(process.argv[3] || 15);
+
+const stats = (arr) => {
+  const s = [...arr].sort((a, b) => a - b);
+  const sum = s.reduce((t, v) => t + v, 0);
+  return {
+    mean: (sum / s.length).toFixed(1),
+    p50: s[Math.floor(s.length / 2)].toFixed(1),
+    min: s[0].toFixed(1),
+    max: s[s.length - 1].toFixed(1),
+  };
+};
+
+const rawOnce = () => new Promise((resolveDone, reject) => {
+  const child = shell === 'powershell'
+    ? spawn('pwsh', ['-NoProfile', '-NonInteractive', '-Command', 'echo hi'])
+    : spawn('bash', ['-c', 'echo hi']);
+  let out = '';
+  child.stdout.on('data', (c) => { out += c; });
+  child.on('error', reject);
+  child.on('close', () => resolveDone(out));
+});
+
+const toolOnce = async () => {
+  const out = await executeBashTool({ command: 'echo hi', shell }, process.cwd(), {});
+  return String(out);
+};
+
+// Warm-up both paths (module init, shell resolution cache, standbys).
+await toolOnce(); await toolOnce();
+await rawOnce(); await rawOnce();
+
+const toolMs = [];
+for (let i = 0; i < N; i++) {
+  const t0 = performance.now();
+  await toolOnce();
+  toolMs.push(performance.now() - t0);
+}
+const rawMs = [];
+for (let i = 0; i < N; i++) {
+  const t0 = performance.now();
+  await rawOnce();
+  rawMs.push(performance.now() - t0);
+}
+
+const t = stats(toolMs);
+const r = stats(rawMs);
+console.log(`shell=${shell} n=${N}`);
+console.log(`tool  mean=${t.mean}ms p50=${t.p50}ms min=${t.min}ms max=${t.max}ms`);
+console.log(`raw   mean=${r.mean}ms p50=${r.p50}ms min=${r.min}ms max=${r.max}ms`);
+console.log(`overhead(mean tool-raw)=${(Number(t.mean) - Number(r.mean)).toFixed(1)}ms`);
+process.exit(0);

package/src/agents/debugger/agent.json

@@ -1,6 +1,6 @@
 {
   "id": "debugger",
   "name": "Debugger",
-  "description": "Failure reproduction and root-cause analysis.",
+  "description": "Use for deep root-cause analysis or a bug surviving 2+ fix cycles.",
   "entry": "AGENT.md"
 }

package/src/agents/explore/agent.json

@@ -1,6 +1,6 @@
 {
   "id": "explore",
   "name": "Explore",
-  "description": "Broad codebase exploration and target narrowing.",
+  "description": "Use when targets are unknown: broad codebase exploration and narrowing.",
   "entry": "AGENT.md"
 }

package/src/agents/heavy-worker/agent.json

@@ -1,6 +1,6 @@
 {
   "id": "heavy-worker",
   "name": "Heavy Worker",
-  "description": "Broad or multi-file implementation.",
+  "description": "Use for complex, high-difficulty tasks.",
   "entry": "AGENT.md"
 }

package/src/agents/maintainer/agent.json

@@ -1,6 +1,6 @@
 {
   "id": "maintainer",
   "name": "Maintainer",
-  "description": "Maintenance, upkeep, and long-running health work.",
+  "description": "Use for memory upkeep and long-running maintenance work.",
   "entry": "AGENT.md"
 }

package/src/agents/reviewer/agent.json

@@ -1,6 +1,6 @@
 {
   "id": "reviewer",
   "name": "Reviewer",
-  "description": "Change review and risk finding.",
+  "description": "Use when an implementation finishes: cross-verify the change for correctness and risk before reporting.",
   "entry": "AGENT.md"
 }

package/src/agents/worker/agent.json

@@ -1,6 +1,6 @@
 {
   "id": "worker",
   "name": "Worker",
-  "description": "Scoped implementation.",
+  "description": "Use for simple, well-scoped tasks.",
   "entry": "AGENT.md"
 }

package/src/lib/rules-builder.cjs

@@ -156,8 +156,8 @@ function stripFrontmatter(markdown) {
 }
 
 function normalizeOutputStyleName(value) {
-  const name = String(value || 'default').trim();
-  return /^[A-Za-z0-9_.-]+$/.test(name) ? name : 'default';
+  const name = String(value || 'simple').trim();
+  return /^[A-Za-z0-9_.-]+$/.test(name) ? name : 'simple';
 }
 
 function loadOutputStyle({ PLUGIN_ROOT, DATA_DIR }) {
@@ -172,10 +172,10 @@ function loadOutputStyle({ PLUGIN_ROOT, DATA_DIR }) {
     const body = stripFrontmatter(readOptional(candidate));
     if (body) return body;
   }
-  if (styleName !== 'default') {
+  if (styleName !== 'simple') {
     const fallback = [
-      path.join(DATA_DIR, 'output-styles', 'default.md'),
-      path.join(PLUGIN_ROOT, 'output-styles', 'default.md'),
+      path.join(DATA_DIR, 'output-styles', 'simple.md'),
+      path.join(PLUGIN_ROOT, 'output-styles', 'simple.md'),
     ];
     for (const candidate of fallback) {
       const body = stripFrontmatter(readOptional(candidate));

package/src/output-styles/simple.md

@@ -2,7 +2,7 @@
 name: simple
 title: Simple
 description: Outcome-first concise handoffs for coding work
-aliases: concise, handoff, default
+aliases: concise, handoff
 keep-coding-instructions: true
 ---
 

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

@@ -14,8 +14,9 @@
   `{path,offset,limit}` array; graph targets as arrays; `explore` facets in
   one `query[]` (max 8, no rephrased duplicates); all new edits in one patch.
   Distinct facets, not alternative routes; sequential singles only for a
-  genuinely dependent step (unconditional follow-ups are not dependent —
-  batch them); only apply_patch executes in order.
+  step whose arguments require the previous result — fixed follow-ups
+  (pinned installs, known writes) go in the same batch; only apply_patch
+  executes in order.
 - Verified paths: project root, session cwd, user-provided, tool-returned.
   `find` first for guessed path/name fragments; on ENOENT, find the basename.
   Retry `EXPLORATION_FAILED` once with changed tokens.

package/src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs

@@ -50,8 +50,10 @@ import {
     anthropicRequestTimeoutMs,
     classifyError,
     anthropicMaxAttempts,
+    createStallRetryBudget,
     midstreamBackoffFor,
     retryAfterMsFromError,
+    STREAM_STALL_RETRY_BUDGET_MS,
     withRetry,
 } from './retry-classifier.mjs';
 import {
@@ -774,6 +776,9 @@ export class AnthropicOAuthProvider {
         const MAX_MIDSTREAM_RETRIES = ANTHROPIC_MAX_MIDSTREAM_RETRIES;
         let firstAttemptError = null;
         let firstAttemptClassifier = null;
+        // Send-scoped stall window: in-place stall retries share one wall
+        // clock starting at the first stall (see createStallRetryBudget).
+        const stallRetryBudget = createStallRetryBudget();
 
         const recoverNonStreaming = async (midState, streamingError, controller) => {
             const exposedChars = Number(midState?.emittedTextChars) || 0;
@@ -1052,6 +1057,11 @@ export class AnthropicOAuthProvider {
                     continue;
                 }
                 const classifier = _classifyMidstreamError(err, midState);
+                if (classifier === 'stream_stalled' && !stallRetryBudget.allowStallRetry()) {
+                    try { process.stderr.write(`[anthropic-oauth] stall retry budget exhausted (${STREAM_STALL_RETRY_BUDGET_MS}ms since first stall) — surfacing for fresh-request retry\n`); } catch {}
+                    try { controller?.abort?.(err); } catch { /* best-effort teardown */ }
+                    throw err;
+                }
                 if (classifier && attemptIndex < MAX_MIDSTREAM_RETRIES) {
                     firstAttemptError = err;
                     firstAttemptClassifier = classifier;

package/src/runtime/agent/orchestrator/providers/anthropic.mjs

@@ -8,8 +8,10 @@ import {
     anthropicMaxAttempts,
     anthropicRequestTimeoutMs,
     classifyError,
+    createStallRetryBudget,
     midstreamBackoffFor,
     sleepWithAbort,
+    STREAM_STALL_RETRY_BUDGET_MS,
     withRetry,
     retryAfterMsFromError,
 } from './retry-classifier.mjs';
@@ -249,6 +251,9 @@ export class AnthropicProvider {
         const MAX_MIDSTREAM_RETRIES = ANTHROPIC_MAX_MIDSTREAM_RETRIES;
         let firstAttemptError = null;
         let firstAttemptClassifier = null;
+        // Send-scoped stall window: in-place stall retries share one wall
+        // clock starting at the first stall (see createStallRetryBudget).
+        const stallRetryBudget = createStallRetryBudget();
 
         const buildReturnFromParse = (parseResult) => {
             const usageRaw = parseResult.usage?.raw || null;
@@ -592,6 +597,15 @@ export class AnthropicProvider {
                         continue;
                     }
                     const classifier = _classifyMidstreamError(err, midState);
+                    if (classifier === 'stream_stalled' && !stallRetryBudget.allowStallRetry()) {
+                        try {
+                            process.stderr.write(
+                                `[${this.name}] stall retry budget exhausted (${STREAM_STALL_RETRY_BUDGET_MS}ms since first stall) — surfacing for fresh-request retry\n`,
+                            );
+                        } catch {}
+                        try { streamController.abort?.(err); } catch {}
+                        throw err;
+                    }
                     if (classifier && attemptIndex < MAX_MIDSTREAM_RETRIES) {
                         firstAttemptError = err;
                         firstAttemptClassifier = classifier;

package/src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs

@@ -36,9 +36,11 @@ import {
     classifyHandshakeError,
     classifyMidstreamError,
     createStreamSafetyStamps,
+    createStallRetryBudget,
     jitterDelayMs,
     MIDSTREAM_RETRY_POLICY,
     sleepWithAbort,
+    STREAM_STALL_RETRY_BUDGET_MS,
 } from './retry-classifier.mjs';
 import { stampStreamOutcome, STREAM_TRANSPORTS } from './lib/stream-outcome.mjs';
 import {
@@ -459,6 +461,9 @@ export async function sendViaWebSocket({
     const MAX_MIDSTREAM_RETRIES = MIDSTREAM_WS_TRANSIENT_RETRY_LIMIT;
     let firstAttemptError = null;
     let firstAttemptClassifier = null;
+    // Send-scoped stall window: in-place stall retries share one wall clock
+    // starting at the first stall (see createStallRetryBudget).
+    const stallRetryBudget = createStallRetryBudget();
     // A generate:false prewarm is billable even if its main request later
     // retries on a fresh socket or falls back to HTTP. Retain one completed
     // result across the whole logical send and attach it to terminal errors.
@@ -1006,6 +1011,11 @@ export async function sendViaWebSocket({
             const classifier = err?.unsafeToRetry === true
                 ? null
                 : _classifyMidstreamError(err, midState);
+            if (classifier === 'stream_stalled' && !stallRetryBudget.allowStallRetry()) {
+                try { process.stderr.write(`[openai-oauth] stall retry budget exhausted (${STREAM_STALL_RETRY_BUDGET_MS}ms since first stall) — surfacing for fresh-request retry\n`); } catch {}
+                emitSendSpan('error');
+                throw _stampTool(_stampLiveText(err));
+            }
             const retryLimit = classifier ? _midstreamRetryLimit(classifier) : 0;
             if (classifier && attemptIndex < retryLimit) {
                 // Retry-eligible: stash the first-attempt error, emit progress,

package/src/runtime/agent/orchestrator/providers/retry-classifier.mjs

@@ -314,6 +314,41 @@ export function jitterDelayMs(ms, ratio = PROVIDER_RETRY_JITTER_RATIO, mode = 's
   return Math.max(0, Math.round(base + offset))
 }
 
+// ── Stall-retry wall-clock budget (send-scoped) ──────────────────────────────
+// Mid-stream 'stream_stalled' recoveries retry in place, which is right for a
+// one-off blip but lets a chronically dying stream burn a whole task budget
+// slowly (observed live: one send stretched 149s→298s→556s across stall
+// retries before the agent deadline killed the task). Reference stacks bound
+// this instead of retrying forever: Claude Code caps each request at ~300s
+// wall clock (API_TIMEOUT_MS) and Codex kills a stream after one 300s silent
+// gap (stream_idle_timeout). This guard is the equivalent for our in-place
+// recovery: the clock starts at the FIRST stall of a send, and stall-classified
+// retries are allowed only inside that window; past it the stall error
+// surfaces so loop-level transport retry issues a FRESH request. Healthy
+// streams never consult the clock (no stall → no budget reads), so long
+// thinking/output can never trip it.
+export const STREAM_STALL_RETRY_BUDGET_MS = (() => {
+  const v = Number(process.env.MIXDOG_STREAM_STALL_BUDGET_MS)
+  return Number.isFinite(v) && v > 0 ? Math.floor(v) : 300_000
+})()
+
+// One instance per provider send() call (NOT per attempt — the whole point is
+// bounding the cross-attempt stall window). `now` is injectable for tests.
+export function createStallRetryBudget(budgetMs = STREAM_STALL_RETRY_BUDGET_MS, now = Date.now) {
+  let firstStallAt = 0
+  return {
+    // Record a stall-classified retry candidate. Returns true while the
+    // send's stall window still has budget; false once exhausted (the caller
+    // surfaces the error instead of retrying in place).
+    allowStallRetry() {
+      const t = now()
+      if (!firstStallAt) firstStallAt = t
+      return (t - firstStallAt) <= budgetMs
+    },
+    get firstStallAt() { return firstStallAt },
+  }
+}
+
 // ── Shared network-resilience interface ──────────────────────────────────────
 // One home for the logic shared across providers: mid-stream classifier
 // (WS + SSE), transport fallback predicate, stream-safety stamp latches,

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

@@ -444,6 +444,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             Math.floor(maxLoopIterations * 0.9),
         ];
     while (true) {
+        const _iterT0 = Date.now();
         throwIfAborted();
         if (iterations >= maxLoopIterations) {
             // Final-answer turn: instead of breaking mid-transcript (which
@@ -642,6 +643,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                 transportRetriesUsed: _transportRetriesUsed, signal,
             }),
         );
+        const _sendEndedAt = Date.now();
         if (_sendResult.action === 'retry') {
             delete opts.cacheBreakIntent;
             contextOverflowRetryUsed = true;
@@ -1038,6 +1040,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             continue;
         }
         try { opts.onToolPhaseStarted?.(); } catch {}
+        const _toolsT0 = Date.now();
         ({ dedupStubTotal: _dedupStubTotal, editCount: _editCount } = await processToolBatch({
             calls: _callsToExecute, messages, tools, cwd, sessionId, sessionRef, signal, opts,
             iterations, assistantTurnMsg: _assistantTurnMsg,
@@ -1050,6 +1053,15 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         }));
         // Settle the stop hook on the batch that actually executed.
         _toolFailureStopHook.endBatch(_callsToExecute);
+        // Loop-phase timing (diagnostics): where non-model time goes per
+        // iteration — presend (repair/compact/snapshot), send (provider
+        // round-trip incl. streaming), tools (batch execution). Gated by the
+        // same env as [turn-timing] so bench runs opt in via -AgentEnv.
+        if (process.env.MIXDOG_TURN_TIMING === '1') {
+            try {
+                process.stderr.write(`[loop-timing] iter=${nextIteration} presend=${sendStartedAt - _iterT0}ms send=${_sendEndedAt - sendStartedAt}ms tools=${Date.now() - _toolsT0}ms calls=${_callsToExecute.length}\n`);
+            } catch { /* diagnostics only */ }
+        }
         _toolBatchJustCompleted = true;
         _continuationsSinceToolBatch = 0;
         _lastToolBatchHadSleep = _callsToExecute.some(isSleepLikeToolCall);

package/src/runtime/agent/orchestrator/session/loop/stop-hooks.mjs

@@ -14,6 +14,8 @@
 
 export const STOP_HOOK_SOURCE = 'tool-failure-stop-hook';
 
+import { isInformationalShellExitOne } from '../result-classification.mjs';
+
 // Only a genuinely EXECUTED result resolves a failure, i.e. kind 'normal'.
 // Cache hits ('cache-hit' / 'scoped-cache-hit') replay an earlier result
 // without running anything, and dedup/guard skips ('skipped') execute nothing
@@ -59,6 +61,13 @@ export function createToolFailureStopHook() {
             // nothing was dispatched — they must not arm the hook.
             if (message.guardSkip === true) return;
             if (message.toolKind === 'error') {
+                // Informational exit-1 probes (grep-family no-match inside a
+                // compound command: useful stdout, blank stderr) stay 'error'
+                // for display/history, but blocking the terminal message over
+                // them forces a pointless re-verify turn — observed live
+                // (kv-store-grpc: /proc PID scan exit 1 → hook misfire, +2
+                // turns). Neutral here: neither arms nor clears.
+                if (isInformationalShellExitOne(message.content)) return;
                 batchFailure = true;
                 if (message.toolCallId) failedCallIds.add(message.toolCallId);
             } else if (EXECUTED_SUCCESS_TOOL_KINDS.has(message.toolKind)) {

package/src/runtime/agent/orchestrator/session/result-classification.mjs

@@ -68,3 +68,31 @@ export function classifyResultKind(result, explicitSuccess = false) {
     }
     return 'normal';
 }
+
+/**
+ * Informational shell exit-1: `Error: [shell-run-failed] [exit code: 1]`
+ * with a non-empty stdout body and NO stderr evidence (neither an inline
+ * `[stderr]` block nor a `[stderr: path]` spill). grep-family "no match"
+ * semantics inside compound probes (loops, `;`-chains, substitutions) land
+ * exactly here: the run produced useful output, wrote nothing to stderr,
+ * and exited 1 only because the final stage matched nothing. The static
+ * single-pipeline gate (bash-tool _isBenignSearchExitOne) deliberately
+ * refuses these ambiguous shapes, so the result stays toolKind 'error' —
+ * consumers that must not overreact to an informational failure (the turn
+ * stop hook) test this signature instead of reclassifying the result.
+ * Signals, timeouts, and other exit codes carry different status markers
+ * and never match; a destructive-warning prefix also disqualifies.
+ *
+ * @param {unknown} result
+ * @returns {boolean}
+ */
+export function isInformationalShellExitOne(result) {
+    if (typeof result !== 'string') return false;
+    const trimmed = result.trimStart();
+    const header = /^error:\s*\[shell-run-failed\]\s*\[exit code: 1\]\s*\n/i.exec(trimmed);
+    if (!header) return false;
+    const payload = trimmed.slice(header[0].length).trim();
+    if (!payload || payload === '(no output)') return false;
+    if (payload.startsWith('[stderr') || payload.includes('\n[stderr')) return false;
+    return true;
+}

package/src/runtime/agent/orchestrator/session/send-with-recovery.mjs

@@ -126,6 +126,36 @@ export async function sendWithRecovery(ctx) {
             // Every branch below consumes it instead of re-inferring safety
             // from provider-specific flags.
             const outcome = readStreamOutcome(sendErr, relayWitness);
+            // Text-only exposure retraction (cross-provider): a stream that
+            // died after relaying ONLY text — no dispatched or complete tool
+            // calls, no terminal — is replayable IF the ask owner retracts the
+            // exposed characters (onTextReset ack === true: the TUI truncates
+            // its live tail, the bench driver truncates its accumulator).
+            // This is the loop-level analogue of anthropic's
+            // recoverNonStreaming for providers WITHOUT a non-streaming
+            // fallback (gemini, openai-compat, openai WS) and for stalls that
+            // outlived the provider's in-place recovery. Observed live:
+            // make-mips-interpreter died with 31 exposed chars + a pending
+            // never-dispatched tool input and burned the whole trial.
+            const retractExposedTextForReplay = async () => {
+                if (outcome.terminalObserved === true) return false;
+                if (outcome.sideEffectDispatched === true) return false;
+                if (outcome.dispatchAmbiguous === true) return false;
+                if (Number(outcome.toolCallsDispatched) > 0) return false;
+                if (Number(outcome.toolCallsComplete) > 0) return false;
+                if (relayWitness.toolCallsDispatched > 0) return false;
+                if (typeof opts?.onTextReset !== 'function') return false;
+                const chars = Math.max(0, Number(outcome.textObservedChars) || 0)
+                    || (typeof sendErr.partialContent === 'string' ? sendErr.partialContent.length : 0);
+                if (chars <= 0) return false;
+                let acked = false;
+                try {
+                    acked = await opts.onTextReset({ chars, reason: 'loop-transport-retraction' }) === true;
+                } catch { acked = false; }
+                if (!acked) return false;
+                relayWitness.textEmitted = false;
+                return true;
+            };
             // Gemini REST/SDK reports MAX_TOKENS by throwing a typed
             // ProviderIncompleteError after preserving the streamed candidate.
             // Normalize only that exact, safe no-tool output-limit shape into a
@@ -177,6 +207,36 @@ export async function sendWithRecovery(ctx) {
                 && sendErr.partialContent.trim().length > 0
                 && outcome.toolCallsComplete === 0
             ) {
+                // Retractable shape: text-only exposure with the owner's
+                // acknowledgement replays on a fresh request instead of
+                // failing the turn. Non-acked (or tool-bearing) shapes keep
+                // the explicit-failure contract below unchanged.
+                if (
+                    transportRetriesUsed < TRANSPORT_RETRY_MAX
+                    && classifyError(sendErr) === 'transient'
+                    && await retractExposedTextForReplay()
+                ) {
+                    const waitMs = TRANSPORT_RETRY_BACKOFF_MS[transportRetriesUsed];
+                    try {
+                        process.stderr.write(
+                            `[loop] exposed-text stall retracted (sess=${sessionId || 'unknown'} `
+                            + `iter=${nextIteration} len=${sendErr.partialContent.length}); `
+                            + `transport retry ${transportRetriesUsed + 1}/${TRANSPORT_RETRY_MAX} after ${waitMs}ms\n`,
+                        );
+                    } catch { /* best-effort */ }
+                    try {
+                        appendAgentTrace({
+                            kind: 'exposed_text_retraction_retry',
+                            sessionId: sessionId || null,
+                            iteration: nextIteration,
+                            attempt: transportRetriesUsed + 1,
+                            waitMs,
+                            partialContentLen: sendErr.partialContent.length,
+                        });
+                    } catch { /* best-effort */ }
+                    await sleepMs(waitMs, undefined, signal ? { signal } : undefined);
+                    return { action: 'retry_transport' };
+                }
                 try {
                     process.stderr.write(
                         `[loop] final stream stalled with partial text (sess=${sessionId || 'unknown'} `
@@ -265,8 +325,8 @@ export async function sendWithRecovery(ctx) {
             // send after a bounded wait instead of failing the turn.
             if (
                 transportRetriesUsed < TRANSPORT_RETRY_MAX
-                && outcome.replaySafe === true
                 && classifyError(sendErr) === 'transient'
+                && (outcome.replaySafe === true || await retractExposedTextForReplay())
             ) {
                 const waitMs = TRANSPORT_RETRY_BACKOFF_MS[transportRetriesUsed];
                 try {

package/src/runtime/agent/orchestrator/tools/builtin/task-tool.mjs

@@ -206,6 +206,11 @@ export async function executeTaskTool(args, options = {}) {
             // consumed synchronously, so no re-arm. Drop the persisted ctx here
             // or it leaks (cleanup only runs on a real watcher settle, which
             // never happens for a never-re-armed entry).
+            // EXCEPT when this wait's tool call was aborted: its result was
+            // discarded, so nobody consumed the outcome — re-arm so the
+            // watcher delivers the completion notification instead of
+            // swallowing it.
+            else if (options?.signal?.aborted) watchBackgroundShellJob(taskId);
             else clearShellJobNotifyCtx(taskId);
         }
     }

package/src/session-runtime/output-styles.mjs

@@ -5,11 +5,8 @@ import { readFileSync, readdirSync, statSync } from 'node:fs';
 import { clean } from './session-text.mjs';
 import { readJsonSafe } from './fs-utils.mjs';
 
-const OUTPUT_STYLE_ORDER = ['simple', 'detailed', 'minimal', 'extreme-minimal'];
+const OUTPUT_STYLE_ORDER = ['detailed', 'simple', 'minimal', 'extreme-minimal'];
 const OUTPUT_STYLE_ALIASES = new Map([
-  ['compact', 'simple'],
-  ['normal', 'simple'],
-  ['detail', 'detailed'],
   ['extreme', 'extreme-minimal'],
   ['extremesimple', 'extreme-minimal'],
   ['extreme-simple', 'extreme-minimal'],

package/src/session-runtime/workflow.mjs

@@ -16,12 +16,18 @@ export const FIXED_AGENT_SLOTS = Object.freeze([
   // (user: 창이 크지 않으니 설명은 짧게).
   { id: 'explore', label: 'Explore', description: 'Repository exploration', workflowSlot: 'explorer' },
   { id: 'maintainer', label: 'Maintainer', description: 'Memory and upkeep', workflowSlot: 'memory' },
-  { id: 'worker', label: 'Worker', description: 'Scoped implementation' },
-  { id: 'heavy-worker', label: 'Heavy Worker', description: 'Multi-file implementation' },
+  { id: 'worker', label: 'Worker', description: 'Simple tasks' },
+  { id: 'heavy-worker', label: 'Heavy Worker', description: 'Complex tasks' },
   { id: 'reviewer', label: 'Reviewer', description: 'Diff and risk review' },
   { id: 'debugger', label: 'Debugger', description: 'Root-cause debugging' },
 ]);
 const AGENT_ROLE_IDS = new Set(FIXED_AGENT_SLOTS.map((agent) => agent.id));
+// Slot-backed built-ins (explore/maintainer) run through their own dedicated
+// channels — the explore tool and the memory cycle — so they are never
+// Lead-delegation targets and stay out of the Available Agents catalog.
+const BUILTIN_SLOT_AGENT_IDS = new Set(
+  FIXED_AGENT_SLOTS.filter((agent) => agent.workflowSlot).map((agent) => agent.id),
+);
 export const DEFAULT_WORKFLOW_ID = 'default';
 
 const SEARCH_CAPABLE_PROVIDERS = new Set([
@@ -282,16 +288,20 @@ export function createWorkflowHelpers({ rootDir, dataDir, readMarkdownDocument,
     lines.push(pack.body);
     // A hand-edited pack may name a hidden role in its `agents:` frontmatter;
     // internal roles are never delegatable, so they never enter the catalog.
+    // Slot-backed built-ins are equally non-delegatable (they ride the explore
+    // tool / memory cycle), so they are filtered even when a pack names them.
     const agentIds = (pack.agentsConfigured ? pack.agents : FIXED_AGENT_SLOTS.map((agent) => agent.id))
-      .filter((id) => !isHiddenAgent(id));
+      .filter((id) => !isHiddenAgent(id) && !BUILTIN_SLOT_AGENT_IDS.has(id));
     const agentBlocks = agentIds.map((id) => loadAgentDefinition(dir, id)).filter(Boolean);
     if (agentBlocks.length) {
       lines.push('# Available Agents');
-      for (const agent of agentBlocks) {
-        lines.push(`## ${agent.name} (${agent.id})`);
-        if (agent.description) lines.push(agent.description);
-        lines.push(agent.body);
-      }
+      // Name + description only: the AGENT.md body is the worker's own system
+      // prompt and rides in the worker session at spawn time — repeating it in
+      // the Lead prompt only bloats context. Lead picks agents by description
+      // (Claude Code whenToUse pattern); the workflow body carries the rules.
+      lines.push(agentBlocks
+        .map((agent) => `- ${agent.name} (${agent.id})${agent.description ? `: ${agent.description}` : ''}`)
+        .join('\n'));
     }
     return lines.join('\n\n');
   }

package/src/tui/dist/index.mjs

@@ -26573,6 +26573,7 @@ function drainTuiSteeringPersist(leadSessionId) {
   return _serialize(async () => {
     let drained = [];
     let droppedStale = 0;
+    let prunedOrphans = 0;
     try {
       await updateJsonAtomic(pendingMessagesPath(), (raw) => {
         const next = normalizePendingStore(raw);
@@ -26586,7 +26587,21 @@ function drainTuiSteeringPersist(leadSessionId) {
           return !stale;
         });
         drained = fresh.map(drainedRowToRestore).filter(Boolean);
-        if (drained.length === 0 && droppedStale === 0) return void 0;
+        for (const otherKey of Object.keys(next.sessions)) {
+          if (otherKey === key) continue;
+          const rows = Array.isArray(next.sessions[otherKey]) ? next.sessions[otherKey] : [];
+          const otherTouched = Number(next.sessionTouchedAt?.[otherKey]) || 0;
+          const allStale = rows.every((row) => {
+            const at = Number(row?.at) || otherTouched;
+            return at > 0 && now - at > STALE_STEERING_RESTORE_TTL_MS;
+          });
+          if (rows.length === 0 || allStale) {
+            delete next.sessions[otherKey];
+            if (next.sessionTouchedAt) delete next.sessionTouchedAt[otherKey];
+            prunedOrphans += rows.length;
+          }
+        }
+        if (drained.length === 0 && droppedStale === 0 && prunedOrphans === 0) return void 0;
         delete next.sessions[key];
         if (next.sessionTouchedAt) delete next.sessionTouchedAt[key];
         next.updatedAt = Date.now();
@@ -26602,6 +26617,13 @@ function drainTuiSteeringPersist(leadSessionId) {
     if (droppedStale > 0) {
       try {
         process.stderr.write(`[tui] dropped ${droppedStale} stale steering row(s) sessionId=${leadSessionId}
+`);
+      } catch {
+      }
+    }
+    if (prunedOrphans > 0) {
+      try {
+        process.stderr.write(`[tui] pruned ${prunedOrphans} orphaned steering row(s) from stale sessions
 `);
       } catch {
       }
@@ -30212,6 +30234,15 @@ function createEngineApiA(bag) {
         restoreState.requeueEntries = [];
         restoreState.discardExecutionPendingResumeKeys = [];
       }
+      const pendingAfterAbortKick = setTimeout(() => {
+        try {
+          if (flags.disposed) return;
+          if (getState().busy) return;
+          if (pending.length > 0 && typeof drain === "function") void drain();
+        } catch {
+        }
+      }, 150);
+      pendingAfterAbortKick.unref?.();
       const abortEpoch = flags.leadTurnEpoch;
       const recoveryMs = Number(flags.manualAbortRecoveryMs) > 0 ? Number(flags.manualAbortRecoveryMs) : MANUAL_ABORT_RECOVERY_MS;
       const recoveryTimer = setTimeout(() => {

package/src/tui/engine/session-api.mjs

@@ -616,6 +616,23 @@ export function createEngineApiA(bag) {
       // ── Bounded manual-abort recovery ───────────────────────────────────
       // runtime.abort() above normally rejects the in-flight runtime.ask() so
       // the turn's own finally clears busy within a tick. If that unwind is
+      // starved the recovery timer below hard-releases busy. Separately from
+      // recovery: queued work must never strand behind a cancelled turn
+      // (Codex parity — abort preserves pending input for the next turn; CC
+      // parity — the command queue survives cancel and fires when idle). The
+      // drain loop that owns a normal turn continues on its own; this bounded
+      // kick covers unwinds where no drain owner re-checks pending after busy
+      // clears. drain() self-guards (busy/draining/commandBusy), so the
+      // drain-owned path is unchanged and a duplicate kick is a no-op.
+      const pendingAfterAbortKick = setTimeout(() => {
+        try {
+          if (flags.disposed) return;
+          if (getState().busy) return;
+          if (pending.length > 0 && typeof drain === 'function') void drain();
+        } catch { /* best-effort */ }
+      }, 150);
+      pendingAfterAbortKick.unref?.();
+      // If that unwind is
       // starved — e.g. a provider abort that never settles after a post-tool
       // fetch stall — busy would stay true until the far-larger turn watchdog
       // trips, wedging the TUI with dead input. Arm a short grace timer that

package/src/tui/engine/tui-steering-persist.mjs

@@ -195,6 +195,7 @@ export function drainTuiSteeringPersist(leadSessionId) {
   return _serialize(async () => {
     let drained = [];
     let droppedStale = 0;
+    let prunedOrphans = 0;
     try {
       await updateJsonAtomic(pendingMessagesPath(), (raw) => {
         const next = normalizePendingStore(raw);
@@ -210,7 +211,26 @@ export function drainTuiSteeringPersist(leadSessionId) {
           return !stale;
         });
         drained = fresh.map(drainedRowToRestore).filter(Boolean);
-        if (drained.length === 0 && droppedStale === 0) return undefined;
+        // Orphan cleanup: buckets of OTHER sessions whose every row already
+        // aged past the restore TTL can never be restored (restore is keyed
+        // by the live session id), so they only grow the file forever
+        // (observed live: queued rows from sessions closed days ago). Prune
+        // them under the same lock/write.
+        for (const otherKey of Object.keys(next.sessions)) {
+          if (otherKey === key) continue;
+          const rows = Array.isArray(next.sessions[otherKey]) ? next.sessions[otherKey] : [];
+          const otherTouched = Number(next.sessionTouchedAt?.[otherKey]) || 0;
+          const allStale = rows.every((row) => {
+            const at = Number(row?.at) || otherTouched;
+            return at > 0 && (now - at) > STALE_STEERING_RESTORE_TTL_MS;
+          });
+          if (rows.length === 0 || allStale) {
+            delete next.sessions[otherKey];
+            if (next.sessionTouchedAt) delete next.sessionTouchedAt[otherKey];
+            prunedOrphans += rows.length;
+          }
+        }
+        if (drained.length === 0 && droppedStale === 0 && prunedOrphans === 0) return undefined;
         delete next.sessions[key];
         if (next.sessionTouchedAt) delete next.sessionTouchedAt[key];
         next.updatedAt = Date.now();
@@ -222,6 +242,9 @@ export function drainTuiSteeringPersist(leadSessionId) {
     if (droppedStale > 0) {
       try { process.stderr.write(`[tui] dropped ${droppedStale} stale steering row(s) sessionId=${leadSessionId}\n`); } catch {}
     }
+    if (prunedOrphans > 0) {
+      try { process.stderr.write(`[tui] pruned ${prunedOrphans} orphaned steering row(s) from stale sessions\n`); } catch {}
+    }
     return drained;
   });
 }

package/src/workflows/default/WORKFLOW.md

@@ -2,7 +2,7 @@
 id: default
 name: Cowork
 description: "Parallel delegation."
-agents: worker, heavy-worker, reviewer, debugger, maintainer
+agents: worker, heavy-worker, reviewer, debugger
 ---
 
 # Cowork
@@ -13,23 +13,12 @@ investigation and planning — no edits, no state mutation, no delegation.
 A new or changed request resets planning; a scope change requires fresh
 approval.
 
-On approval, fan out at maximum width: one agent per independent scope, all
-spawned in one turn; only a scope that depends on another's output waits.
-Split the plan into as many scopes as possible: disjoint file/module sets
-are independent; merge only on a true output dependency. Prefer parallel
-scopes over sequential slices in one agent. Brief each agent per the Lead
-Brief contract.
-
-Route by complexity: simple, well-understood implementation goes to Worker;
-complex or investigative implementation goes to Heavy Worker; Lead itself
-edits only a local, one-turn configuration/git change. Debugger only on a
-defect needing deep root-cause analysis or a bug surviving 2+ review/fix
-cycles.
-
-Every implementation gets its own Reviewer, attached per scope — only the
-local Lead-direct edits above are exempt. Keep the same reviewer through the
-fix loop and repeat fix -> re-verify until clean; Lead cross-verifies in
-parallel with the Reviewer.
+On approval, delegate maximally: one agent per independent scope, fit to the
+situation, all spawned in one turn; only a scope that depends on another's
+output waits. Split the plan into as many scopes as possible: disjoint
+file/module sets are independent; merge only on a true output dependency.
+Prefer parallel scopes over sequential slices in one agent. Brief each agent
+per the Lead Brief contract.
 
 Report the verified result against the approved plan. Build, deploy, commit,
 and push happen only on an explicit user request.