mixdog 0.9.95 → 0.9.97

package/src/tui/{engine → session}/session-api.mjs

@@ -1,26 +1,16 @@
 /**
- * src/tui/engine/session-api.mjs - part of the public engine session object.
+ * src/tui/session/session-api.mjs - part of the public session runtime session object.
  */
 import { compactEventDetail, projectNameFromPath } from './labels.mjs';
 import { toolErrorDisplay } from './tool-result-text.mjs';
 import { isQueuedEntryEditable, promptDisplayText } from './queue-helpers.mjs';
-import { createEngineApiB } from './session-api-ext.mjs';
+import { createSessionApiB } from './session-api-ext.mjs';
 import { buildDoctorReport } from '../app/doctor.mjs';
 import { recomputePromptHistory } from './prompt-history.mjs';
-import { buildMergedPromptHistory, loadPromptHistory } from '../prompt-history-store.mjs';
-import { touchProjectSelected } from '../../standalone/projects.mjs';
+import { appendPromptHistory, buildMergedPromptHistory, loadPromptHistory, promptHistoryKey } from '../prompt-history-store.mjs';
 
-// Upper bound on how long a manual Esc abort may leave the store busy while the
-// in-flight runtime.ask() unwinds. runtime.abort() normally rejects the pending
-// ask within a tick; this is the belt-and-suspenders window before the bounded
-// recovery timer hard-releases busy so Esc can never wedge input forever.
-const MANUAL_ABORT_RECOVERY_MS = (() => {
-  const v = Number(process.env.MIXDOG_MANUAL_ABORT_RECOVERY_MS);
-  return Number.isFinite(v) && v > 0 ? v : 4000;
-})();
-
-export function createEngineApi(bag) {
-  const api = { ...createEngineApiA(bag), ...createEngineApiB(bag) };
+export function createSessionApi(bag) {
+  const api = { ...createSessionApiA(bag), ...createSessionApiB(bag) };
   // One-shot settings/status bundle. On a daemon-backed store every getter is
   // its own serialized round-trip and the settings panel needs a dozen of them,
   // so the panel asks for this instead of fanning out. It calls the SAME
@@ -33,7 +23,7 @@ export function createEngineApi(bag) {
     const snapshot = {
       autoClear: await read(api.getAutoClear),
       compaction: await read(api.getCompactionSettings),
-      memory: await read(api.getMemorySettings),
+      recap: await read(api.getRecapSettings),
       channels: await read(api.getChannelSettings, { includeStatus: false }),
       systemShell: await read(api.getSystemShell),
       outputStyle: (await read(api.getOutputStyle)) || (await read(api.listOutputStyles)),
@@ -43,7 +33,7 @@ export function createEngineApi(bag) {
       updateSettings: await read(api.getUpdateSettings),
     };
     if (heavy) {
-      snapshot.channelBackend = (await read(api.getChannelSetup))?.backend || 'discord';
+      snapshot.channelProvider = (await read(api.getChannelSetup))?.provider || 'discord';
       snapshot.mcp = await read(api.mcpStatus);
       snapshot.hooks = await read(api.hooksStatus);
       snapshot.plugins = await read(api.pluginsStatus);
@@ -54,31 +44,38 @@ export function createEngineApi(bag) {
   return api;
 }
 
-export function createEngineApiA(bag) {
+export function createSessionApiA(bag) {
   const {
     runtime, nextId, flags, pending, listeners, getState, getPublishedState = getState, set, flushEmitImmediate, pushItem, patchItem, replaceItems, restoreOlderTranscript, restoreNewerTranscript, settleStreamingTail, clearStreamingTail, pushNotice, autoClearState, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, updateAgentJobCard, requeueEntriesFront, enqueue, autoClearBeforeSubmit, restoreQueued, resetStatsAndSyncContext, drain, flushDeferredExecutionPendingResumeKick, discardExecutionPendingResume,
   } = bag;
-  const submit = (text, options = {}) => {
+  const submission = (text, options = {}) => {
     const t = promptDisplayText(text, options).trim();
-    if (!t) return false;
+    if (!t) return null;
     const mode = options.mode || 'prompt';
-   // Prompt input queued while a turn is active keeps the
-   // default `next` priority, so it is injected at the next tool/model
-   // boundary. Explicit options.priority still wins.
+    // Prompt input queued while a turn is active keeps the default `next`
+    // priority, so it is injected at the next tool/model boundary. Explicit
+    // options.priority still wins.
    const priority = options.priority;
-    const queueOptions = {
-      ...options,
-      // Always mint a submission id so daemon retries / dual-path intake
-      // can dedupe instead of booking the same prompt twice.
-      id: String(options.id || '').trim() || nextId(),
-      mode,
-      displayText: promptDisplayText(text, options),
-      priority,
+    return {
+      text,
+      queueOptions: {
+        ...options,
+        // Always mint a submission id so daemon retries / dual-path intake
+        // can dedupe instead of booking the same prompt twice.
+        id: String(options.id || '').trim() || nextId(),
+        mode,
+        displayText: promptDisplayText(text, options),
+        priority,
+      },
     };
+  };
+  const submit = (text, options = {}) => {
+    const intake = submission(text, options);
+    if (!intake) return false;
     // A running clear (idle auto-clear or session_manage) sets commandBusy;
     // queue the prompt instead of dropping it — it drains after the clear.
     if (flags.autoClearRunning) {
-      return enqueue(text, queueOptions) !== false;
+      return enqueue(intake.text, intake.queueOptions) !== false;
     }
     // Any in-flight session command (clear/setModel/newSession/resume/...)
     // holds commandBusy. Previously the prompt was dropped here and only the
@@ -86,17 +83,31 @@ export function createEngineApiA(bag) {
     // commandBusy, and the central release hook re-kicks drain once the
     // command settles, so the prompt runs afterwards rather than vanishing.
     if (getState().commandBusy) {
-      return enqueue(text, queueOptions) !== false;
+      return enqueue(intake.text, intake.queueOptions) !== false;
     }
     if (getState().busy) {
-      return enqueue(text, queueOptions) !== false;
+      return enqueue(intake.text, intake.queueOptions) !== false;
     }
     // If autoClearBeforeSubmit rejects (e.g. compaction timeout throws), the
     // prompt must still be queued — swallow the rejection so enqueue always
     // runs and the submit is never silently lost.
-    void autoClearBeforeSubmit().catch(() => {}).then(() => enqueue(text, queueOptions));
+    void autoClearBeforeSubmit().catch(() => {}).then(
+      () => enqueue(intake.text, intake.queueOptions),
+    );
     return true;
   };
+  const submitAsync = async (text, options = {}) => {
+    const intake = submission(text, options);
+    if (!intake) return false;
+    // Daemon intake needs an acknowledgement boundary stronger than the TUI's
+    // synchronous submit(): by the time this Promise resolves, the prompt is
+    // present either as a visible queue entry or as the first durable user row.
+    // Provider execution still runs detached through drain().
+    if (!flags.autoClearRunning && !getState().commandBusy && !getState().busy) {
+      await autoClearBeforeSubmit().catch(() => {});
+    }
+    return enqueue(intake.text, intake.queueOptions) !== false;
+  };
   return {
     getState: () => getPublishedState(),
     patchItem,
@@ -107,7 +118,7 @@ export function createEngineApiA(bag) {
       return () => listeners.delete(listener);
     },
     submit,
-    submitAsync: async (text, options = {}) => submit(text, options),
+    submitAsync,
     reserveSession: (sessionId) => {
       const id = runtime.reserveSessionId?.(sessionId);
       if (!id) return false;
@@ -116,6 +127,46 @@ export function createEngineApiA(bag) {
       return String(getState().sessionId || '') === String(id);
     },
     restoreQueued,
+    // Claude Code's message selector ("jump back to a previous message"):
+    // rewind the conversation to just before a user prompt and hand its text
+    // back for editing. Idle-only — a live turn must be interrupted first.
+    rewindToItem: async (itemId) => {
+      const target = String(itemId ?? '').trim();
+      if (!target) return null;
+      if (getState().busy || getState().commandBusy) return null;
+      const items = getState().items || [];
+      const index = items.findIndex(
+        (item) => item?.kind === 'user' && String(item?.id) === target,
+      );
+      if (index < 0) return null;
+      const text = String(items[index]?.text || '').trim();
+      if (!text) return null;
+      set({ commandBusy: true });
+      try {
+        const rewound = await runtime.rewindMessages?.({ text });
+        if (!rewound) return null;
+        const restoreKey = promptHistoryKey(text);
+        set({
+          items: replaceItems(items.slice(0, index), {
+            preserveSpill: true,
+            preserveTranscriptView: true,
+          }),
+          spinner: null,
+          thinking: null,
+          lastTurn: null,
+          // The prompt returns to the draft, so it must not ALSO sit in the
+          // Up-arrow history — otherwise it shows up twice.
+          promptHistoryList: (getState().promptHistoryList || [])
+            .filter((entry) => promptHistoryKey(entry) !== restoreKey),
+        });
+        syncContextStats({ allowEstimated: true });
+        set({ stats: { ...getState().stats } });
+        flushEmitImmediate?.();
+        return { text, removed: items.length - index, messages: rewound.removed };
+      } finally {
+        set({ commandBusy: false });
+      }
+    },
     setModel: async (m) => {
       if (getState().commandBusy) return false;
       set({ commandBusy: true });
@@ -209,14 +260,14 @@ export function createEngineApiA(bag) {
         set({ commandBusy: false });
       }
     },
-    getMemorySettings: () => {
-      return runtime.getMemorySettings?.() || { enabled: true };
+    getRecapSettings: () => {
+      return runtime.getRecapSettings?.() || { enabled: true };
     },
-    setMemoryEnabled: async (enabled) => {
+    setRecapEnabled: async (enabled) => {
       if (getState().commandBusy) return null;
       set({ commandBusy: true });
       try {
-        const next = await runtime.setMemoryEnabled?.(enabled);
+        const next = await runtime.setRecapEnabled?.(enabled);
         set({ ...routeState(), stats: { ...getState().stats } });
         // Deferred for the same reason as setCompactionSettings above: keep
         // the recompute off the key-handler tick so the toggle repaints
@@ -296,12 +347,6 @@ export function createEngineApiA(bag) {
     },
     setCwd: (path, options = {}) => {
       const next = runtime.setCwd(path);
-      // "Last opened" recency belongs to the ACTUAL cwd switch, not to one
-      // caller: the project picker, its Current Path row and the /cwd prompt
-      // all land here, so the project list stays ordered by what was really
-      // opened last. Unregistered folders are ignored — this never registers
-      // a project on its own (addProject remains the only registration path).
-      try { touchProjectSelected(next); } catch { /* best-effort recency */ }
       // Republish up-arrow history for the NEW project: current session prompts
       // merged with the cwd-scoped persisted store for the new cwd.
       const sessionList = recomputePromptHistory(getState().items);
@@ -311,6 +356,15 @@ export function createEngineApiA(bag) {
       }
       return next;
     },
+    rememberPromptHistory: (value) => {
+      const text = String(value || '').trim();
+      if (!text) return false;
+      const persisted = appendPromptHistory(getState().cwd, text);
+      if (!persisted) return false;
+      const sessionList = recomputePromptHistory(getState().items);
+      set({ promptHistoryList: buildMergedPromptHistory(sessionList, persisted) });
+      return true;
+    },
     getSystemShell: () => {
       return runtime.getSystemShell?.() || runtime.systemShell || { source: 'auto', command: '', effective: '' };
     },
@@ -608,7 +662,7 @@ export function createEngineApiA(bag) {
         set({ commandBusy: false, commandStatus: null });
       }
     },
-    abort: () => {
+    abort: (options = {}) => {
       if (!getState().busy) return false;
       denyAllToolApprovals('interrupted by user');
       const restoreState = flags.activePromptRestore;
@@ -616,7 +670,9 @@ export function createEngineApiA(bag) {
       // interrupting should just cancel the running turn and let the steering
       // prompt run next, NOT resurrect the in-flight prompt back into the draft.
       const hasPendingSteering = pending.some((entry) => isQueuedEntryEditable(entry));
-      const canRestore = restoreState?.restorable && !hasPendingSteering;
+      const canRestore = options?.restorePrompt !== false
+        && restoreState?.restorable
+        && !hasPendingSteering;
       const restoreText = canRestore ? restoreState.text : '';
       const restorePastedImages = canRestore && restoreState?.pastedImages ? restoreState.pastedImages : null;
       const restorePastedTexts = canRestore && restoreState?.pastedTexts ? restoreState.pastedTexts : null;
@@ -644,6 +700,11 @@ export function createEngineApiA(bag) {
           restoreState.reclaimed = true;
           const idSet = new Set((restoreState.submittedIds || []).filter((id) => id != null));
           const patch = { spinner: null, thinking: null, lastTurn: null };
+          if (restoreText) {
+            const restoreKey = promptHistoryKey(restoreText);
+            patch.promptHistoryList = (getState().promptHistoryList || [])
+              .filter((entry) => promptHistoryKey(entry) !== restoreKey);
+          }
           if (idSet.size > 0) {
             const items = getState().items.filter((item) => !idSet.has(item?.id));
             if (items.length !== getState().items.length) {
@@ -660,11 +721,7 @@ export function createEngineApiA(bag) {
         restoreState.requeueEntries = [];
         restoreState.discardExecutionPendingResumeKeys = [];
       }
-      // ── 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
+      // Queued work must never strand behind a cancelled turn
       // (abort preserves pending input for the next turn, and the command
       // queue survives cancel and fires when idle). The
       // drain loop that owns a normal turn continues on its own; this bounded
@@ -679,46 +736,6 @@ export function createEngineApiA(bag) {
         } 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
-      // hard-releases busy exactly like the watchdog force-release, but ONLY
-      // when this same turn is still the active owner (epoch unchanged) AND
-      // still busy — so a normal cancellation that settles in time is never
-      // masked and a newer turn's store is never corrupted.
-      const abortEpoch = flags.leadTurnEpoch;
-      const recoveryMs = Number(flags.manualAbortRecoveryMs) > 0
-        ? Number(flags.manualAbortRecoveryMs)
-        : MANUAL_ABORT_RECOVERY_MS;
-      const recoveryTimer = setTimeout(() => {
-        if (flags.disposed) return;
-        if (!getState().busy) return;                    // normal abort settled
-        if (flags.leadTurnEpoch !== abortEpoch) return;  // a newer turn owns the store
-        const streamingTail = getState().streamingTail;
-        if (streamingTail?.text?.trim()) {
-          settleStreamingTail?.(streamingTail.id, {});
-        } else {
-          clearStreamingTail?.();
-        }
-        // Bump the epoch FIRST so the still-stuck turn's eventual finally becomes
-        // a no-op for shared getState() writes and cannot corrupt the handoff.
-        flags.leadTurnEpoch = (Number(flags.leadTurnEpoch) || 0) + 1;
-        set({ busy: false, spinner: null, thinking: null, lastTurn: null });
-        flags.activePromptRestore = null;
-        // Abandon the drain loop that is still awaiting the stuck turn before
-        // releasing the drain lock. Its eventual finally observes the stale
-        // epoch and cannot clear a newer drain's ownership or continue work.
-        flags.drainEpoch = (Number(flags.drainEpoch) || 0) + 1;
-        if (flags.draining) flags.draining = false;
-        pushNotice('Interrupt did not settle — input restored.', 'warn', { transcript: true });
-        flushEmitImmediate?.();
-        if (pending.length > 0 && typeof drain === 'function') void drain();
-        // busy→false here bypasses the normal turn-end + drain-finally flushes,
-        // so re-arm any deferred completion kick explicitly (idempotent).
-        if (typeof flushDeferredExecutionPendingResumeKick === 'function') flushDeferredExecutionPendingResumeKick();
-      }, recoveryMs);
-      recoveryTimer.unref?.();
       return { aborted, restoreText, pastedImages: restorePastedImages, discardPastedImages, pastedTexts: restorePastedTexts, discardPastedTexts };
     },
   };

package/src/tui/{engine → session}/session-flow.mjs

@@ -1,5 +1,5 @@
 /**
- * src/tui/engine/session-flow.mjs - prompt queue drain + session clear/reset. Extracted from engine.mjs.
+ * src/tui/session/session-flow.mjs - prompt queue drain + session clear/reset. Extracted from session-local.mjs.
  */
 import { presentErrorText } from '../../runtime/shared/err-text.mjs';
 import { resetAllStreamingMarkdownStablePrefixes } from '../markdown/streaming-markdown.mjs';
@@ -560,7 +560,13 @@ export function createSessionFlow(bag) {
     removeQueuedEntries(queued);
     const queuedText = queued.map((item) => item.text).filter((text) => String(text || '').trim()).join('\n');
     const combinedText = [queuedText, String(currentText || '')].filter((text) => text.trim()).join('\n');
-    return { count: queued.length, text: combinedText, pastedImages: mergePastedImages(queued), pastedTexts: mergePastedTexts(queued) };
+    return {
+      count: queued.length,
+      ids: queued.map((item) => String(item.id || '')).filter(Boolean),
+      text: combinedText,
+      pastedImages: mergePastedImages(queued),
+      pastedTexts: mergePastedTexts(queued),
+    };
   }
 
   const resetStats = () => {

package/src/tui/{engine → session}/session-stats.mjs

@@ -1,8 +1,8 @@
 /**
- * src/tui/engine/session-stats.mjs - session-usage accumulator.
+ * src/tui/session/session-stats.mjs - session-usage accumulator.
  *
- * Inlined (not imported from ui/statusline.mjs) so the engine has no static
- * dependency on the vendored statusline closure. Extracted from engine.mjs.
+ * Inlined (not imported from ui/statusline.mjs) so the session runtime has no static
+ * dependency on the vendored statusline closure. Extracted from session-local.mjs.
  */
 export function createSessionStats() {
   return {

package/src/tui/{engine → session}/tool-approval.mjs

@@ -1,12 +1,12 @@
 /**
- * src/tui/engine/tool-approval.mjs — tool-approval queue plumbing extracted
- * from createEngineSession (engine.mjs) as a dependency-injection factory.
+ * src/tui/session/tool-approval.mjs — tool-approval queue plumbing extracted
+ * from the session runtime as a dependency-injection factory.
  *
  * These handlers drive a small FIFO of hook approval requests and reflect the
  * active one into store state (state.toolApproval). They need live session
  * state, so the closure identifiers (state/set/nextId/disposed/timeout) are
  * threaded through the factory argument via getters — never stale snapshots.
- * Every body is the original engine.mjs logic verbatim.
+ * Every body is the original session-local.mjs logic verbatim.
  */
 export function createToolApproval({ getState, set, nextId, getDisposed, timeoutMs }) {
   const toolApprovalQueue = [];

package/src/tui/{engine → session}/tool-call-fields.mjs

@@ -1,6 +1,6 @@
 /**
- * src/tui/engine/tool-call-fields.mjs - accessors for the varied tool-call /
- * tool-result id/name/arg shapes across providers. Extracted from engine.mjs.
+ * src/tui/session/tool-call-fields.mjs - accessors for the varied tool-call /
+ * tool-result id/name/arg shapes across providers. Extracted from session-local.mjs.
  */
 export function toolCallId(call) {
   return call?.id ?? call?.toolCallId ?? call?.tool_call_id ?? call?.call_id;

package/src/tui/{engine → session}/tool-card-results.mjs

@@ -1,17 +1,17 @@
 /**
- * src/tui/engine/tool-card-results.mjs — the tool-card result state machine
- * (patchToolCardResult + flushToolResults) extracted from createEngineSession
- * (engine.mjs) as a dependency-injection factory.
+ * src/tui/session/tool-card-results.mjs — the tool-card result state machine
+ * (patchToolCardResult + flushToolResults) extracted from the session runtime
+ * (session-local.mjs) as a dependency-injection factory.
  *
  * These handlers own the per-turn accounting that reflects tool results into
  * store items: aggregate cards, non-aggregate/legacy agent-job cards, grouped
  * fallbacks, and the finalize/cancelled sweeps. They mutate live session state,
  * so state/set/patchItem/markToolCallDone/updateAgentJobCard are threaded via
  * the factory argument (getters/callbacks) — never stale snapshots. Every body
- * is the original engine.mjs logic verbatim.
+ * is the original session-local.mjs logic verbatim.
  */
 import { summarizeToolResult, aggregateDoneCategories } from '../../runtime/shared/tool-surface.mjs';
-import { toolResultText, toolErrorDisplay, toolGroupedDisplayFallback } from './tool-result-text.mjs';
+import { toolResultText, toolErrorDisplay, toolGroupedDisplayFallback, stripShellExitHeader } from './tool-result-text.mjs';
 import { toolResultCallId } from './tool-call-fields.mjs';
 import { parseAgentJob } from './agent-envelope.mjs';
 import {
@@ -82,7 +82,9 @@ export function createToolCardResults({
     // outcomes remain successful calls with their raw/semantic result detail.
     const { exitCode, isExitError, isCallError } = toolCallOutcome(message, rawText);
     const isError = isCallError;
-    const text = isError ? toolErrorDisplay(rawText, card?.name || 'tool') : rawText;
+    const text = isError
+      ? toolErrorDisplay(rawText, card?.name || 'tool')
+      : (isExitError ? stripShellExitHeader(rawText) : rawText);
 
     if (aggregate && card.itemId === aggregate.itemId) {
       if (!callRec) return false;

package/src/tui/{engine → session}/tool-result-status.mjs

@@ -1,10 +1,10 @@
 /**
- * src/tui/engine/tool-result-status.mjs — pure tool-result status + aggregate
- * text helpers extracted from createEngineSession (engine.mjs).
+ * src/tui/session/tool-result-status.mjs — pure tool-result status + aggregate
+ * text helpers extracted from the session runtime.
  *
  * These functions were function-declared inside the closure but reference only
  * their arguments plus toolErrorDisplay (imported below) — no session state —
- * so they move out verbatim as free functions. engine.mjs imports them and
+ * so they move out verbatim as free functions. session-local.mjs imports them and
  * keeps calling them unchanged.
  */
 import { toolErrorDisplay } from './tool-result-text.mjs';
@@ -28,7 +28,7 @@ export function shellCommandExitCode(text) {
   // `Error: [shell-run-failed] [exit code: N]` as the leading marker header.
   if (!/^\s*(?:Error:\s*)?\[shell-run-failed\]/i.test(body)) return null;
   // Restrict marker parsing to the header region (first line) so only the
-  // engine-emitted status header — not quoted command output below — counts.
+  // session runtime-emitted status header — not quoted command output below — counts.
   const header = body.split('\n', 1)[0] || '';
   // Timeout / signal / abort are NOT a plain command exit — keep them "Failed".
   if (/\[timeout:|\[signal:|timed out|aborted|interrupted/i.test(header)) return null;
@@ -93,7 +93,7 @@ export function withCancelledResultMarker(text, item) {
   // Do NOT inspect item.rawResult here: aggregate rawResult is child tool
   // output (`1. grep\n<result>…`) that can incidentally contain a `status:`
   // line, which would false-positive as an already-terminal status and skip
-  // the cancelled marker. Only result/text/body are engine-controlled
+  // the cancelled marker. Only result/text/body are session runtime-controlled
   // collapsed detail (empty / status word / an existing marker), so they are
   // the trustworthy terminal-status sources.
   const sources = [item?.result, item?.text, body];

package/src/tui/{engine → session}/tool-result-text.mjs

@@ -1,8 +1,8 @@
 /**
- * src/tui/engine/tool-result-text.mjs - flatten tool-result content shapes into
+ * src/tui/session/tool-result-text.mjs - flatten tool-result content shapes into
  * display text, plus collapsed-detail/grouped fallbacks and error framing.
- * Extracted from engine.mjs; toolResultText/toolAggregateDetailFallback/
- * toolGroupedDisplayFallback remain part of engine.mjs's public surface.
+ * Extracted from session-local.mjs; toolResultText/toolAggregateDetailFallback/
+ * toolGroupedDisplayFallback remain part of session-local.mjs's public surface.
  */
 import { presentErrorText } from '../../runtime/shared/err-text.mjs';
 
@@ -124,3 +124,13 @@ export function toolErrorDisplay(value, surface = 'tool') {
   }
   return /^error\s*:/i.test(text) ? text : `Error: ${text}`;
 }
+
+// Display-only: a command-exit card already renders `Exit N` as its state, so
+// the machine header (`Error: [shell-run-failed] [exit code: N]`) is redundant
+// in the body — and the bare word "Error" reads as a tool failure even though
+// the tool ran fine and the command merely exited non-zero. The model-facing
+// result keeps the header untouched; only the rendered body drops it.
+export function stripShellExitHeader(text) {
+  const body = String(text ?? '');
+  return body.replace(/(^|\n)(?:Error:\s*)?\[shell-run-failed\][^\n]*\n{0,2}/i, '$1');
+}

package/src/tui/{engine → session}/transcript-spill.mjs

@@ -1,15 +1,15 @@
-// Transcript spill buffer + engine item state, extracted from engine.mjs.
+// Transcript spill buffer + session runtime item state, extracted from session-local.mjs.
 /**
- * src/tui/engine.mjs - the engine<->React bridge (React-free).
+ * src/tui/session-local.mjs - the session runtime<->React bridge (React-free).
  *
  * Runs mixdog's session manager outside React and exposes a tiny subscribable
  * store. The React/ink layer consumes it via useSyncExternalStore
- * (see hooks/useEngine.mjs).
+ * (see hooks/useSession.mjs).
  *
- * Pure/stateless helpers live in ./engine/* (boot-profile, session-stats,
+ * Pure/stateless helpers live in ./session/* (boot-profile, session-stats,
  * labels, notice-text, tool-result-text, tool-call-fields, agent-envelope,
  * queue-helpers) and are re-exported here so the public surface is unchanged.
- * This file keeps the stateful createEngineSession store + notification plan.
+ * This file keeps the stateful session store + notification plan.
  */
 import { performance } from 'node:perf_hooks';
 import { mkdtempSync, readFileSync, readdirSync, rmSync, statSync, watch, writeFileSync } from 'node:fs';
@@ -32,8 +32,8 @@ import { presentErrorText } from '../../runtime/shared/err-text.mjs';
 import { sessionPath } from '../../runtime/agent/orchestrator/session/store/paths-heartbeat.mjs';
 import { listThemes, getThemeSetting, setThemeSetting } from '../theme.mjs';
 import { resetAllStreamingMarkdownStablePrefixes } from '../markdown/streaming-markdown.mjs';
-import { bootProfile } from '../engine/boot-profile.mjs';
-import { createSessionStats, applyUsageDelta } from '../engine/session-stats.mjs';
+import { bootProfile } from '../session/boot-profile.mjs';
+import { createSessionStats, applyUsageDelta } from '../session/session-stats.mjs';
 import {
   pickVerb,
   pickDoneVerb,
@@ -41,26 +41,26 @@ import {
   compactEventLabel,
   compactEventDetail,
   projectNameFromPath,
-} from '../engine/labels.mjs';
-import { polishNoticeText } from '../engine/notice-text.mjs';
+} from '../session/labels.mjs';
+import { polishNoticeText } from '../session/notice-text.mjs';
 import {
   toolResultText,
   toolAggregateDetailFallback,
   toolGroupedDisplayFallback,
   toolErrorDisplay,
-} from '../engine/tool-result-text.mjs';
+} from '../session/tool-result-text.mjs';
 import {
   toolCallId,
   toolResultCallId,
   toolCallName,
   toolCallArgs,
-} from '../engine/tool-call-fields.mjs';
+} from '../session/tool-call-fields.mjs';
 import {
   parseBackgroundTaskEnvelope,
   parseSyntheticAgentMessage,
   toolResultStatus,
   isErrorToolStatus,
-} from '../engine/agent-envelope.mjs';
+} from '../session/agent-envelope.mjs';
 import {
   queuePriorityValue,
   defaultQueuePriority,
@@ -74,39 +74,39 @@ import {
   mergePastedImages,
   mergePastedTexts,
   callCommitCallbacks,
-} from '../engine/queue-helpers.mjs';
+} from '../session/queue-helpers.mjs';
 import {
   resolveTuiRuntimeNotificationDelivery,
-} from '../engine/notification-plan.mjs';
-import { yieldToRenderer } from '../engine/render-timing.mjs';
+} from '../session/notification-plan.mjs';
+import { yieldToRenderer } from '../session/render-timing.mjs';
 import {
   aggregateRawResult,
   aggregateBucketForCategory,
   aggregateSummaries,
   assignAggregateSummaryOrder,
-} from '../engine/tool-result-status.mjs';
-import { createToolApproval } from '../engine/tool-approval.mjs';
-import { createToolCardResults } from '../engine/tool-card-results.mjs';
-import { createAgentJobFeed } from '../engine/agent-job-feed.mjs';
-import { appendAgentResponseTail } from '../engine/agent-response-tail.mjs';
+} from '../session/tool-result-status.mjs';
+import { createToolApproval } from '../session/tool-approval.mjs';
+import { createToolCardResults } from '../session/tool-card-results.mjs';
+import { createAgentJobFeed } from '../session/agent-job-feed.mjs';
+import { appendAgentResponseTail } from '../session/agent-response-tail.mjs';
 import {
   appendTuiSteeringPersist,
   dropTuiSteeringPersist,
   drainTuiSteeringPersist,
   flushTuiSteeringPersist,
-} from '../engine/tui-steering-persist.mjs';
-import { createContextState } from '../engine/context-state.mjs';
-import { recomputePromptHistory } from '../engine/prompt-history.mjs';
+} from '../session/tui-steering-persist.mjs';
+import { createContextState } from '../session/context-state.mjs';
+import { recomputePromptHistory } from '../session/prompt-history.mjs';
 import {
   appendPromptHistory,
   buildMergedPromptHistory,
   loadPromptHistory,
 } from '../prompt-history-store.mjs';
-import { createSessionFlow } from '../engine/session-flow.mjs';
-import { createRunTurn } from '../engine/turn.mjs';
-import { createEngineApi } from '../engine/session-api.mjs';
-import { createFrameBatchedStorePublisher } from '../engine/frame-batched-store.mjs';
-import { createLiveShare, liveSharePipePath } from '../engine/live-share.mjs';
+import { createSessionFlow } from '../session/session-flow.mjs';
+import { createRunTurn } from '../session/turn.mjs';
+import { createSessionApi } from '../session/session-api.mjs';
+import { createFrameBatchedStorePublisher } from '../session/frame-batched-store.mjs';
+import { createLiveShare, liveSharePipePath } from '../session/live-share.mjs';
 import { displayModelName } from '../../ui/model-display.mjs';
 
 export const TUI_DEBUG = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_TUI_DEBUG || ''));
@@ -484,14 +484,14 @@ export function refillTranscriptViewOverlap(viewItems, previousLiveItems, nextLi
 }
 
 // Re-export the shared tool-result/notification helpers so importers (and tests)
-// keep resolving them from engine.mjs unchanged.
+// keep resolving them from session-local.mjs unchanged.
 export { toolResultText, toolAggregateDetailFallback, toolGroupedDisplayFallback };
 export { parseBackgroundTaskEnvelope };
-// Re-export the pure notification delivery plan (moved to ./engine/notification-plan.mjs)
-// so importers/tests keep resolving resolveTuiRuntimeNotificationDelivery from engine.mjs.
+// Re-export the pure notification delivery plan (moved to ./session/notification-plan.mjs)
+// so importers/tests keep resolving resolveTuiRuntimeNotificationDelivery from session-local.mjs.
 export { resolveTuiRuntimeNotificationDelivery };
 
-export function replaceEngineItemsState({
+export function replaceSessionItemsState({
   state,
   items,
   itemIndexById,
@@ -513,9 +513,9 @@ export function replaceEngineItemsState({
   };
 }
 
-// Shared by the live engine and focused transcript tests so revision/tail
+// Shared by the live session runtime and focused transcript tests so revision/tail
 // regressions exercise the exact mutation implementation used in production.
-export function createEngineItemMutators({
+export function createSessionItemMutators({
   getState,
   set,
   itemIndexById,