mixdog 0.9.96 → 0.9.99

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,

package/src/tui/{engine → session}/turn.mjs

@@ -1,24 +1,23 @@
 /**
- * src/tui/engine/turn.mjs - lead TUI turn engine (createRunTurn). Extracted from engine.mjs.
+ * src/tui/session/turn.mjs - lead TUI turn session runtime (createRunTurn). Extracted from session-local.mjs.
  */
-import { aggregateToolCategoryEntry, aggregateDoneCategories, classifyToolCategory, formatAggregateDetail, summarizeToolResult } from '../../runtime/shared/tool-surface.mjs';
+import { aggregateToolCategoryEntries, aggregateDoneCategories, classifyToolCategory, formatAggregateDetail, summarizeToolResult } from '../../runtime/shared/tool-surface.mjs';
 import { applyUsageDelta } from './session-stats.mjs';
 import { pickVerb, pickDoneVerb, compactEventLabel, compactEventDetail } from './labels.mjs';
 import { toolResultText, toolErrorDisplay, stripShellExitHeader } from './tool-result-text.mjs';
 import { toolCallId, toolResultCallId, toolCallName, toolCallArgs } from './tool-call-fields.mjs';
 import { promptDisplayText, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
 import { TUI_FRAME_MS, yieldToRenderer } from './render-timing.mjs';
-import { createTurnWatchdog } from './turn-watchdog.mjs';
 import { aggregateRawResult, aggregateBucketForCategory, aggregateSummaries, assignAggregateSummaryOrder, failureDetailText, toolCallOutcome } from './tool-result-status.mjs';
 
 export const STREAM_BATCH_INTERVAL_MS = TUI_FRAME_MS;
 
 export function createRunTurn(bag) {
   const {
-    runtime, nextId, tuiDebug, LEAD_TURN_TIMEOUT_MS, flags, pending, itemIndexById, getState, set, flushEmit, flushEmitImmediate, pushItem, appendItems, patchItem, replaceItems, updateStreamingTail: updateStreamingTailFromStore, settleStreamingTail: settleStreamingTailFromStore, clearStreamingTail: clearStreamingTailFromStore, pushNotice, pushUserOrSyntheticItem, markToolCallActive, markToolCallDone, clearActiveToolSummary, agentStatusState, routeState, transcriptRouteMetadata, syncContextStats, denyAllToolApprovals, requestToolApproval, patchToolCardResult, flushToolResults, flushDeferredExecutionPendingResumeKick, drain, drainPendingSteering,
+    runtime, nextId, tuiDebug, flags, pending, itemIndexById, getState, set, flushEmit, flushEmitImmediate, pushItem, appendItems, patchItem, replaceItems, updateStreamingTail: updateStreamingTailFromStore, settleStreamingTail: settleStreamingTailFromStore, clearStreamingTail: clearStreamingTailFromStore, pushNotice, pushUserOrSyntheticItem, markToolCallActive, markToolCallDone, clearActiveToolSummary, agentStatusState, routeState, transcriptRouteMetadata, syncContextStats, denyAllToolApprovals, requestToolApproval, patchToolCardResult, flushToolResults, flushDeferredExecutionPendingResumeKick, drainPendingSteering,
   } = bag;
   // Small fallbacks keep isolated createRunTurn harnesses source-compatible;
-  // the real engine supplies atomic implementations that also maintain revision.
+  // the real session runtime supplies atomic implementations that also maintain revision.
   const updateStreamingTail = updateStreamingTailFromStore || ((id, patch = {}, extra = {}) => {
     set({
       streamingTail: { ...(getState().streamingTail || {}), ...patch, kind: 'assistant', id, streaming: true },
@@ -48,11 +47,8 @@ export function createRunTurn(bag) {
     const turnTranscriptMeta = { ...baseTranscriptMeta, completionVerb };
     flags.pendingTranscriptMeta = null;
     const { at: _userItemAt, ...turnRouteMeta } = turnTranscriptMeta;
-    // Per-turn epoch. Force-release (watchdog grace) bumps the shared counter so
-    // this turn's own eventual `finally` — which may run LONG after force-release
-    // already started a new turn that reuses the per-session mutex — can detect
-    // it is stale and skip all shared-getState() writes (busy, flags.activePromptRestore,
-    // turndone, drain kick). Neutralizes the stale unwind without touching the mutex.
+    // Per-turn epoch prevents a disposed/replaced surface from publishing a
+    // terminal snapshot after another turn has become the visible owner.
     const turnEpoch = ++flags.leadTurnEpoch;
     const isCurrentTurn = () => !flags.disposed && flags.leadTurnEpoch === turnEpoch;
     const inputBaseline = getState().stats.inputTokens;
@@ -79,80 +75,8 @@ export function createRunTurn(bag) {
     let assistantText = '';
     let currentAssistantId = null;
 
-    tuiDebug(`runTurn start turn=${turnIndex} pending=${pending.length} timeoutMs=${LEAD_TURN_TIMEOUT_MS}`);
-    // ── Idle watchdog ─────────────────────────────────────────────────────
-    // If this turn stops making observable progress (provider call stuck),
-    // trip after the cap: abort the in-flight run via the existing interrupt
-    // path (runtime.abort, the same one Esc uses), which rejects the pending
-    // runtime.ask() with a SessionClosedError so the normal cancelled-turn
-    // teardown runs. Keep this progress-based rather than total wall-clock:
-    // long multi-tool turns can legitimately exceed 5m while still producing
-    // model/tool events.
-    let watchdogGraceTimer = null;
-    const configuredLeadToolMaxMs = Number(process.env.MIXDOG_LEAD_TOOL_MAX_MS);
-    const leadToolMaxMs = Number.isFinite(configuredLeadToolMaxMs) && configuredLeadToolMaxMs > 0
-      ? configuredLeadToolMaxMs
-      : 30 * 60 * 1000;
-    // Scheduling/liveness lives in turn-watchdog.mjs; the trip ACTION stays here
-    // because it unwinds this turn's UI state.
-    const watchdog = createTurnWatchdog({
-      runtime,
-      timeoutMs: LEAD_TURN_TIMEOUT_MS,
-      toolMaxMs: leadToolMaxMs,
-      isCurrentTurn,
-      onTrip: ({ idleMs, lastProgressLabel }) => {
-        if (_batchTimer !== null) {
-          clearTimeout(_batchTimer);
-          _batchTimer = null;
-        }
-        _pendingTextFlush = false;
-        _pendingThinkFlush = false;
-        _pendingThinkingLastEndedAt = 0;
-        const elapsed = Date.now() - startedAt;
-        tuiDebug(`runTurn WATCHDOG TRIP turn=${turnIndex} elapsedMs=${elapsed} idleMs=${idleMs} lastProgress=${lastProgressLabel} — aborting stuck turn`);
-        pushNotice(`Turn timed out after ${Math.round(idleMs / 1000)}s idle (last progress: ${lastProgressLabel}) — aborting stuck request. Input will be released shortly if abort does not unwind.`, 'warn', { transcript: true });
-        try { runtime.abort('watchdog'); } catch {}
-        // Belt-and-suspenders: if runtime.abort() did not reject runtime.ask()
-        // (unwind starved), hard-release the turn after a short grace so the
-        // React store is never left with busy=true and no drain in flight.
-        watchdogGraceTimer = setTimeout(() => {
-          if (flags.disposed) return;
-          if (!getState().busy) return;
-          if (flags.leadTurnEpoch !== turnEpoch) return; // a newer turn already owns the store
-          tuiDebug(`runTurn WATCHDOG FORCE-RELEASE turn=${turnIndex} — abort unwind starved`);
-          denyAllToolApprovals('turn timed out');
-          clearActiveToolSummary();
-          flushToolResults([], toolCards, cardByCallId, toolGroups, resultsDone, { finalize: true, cancelled: true });
-          finalizeToolHeaders();
-          clearDeferredTimers();
-          flags.flushDeferredBeforeImmediatePush = null;
-          if (currentAssistantId && currentAssistantText.trim()) {
-            settleStreamingTail(currentAssistantId, { text: currentAssistantText });
-          } else {
-            clearStreamingTail(currentAssistantId);
-          }
-          // Bump the epoch FIRST so this (still-stuck) turn's later finally becomes
-          // a no-op for shared getState() and cannot corrupt the turn we hand off to.
-          flags.leadTurnEpoch++;
-          set({ busy: false, spinner: null, thinking: null, lastTurn: null });
-          flags.activePromptRestore = null;
-          if (flags.draining) flags.draining = false;
-          if (pending.length > 0) void drain();
-          // busy→false here bypasses both the normal turn-end flush and the
-          // drain-finally flush, so a deferred completion kick would never re-arm.
-          // Fire it explicitly (idempotent: guarded by deferred flag + !busy).
-          flushDeferredExecutionPendingResumeKick();
-          flushEmitImmediate?.();
-        }, 5_000);
-        watchdogGraceTimer.unref?.();
-      },
-    });
-    const clearWatchdog = () => {
-      watchdog.clear();
-      if (watchdogGraceTimer) { clearTimeout(watchdogGraceTimer); watchdogGraceTimer = null; }
-    };
-    const markTurnProgress = (label) => watchdog.markProgress(label);
-    watchdog.arm();
+    tuiDebug(`runTurn start turn=${turnIndex} pending=${pending.length}`);
+    const markTurnProgress = () => isCurrentTurn();
     let currentAssistantText = '';
     // Segments sealed as their own assistant item(s) this turn via
     // commitAssistantSegment (e.g. a tool preamble, then a no-newline tail
@@ -585,11 +509,11 @@ export function createRunTurn(bag) {
     let _lastNewlineIdx = -1;      // offset of the last completed-line '\n' found so far
     let _emittedNewlineIdx = -2;   // newline offset backing _emittedVisibleText (-2 forces first compute)
     let _emittedVisibleText = '';  // cached visible slice for the current newline offset
-    // Engine-local streaming scalars. Neither responseLength nor thinkingText is
+    // Session runtime-local streaming scalars. Neither responseLength nor thinkingText is
     // rendered per-token by any consumer: App reads getState().thinking only as a
     // boolean (App.jsx `!!(getState().thinking || liveSpinner?.thinking)`) and the
     // Spinner takes outputTokens, not responseLength. So we keep these growing
-    // values in engine-local vars and publish to the store only on a visible
+    // values in session runtime-local vars and publish to the store only on a visible
     // transition (thinking on↔off), a completed visible text line, tool/usage
     // updates, or finalization — not on every 8ms streaming flush.
     let _publishedThinkingActive = false; // last thinking boolean pushed to store
@@ -690,7 +614,7 @@ export function createRunTurn(bag) {
         // reads the thinking flag + timing anchors — none of them render the
         // growing thinkingText. So publish the thinking boolean only on the
         // OFF→ON transition (or when compacting toggles the flag), not on every
-        // 8ms reasoning chunk. The full thinkingText stays engine-local and is
+        // 8ms reasoning chunk. The full thinkingText stays session runtime-local and is
         // emitted at finalize via the normal spinner/thinking teardown.
         const nextThinkingActive = !compactingActive;
         // Skip the push when the published thinking boolean is unchanged: neither
@@ -909,10 +833,11 @@ export function createRunTurn(bag) {
             const bucket = aggregateBucketForCategory(category, { agentBatch });
             const callId = toolCallId(c);
             const callKey = callId || `__tool_${toolCards.length}_${i}`;
-            // The old App scan counted multi-pattern calls via
-            // aggregateToolCategoryEntry(...).count, not a flat 1. Derive the same
+            // The old App scan counted multi-pattern calls via category work
+            // units, not a flat 1. Derive the same
             // count here so the incremental Explore/Search summary matches.
-            const activeCount = Number(aggregateToolCategoryEntry(name, args, category)?.count || 1);
+            const categoryEntries = aggregateToolCategoryEntries(name, args, category);
+            const activeCount = categoryEntries.reduce((total, entry) => total + Number(entry.count || 1), 0);
             // Track Explore/Search calls as active for the incremental prompt-
             // line summary; cleared when their result lands or the turn ends.
             markToolCallActive(callKey, category, activeCount, Date.now());
@@ -961,15 +886,16 @@ export function createRunTurn(bag) {
               continue;
             }
 
-            const categoryEntry = aggregateToolCategoryEntry(name, args, category);
             const aggregateCard = ensureAggregateCard(bucket);
             if (shellAfterEdit) aggregateCard.verifyShell = true;
-            if (!aggregateCard.categories.has(categoryEntry.key)) aggregateCard.categoryOrder.push(categoryEntry.key);
-            const prevCategory = aggregateCard.categories.get(categoryEntry.key);
-            aggregateCard.categories.set(categoryEntry.key, {
-              ...categoryEntry,
-              count: Number(prevCategory?.count || 0) + Number(categoryEntry.count || 1),
-            });
+            for (const categoryEntry of categoryEntries) {
+              if (!aggregateCard.categories.has(categoryEntry.key)) aggregateCard.categoryOrder.push(categoryEntry.key);
+              const prevCategory = aggregateCard.categories.get(categoryEntry.key);
+              aggregateCard.categories.set(categoryEntry.key, {
+                ...categoryEntry,
+                count: Number(prevCategory?.count || 0) + Number(categoryEntry.count || 1),
+              });
+            }
             aggregateCard.calls.set(callKey, { name, args, category, summary: null, summarySeq: null, isError: false, isCallError: false, isExitError: false, exitCode: null, resultText: null, resolved: false, completedEarly: false });
             touchedAggregates.add(aggregateCard);
             const card = { itemId: aggregateCard.itemId, callId: callKey, done: false, aggregate: aggregateCard };
@@ -1164,7 +1090,7 @@ export function createRunTurn(bag) {
           flushStreamBatch();
         },
         onReasoningDelta: (chunk) => {
-          if (!isCurrentTurn() || watchdog.tripped) return;
+          if (!isCurrentTurn()) return;
           if (String(chunk ?? '')) {
             if (!markTurnProgress('reasoning-delta')) return;
           }
@@ -1281,13 +1207,9 @@ export function createRunTurn(bag) {
     } finally {
       const isStaleUnwind = !isCurrentTurn();
       if (!isStaleUnwind) denyAllToolApprovals(cancelled ? 'turn cancelled' : 'turn finished');
-      // Turn is unwinding normally (or via abort) — cancel the idle watchdog and
-      // its force-release grace so they never fire on a live turn.
-      clearWatchdog();
       clearLiveTailTimer();
-      // If the watchdog force-release already fired, a NEWER turn now owns the
-      // shared store (busy, flags.activePromptRestore, turndone, drain). This stale
-      // unwind must NOT write shared getState() or it corrupts that turn.
+      // A replaced/disposed surface must not write shared state owned by the
+      // current visible turn.
       let closingItems = [];
       if (deferredEntries.length) {
         if (!isStaleUnwind) {
@@ -1307,7 +1229,7 @@ export function createRunTurn(bag) {
       if (!isStaleUnwind) flags.flushDeferredBeforeImmediatePush = null;
       closeThinkingSegment();
       if (isStaleUnwind) {
-        tuiDebug(`runTurn STALE UNWIND turn=${turnIndex} — force-released; skipping shared UI/state writes`);
+        tuiDebug(`runTurn STALE UNWIND turn=${turnIndex} — skipping shared UI/state writes`);
       } else {
         if (currentAssistantId && getState().streamingTail?.id === currentAssistantId) {
           if (currentAssistantText.trim()) {
@@ -1323,7 +1245,7 @@ export function createRunTurn(bag) {
         flags.activePromptRestore = null;
         const elapsedMs = Date.now() - startedAt;
         const thinkingElapsedMs = thinkingStartedAt ? accumulatedThinkingMs : 0;
-        // responseLength is engine-local now (not pushed per-token), so compute the
+        // responseLength is session runtime-local now (not pushed per-token), so compute the
         // fallback from the live accumulator instead of the possibly-stale
         // getState().spinner.responseLength. Final-only / non-streaming turns never
         // accumulate `assistantText` (only currentAssistantText is set at the
@@ -1374,7 +1296,7 @@ export function createRunTurn(bag) {
     flushEmit?.();
     _publishedThinkingActive = false; // turn teardown cleared getState().thinking
     const finalStatus = cancelled ? 'cancelled' : (failed ? 'failed' : 'done');
-    tuiDebug(`runTurn end turn=${turnIndex} status=${finalStatus} elapsedMs=${Date.now() - startedAt}${watchdog.tripped ? ' watchdogTripped=1' : ''} pending=${pending.length}`);
+    tuiDebug(`runTurn end turn=${turnIndex} status=${finalStatus} elapsedMs=${Date.now() - startedAt} pending=${pending.length}`);
     return finalStatus;
   }