mixdog 0.9.91 → 0.9.93

package/src/runtime/memory/tool-defs.mjs

@@ -4,7 +4,7 @@
 // they never reach an external LLM. `aiWrapped: true` routes dispatches
 // through ai-wrapped-dispatch.mjs instead of the module's handleToolCall.
 // Shared period grammar for recall/search_memories.
-const PERIOD_DESCRIPTION = "last (recent sessions; +query topic-filter; limit=session count), Nm/Nh/Nd, today/yesterday/this_week/last_week, all, YYYY-MM-DD, date~date, HH:MM~HH:MM, or 'YYYY-MM-DD HH:MM~HH:MM'.";
+const PERIOD_DESCRIPTION = "last (recent sessions; +query topic-filter), Nm/Nh/Nd, today/yesterday/this_week/last_week, all, YYYY-MM-DD, date~date, or HH:MM~HH:MM.";
 export const TOOL_DEFS = [
   {
     name: 'memory',
@@ -48,7 +48,7 @@ export const TOOL_DEFS = [
     name: 'recall',
     title: 'Recall',
     annotations: { title: 'Recall', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    description: 'Retrieve stored memory/session history for prior-work context (resumes, earlier decisions). Query is topic/semantic, not regex; period selects the time window; id for exact follow-up.',
+    description: 'Retrieve stored memory/session history (prior work, resumes, decisions). Query is semantic, not regex; period=time window; id=exact follow-up.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -60,10 +60,10 @@ export const TOOL_DEFS = [
         sort: { type: 'string', enum: ['importance', 'date'], description: 'importance or date.' },
         category: { anyOf: [{ type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'] }, { type: 'array', items: { type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'] }, minItems: 1 }], description: 'Category filter.' },
         includeArchived: { type: 'boolean', description: 'Include archived entries.' },
-        includeMembers: { type: 'boolean', description: 'Include chunk members in output; does not widen the search pool.' },
-        includeRaw: { type: 'boolean', description: 'Include unchunked raw/episode rows.' },
+        includeMembers: { type: 'boolean', description: 'Include chunk members.' },
+        includeRaw: { type: 'boolean', description: 'Include raw/episode rows.' },
         sessionOnly: { type: 'boolean', description: 'Search this session only.' },
-        projectScope: { type: 'string', description: 'Project pool selector: inferred from cwd, common, all, or slug.' },
+        projectScope: { type: 'string', description: 'Pool: inferred from cwd, common, all, or slug.' },
       },
       additionalProperties: false,
     },

package/src/runtime/shared/channel-notification-routing.mjs

@@ -7,6 +7,12 @@ export function channelNotificationModelContent(params = {}) {
 }
 
 export function shouldMirrorChannelNotificationToPending(meta = {}) {
-  const type = String(meta?.type || '').trim().toLowerCase();
-  return type === 'schedule';
+  // CC parity (reference messageQueueManager.ts): every inbound channel/
+  // schedule notification flows through the single queue — when no live
+  // listener handled it (engine not subscribed yet, pane disposed, headless),
+  // it is mirrored into the session pending queue for the next turn instead
+  // of being dropped. Silent-to-agent stays excluded; the upstream content
+  // gate (channelNotificationModelContent → '') already enforces it, this is
+  // a defensive second gate.
+  return !(meta?.silent_to_agent === true || meta?.silent_to_agent === 'true');
 }

package/src/runtime/shared/llm/http-agent.mjs

@@ -88,6 +88,17 @@ export function getLlmDispatcher() {
       keepAliveTimeout: envInt('MIXDOG_LLM_KEEPALIVE_MS', 60_000),
       keepAliveMaxTimeout: envInt('MIXDOG_LLM_KEEPALIVE_MAX_MS', 90_000),
       connections: envInt('MIXDOG_LLM_CONNECTIONS', 16),
+      // undici defaults both of these to 300s, which beheaded the Anthropic
+      // NON-STREAMING stall fallback (2026-08-03 regex-chess probe:
+      // UND_ERR_HEADERS_TIMEOUT at exactly 300s) — a non-streaming completion
+      // sends NO response headers until generation finishes, so a long silent
+      // generation legitimately exceeds 300s of header wait. Raise both to
+      // 600s: first-byte/idle protection is owned by the app-level watchdogs
+      // (provider first-byte + semantic idle + agent stall abort), which all
+      // fire below this transport ceiling; this layer is only the last-resort
+      // dead-socket bound.
+      headersTimeout: envInt('MIXDOG_LLM_HEADERS_TIMEOUT_MS', 600_000),
+      bodyTimeout: envInt('MIXDOG_LLM_BODY_TIMEOUT_MS', 600_000),
     })
   }
   // mixdog standalone: separate undici instance from Node's fetch undici, so

package/src/session-runtime/lifecycle-api.mjs

@@ -322,8 +322,27 @@ export function createLifecycleApi(deps) {
       const available = listLeadSessions({ refreshFromStorage: true })
         .some(row => row.id === sessionId);
       if (!available) return false;
+      let ownedAgentSessionIds = [];
+      try {
+        const candidates = mgr.listOwnedAgentSessionIds?.(sessionId);
+        if (Array.isArray(candidates)) {
+          ownedAgentSessionIds = [...new Set(candidates
+            .map(clean)
+            .filter(childId => childId && childId !== sessionId && /^[A-Za-z0-9_-]+$/.test(childId)))];
+        }
+      } catch { /* parent deletion remains available if child enumeration fails */ }
       const current = getSession();
-      if (current?.id !== sessionId) return mgr.deleteSession(sessionId) === true;
+      if (current?.id !== sessionId) {
+        const deleted = mgr.deleteSession(sessionId) === true;
+        if (!deleted) return false;
+        // The parent is already irreversibly gone, so child cleanup is
+        // best-effort and idempotent. Any vetoed child becomes sweep-eligible
+        // because its retained-parent proof disappeared with the parent.
+        for (const childId of ownedAgentSessionIds) {
+          try { mgr.deleteSession(childId); } catch {}
+        }
+        return true;
+      }
 
       const cleanupReason = 'desktop-session-delete';
       try {
@@ -339,6 +358,12 @@ export function createLifecycleApi(deps) {
       // immediately would let a late provider/save continuation resurrect the
       // deleted conversation after the user has moved to its replacement.
       if (mgr.closeSession(sessionId, cleanupReason, { tombstone: true }) !== true) return false;
+      // Active parent deletion uses the same durable tombstone boundary for
+      // every linked child. Their files then mature with the parent instead of
+      // disappearing while the parent task is still retained.
+      for (const childId of ownedAgentSessionIds) {
+        try { mgr.closeSession(childId, cleanupReason, { tombstone: true }); } catch {}
+      }
       setSession(null);
       invalidateContextStatusCache();
       invalidatePreSessionToolSurface();

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/tool-catalog-data.mjs

@@ -26,8 +26,11 @@ export const DEFERRED_DEFAULT_READONLY_TOOLS = Object.freeze([
 ]);
 export const DEFERRED_DEFAULT_LEAD_TOOLS = Object.freeze([
   'read', 'code_graph', 'grep', 'find', 'glob', 'list', 'shell', 'task',
-  'explore', 'apply_patch', 'agent', 'recall', 'search', 'web_fetch', 'cwd',
-  'session_manage', 'Skill', 'load_tool',
+  // cwd / session_manage / web_fetch demoted to the deferred manifest 2026-08:
+  // 0 / 0 / 10 calls in a 3-day 7.6k-call trace window; they auto-load on
+  // first direct call.
+  'explore', 'apply_patch', 'agent', 'recall', 'search',
+  'Skill', 'load_tool',
 ]);
 
 export const READONLY_TOOL_NAMES = new Set([

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([
@@ -202,11 +208,13 @@ export function createWorkflowHelpers({ rootDir, dataDir, readMarkdownDocument,
         if (pack && !pack.hidden) byId.set(pack.id, pack);
       }
     }
-    return [...byId.values()].sort((a, b) => {
-      if (a.id === DEFAULT_WORKFLOW_ID) return -1;
-      if (b.id === DEFAULT_WORKFLOW_ID) return 1;
-      return a.name.localeCompare(b.name);
-    });
+    // Solo leads (user decision: solo is the default working mode), the
+    // cowork pack (built-in id `default`) second, then customs alphabetically
+    // — every picker (TUI, desktop sidebar, onboarding) shares this order.
+    const weight = (pack) => pack.id === 'solo' ? 0
+      : (pack.id === DEFAULT_WORKFLOW_ID || pack.id === 'cowork') ? 1 : 2;
+    return [...byId.values()].sort((a, b) =>
+      (weight(a) - weight(b)) || a.name.localeCompare(b.name));
   }
 
   function activeWorkflowId(config) {
@@ -282,16 +290,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/standalone/agent-tool/tag-registry.mjs

@@ -259,7 +259,11 @@ export function createTagRegistry({
       const tag = tagForSession(sessionId);
       tombstoneTerminalSession(tag, sessionId, session);
       clearAgentStatuslineRoute(sessionId);
-      try { mgr.closeSession(sessionId, 'terminal-reap'); } catch {}
+      // Reaping expires only the reusable tag/runtime lease. The transcript is
+      // user-visible from the parent task's agent tab, so terminal cleanup must
+      // never tombstone it ahead of that parent. The normal completion path
+      // unloads immediately; this delayed call is an idempotent race fallback.
+      try { mgr.unloadSessionRuntime?.(sessionId, 'terminal-reap'); } catch {}
     }, reapMs);
     handle.unref?.();
     reapTimers.set(sessionId, handle);

package/src/standalone/explore-tool.mjs

@@ -18,7 +18,7 @@ export const EXPLORE_TOOL = {
   name: 'explore',
   title: 'Explore',
   annotations: { title: 'Explore', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-  description: 'Locator for broad/uncertain targets with no known path, repo or machine-wide (dot dirs included). query[] fans out up to 8 independent facets in parallel.',
+  description: 'Repo- or machine-wide locator (dot dirs included). query[] fans out up to 8 independent facets in parallel.',
   inputSchema: {
     type: 'object',
     properties: {

package/src/tui/dist/index.mjs

@@ -25135,7 +25135,7 @@ function parseAgentResultEnvelope(text, fallback = {}) {
       fast: fallback.fast ?? attrs.fast
     },
     result: body || agentJobStatusText({ status: fallback.status || attrs.status || "completed", taskId: fallback.taskId || attrs.task_id || attrs.taskid || "" }),
-    isError: /^(failed|error|timeout|cancelled|canceled|killed)$/i.test(fallback.status || attrs.status || "")
+    isError: /^(failed|error|timeout|cancelled|canceled|killed|denied)$/i.test(fallback.status || attrs.status || "")
   };
 }
 function parseBackgroundTaskEnvelope(text) {
@@ -25193,7 +25193,7 @@ function parseBackgroundTaskEnvelope(text) {
     },
     result: resultBody || (!errorText ? [status ? `status: ${status}` : "", taskId ? `task_id: ${taskId}` : ""].filter(Boolean).join(" \xB7 ") : ""),
     rawResult: value,
-    isError: /^(failed|error|timeout|cancelled|canceled|killed)$/i.test(status) || /^error:/i.test(body) || Boolean(errorText)
+    isError: /^(failed|error|timeout|cancelled|canceled|killed|denied)$/i.test(status) || /^error:/i.test(body) || Boolean(errorText)
   };
 }
 function isStatusOnlyAgentCompletionNotification(text) {
@@ -25255,7 +25255,7 @@ function parseSyntheticAgentMessage(text) {
       label,
       args: agentArgsWithResultMetadata({ type: agentJob.type || "notification", description: "agent notification" }, agentJob),
       result: result || agentJobStatusText(agentJob) || "agent notification",
-      isError: /^(failed|error|timeout|cancelled|killed)$/i.test(label)
+      isError: /^(failed|error|timeout|cancelled|canceled|killed|denied)$/i.test(label)
     };
   }
   if (/<task-notification\b/i.test(value)) {
@@ -25273,6 +25273,54 @@ function parseSyntheticAgentMessage(text) {
   }
   return null;
 }
+function buildExecutionResponseToolItem(text, {
+  id,
+  responseKey = "",
+  now = Date.now()
+} = {}) {
+  const synthetic = parseSyntheticAgentMessage(text);
+  if (!synthetic) return null;
+  const label = synthetic.label || "notification";
+  const isAgent = synthetic.name === "agent";
+  const args = {
+    ...synthetic.args && typeof synthetic.args === "object" ? synthetic.args : {
+      type: label,
+      task_id: synthetic.taskId || void 0,
+      description: synthetic.summary || "execution notification"
+    },
+    ...isAgent ? { type: "result" } : {}
+  };
+  const rawResult = synthetic.rawResult ?? text;
+  const responseHasBody = /\n\s*\n[\s\S]*\S/.test(String(text || ""));
+  const key = String(responseKey || args.task_id || "").trim();
+  return {
+    kind: "tool",
+    id,
+    name: synthetic.name || "task",
+    args,
+    result: synthetic.result,
+    rawResult,
+    isError: synthetic.isError ?? /^(failed|error|timeout|cancelled|canceled|killed|denied)$/i.test(label),
+    expanded: false,
+    count: 1,
+    completedCount: 1,
+    startedAt: now,
+    completedAt: now,
+    ...isAgent ? {
+      agentDirection: "inbound",
+      agentResponseKey: key,
+      agentResponseHasBody: responseHasBody,
+      agentResponseAggregate: false,
+      agentResponseEntries: [{
+        key,
+        raw: String(rawResult ?? "").trim(),
+        result: synthetic.result,
+        hasBody: responseHasBody,
+        isError: synthetic.isError === true
+      }]
+    } : {}
+  };
+}
 function parseAgentJob(text) {
   const value = String(text || "");
   const idMatch = /^agent task:\s*([^\s]+)/m.exec(value) || /^task_id:\s*([^\s]+)/m.exec(value);
@@ -26573,6 +26621,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 +26635,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 +26665,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 {
       }
@@ -27403,6 +27473,7 @@ function createTurnWatchdog({
 }
 
 // src/tui/engine/turn.mjs
+var STREAM_BATCH_INTERVAL_MS = TUI_FRAME_MS;
 function createRunTurn(bag) {
   const {
     runtime,
@@ -27893,7 +27964,6 @@ function createRunTurn(bag) {
       thinkingSegmentStartedAt = 0;
       return now;
     };
-    const STREAM_BATCH_INTERVAL_MS = 16;
     let _batchTimer = null;
     let _pendingTextFlush = false;
     let _pendingThinkFlush = false;
@@ -30212,6 +30282,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(() => {
@@ -31787,56 +31866,31 @@ async function createEngineSession({
     });
   };
   const pushAsyncAgentResponse = (text, id = nextId(), origin = "injected", metadata = {}) => {
-    const synthetic = parseSyntheticAgentMessage(text);
-    const isAgent = synthetic?.name === "agent";
-    if (!isAgent) return pushUserOrSyntheticItem(text, id, origin);
-    const responseHasBody = /\n\s*\n[\s\S]*\S/.test(String(text || ""));
-    const rawResult = synthetic.rawResult ?? text;
-    const args = {
-      ...synthetic.args && typeof synthetic.args === "object" ? synthetic.args : {},
-      type: "result"
-    };
-    const responseKey = String(metadata.responseKey || metadata.executionId || args.task_id || "").trim();
+    const responseItem = buildExecutionResponseToolItem(text, {
+      id,
+      responseKey: metadata.responseKey || metadata.executionId
+    });
+    if (!responseItem) return pushUserOrSyntheticItem(text, id, origin);
+    if (responseItem.name !== "agent") {
+      pushItem(responseItem);
+      return true;
+    }
     const previous = state.items.at(-1);
     if (previous?.kind === "tool" && previous.agentDirection === "inbound") {
       const patch = appendAgentResponseTail(previous, {
-        key: responseKey,
-        args,
-        result: synthetic.result,
-        rawResult,
-        hasBody: responseHasBody,
-        isError: synthetic.isError === true
+        key: responseItem.agentResponseKey,
+        args: responseItem.args,
+        result: responseItem.result,
+        rawResult: responseItem.rawResult,
+        hasBody: responseItem.agentResponseHasBody,
+        isError: responseItem.isError
       });
       if (patch) {
         patchItem(previous.id, patch);
         return true;
       }
     }
-    pushItem({
-      kind: "tool",
-      id,
-      name: "agent",
-      args,
-      result: synthetic.result,
-      rawResult,
-      isError: synthetic.isError === true,
-      expanded: false,
-      count: 1,
-      completedCount: 1,
-      startedAt: Date.now(),
-      completedAt: Date.now(),
-      agentDirection: "inbound",
-      agentResponseKey: responseKey,
-      agentResponseHasBody: responseHasBody,
-      agentResponseAggregate: false,
-      agentResponseEntries: [{
-        key: responseKey,
-        raw: String(rawResult ?? "").trim(),
-        result: synthetic.result,
-        hasBody: responseHasBody,
-        isError: synthetic.isError === true
-      }]
-    });
+    pushItem(responseItem);
     return true;
   };
   const pushToast = (text, tone = "info", ttlMs = 3e3) => {

package/src/tui/engine/agent-envelope.mjs

@@ -84,7 +84,7 @@ export function parseAgentResultEnvelope(text, fallback = {}) {
       fast: fallback.fast ?? attrs.fast,
     },
     result: body || agentJobStatusText({ status: fallback.status || attrs.status || 'completed', taskId: fallback.taskId || attrs.task_id || attrs.taskid || '' }),
-    isError: /^(failed|error|timeout|cancelled|canceled|killed)$/i.test(fallback.status || attrs.status || ''),
+    isError: /^(failed|error|timeout|cancelled|canceled|killed|denied)$/i.test(fallback.status || attrs.status || ''),
   };
 }
 
@@ -143,7 +143,7 @@ export function parseBackgroundTaskEnvelope(text) {
     },
     result: resultBody || (!errorText ? [status ? `status: ${status}` : '', taskId ? `task_id: ${taskId}` : ''].filter(Boolean).join(' · ') : ''),
     rawResult: value,
-    isError: /^(failed|error|timeout|cancelled|canceled|killed)$/i.test(status) || /^error:/i.test(body) || Boolean(errorText),
+    isError: /^(failed|error|timeout|cancelled|canceled|killed|denied)$/i.test(status) || /^error:/i.test(body) || Boolean(errorText),
   };
 }
 
@@ -223,7 +223,7 @@ export function parseSyntheticAgentMessage(text) {
       label,
       args: agentArgsWithResultMetadata({ type: agentJob.type || 'notification', description: 'agent notification' }, agentJob),
       result: result || agentJobStatusText(agentJob) || 'agent notification',
-      isError: /^(failed|error|timeout|cancelled|killed)$/i.test(label),
+      isError: /^(failed|error|timeout|cancelled|canceled|killed|denied)$/i.test(label),
     };
   }
   if (/<task-notification\b/i.test(value)) {
@@ -242,6 +242,55 @@ export function parseSyntheticAgentMessage(text) {
   return null;
 }
 
+export function buildExecutionResponseToolItem(text, {
+  id,
+  responseKey = '',
+  now = Date.now(),
+} = {}) {
+  const synthetic = parseSyntheticAgentMessage(text);
+  if (!synthetic) return null;
+  const label = synthetic.label || 'notification';
+  const isAgent = synthetic.name === 'agent';
+  const args = {
+    ...(synthetic.args && typeof synthetic.args === 'object' ? synthetic.args : {
+      type: label,
+      task_id: synthetic.taskId || undefined,
+      description: synthetic.summary || 'execution notification',
+    }),
+    ...(isAgent ? { type: 'result' } : {}),
+  };
+  const rawResult = synthetic.rawResult ?? text;
+  const responseHasBody = /\n\s*\n[\s\S]*\S/.test(String(text || ''));
+  const key = String(responseKey || args.task_id || '').trim();
+  return {
+    kind: 'tool',
+    id,
+    name: synthetic.name || 'task',
+    args,
+    result: synthetic.result,
+    rawResult,
+    isError: synthetic.isError ?? /^(failed|error|timeout|cancelled|canceled|killed|denied)$/i.test(label),
+    expanded: false,
+    count: 1,
+    completedCount: 1,
+    startedAt: now,
+    completedAt: now,
+    ...(isAgent ? {
+      agentDirection: 'inbound',
+      agentResponseKey: key,
+      agentResponseHasBody: responseHasBody,
+      agentResponseAggregate: false,
+      agentResponseEntries: [{
+        key,
+        raw: String(rawResult ?? '').trim(),
+        result: synthetic.result,
+        hasBody: responseHasBody,
+        isError: synthetic.isError === true,
+      }],
+    } : {}),
+  };
+}
+
 export function parseAgentJob(text) {
   const value = String(text || '');
   const idMatch = /^agent task:\s*([^\s]+)/m.exec(value) || /^task_id:\s*([^\s]+)/m.exec(value);

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;
   });
 }