mixdog 0.9.95 → 0.9.97

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 } from './tool-result-text.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
@@ -183,12 +107,6 @@ export function createRunTurn(bag) {
     const toolCards = [];
     const toolGroups = new Map();
     const resultsDone = new Set();
-    // apply_patch+post_shell twin display: parent callId → synthetic shell
-    // callId. The protocol stays ONE call/ONE result, but the transcript shows
-    // TWO cards (edit + verify shell) so a long post_shell no longer looks
-    // like a stuck 'Editing 1 file'. deliverToolResultMessage splits the
-    // combined result text back between the two cards.
-    const postShellTwins = new Map();
     // ── Live shell-output tail → running tool card ─────────────────────────
     // 1 s poll of orchestrator liveness while this turn runs. When exactly one
     // standalone (non-aggregate) card is unresolved and the runtime reports a
@@ -591,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
@@ -696,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
@@ -748,7 +666,9 @@ export function createRunTurn(bag) {
         // the provider's isError/error-tool envelope drives failure counts/red.
         const { exitCode, isExitError, isCallError } = toolCallOutcome(message, rawText);
         const isError = isCallError;
-        const text = isError ? toolErrorDisplay(rawText, callRec.name || 'tool') : rawText;
+        const text = isError
+          ? toolErrorDisplay(rawText, callRec.name || 'tool')
+          : (isExitError ? stripShellExitHeader(rawText) : rawText);
         callRec.summary = !isError ? summarizeToolResult(callRec.name, callRec.args, rawText, isError) : null;
         assignAggregateSummaryOrder(aggregate, callRec);
         callRec.isError = isError;
@@ -805,49 +725,7 @@ export function createRunTurn(bag) {
         const earlyCallId = toolResultCallId(message);
         if (earlyCallId) {
           markToolCardCompletedState(earlyCallId, message);
-          const earlyTwin = postShellTwins.get(earlyCallId);
-          if (earlyTwin) markToolCardCompletedState(earlyTwin, message);
-        }
-        return;
-      }
-      const parentCallId = toolResultCallId(message);
-      const twinCallId = parentCallId ? postShellTwins.get(parentCallId) : null;
-      if (twinCallId && !resultsDone.has(twinCallId)) {
-        const combined = String(toolResultText(message?.content) ?? '');
-        // tool-exec composes `${patch}\n\n${header}\n${shell}` (or appends the
-        // skipped marker to a failed patch). Split on those exact seams.
-        const headerMatch = combined.match(/\n+--- post_shell( FAILED[^\n]*)? ---\n?/);
-        const skippedMatch = headerMatch ? null : combined.match(/\n+--- post_shell skipped: patch failed ---\s*$/);
-        let patchPart = combined;
-        let shellPart = null;
-        if (headerMatch) {
-          patchPart = combined.slice(0, headerMatch.index);
-          shellPart = combined.slice(headerMatch.index + headerMatch[0].length);
-          // Keep the FAILED banner on the shell card so its error state and
-          // fix-and-re-verify guidance survive the split.
-          if (headerMatch[1]) shellPart = `Error: post_shell FAILED (patch is applied; fix and re-verify)\n${shellPart}`;
-        } else if (skippedMatch) {
-          patchPart = combined.slice(0, skippedMatch.index);
-          shellPart = 'Error: post_shell skipped: patch failed';
         }
-        if (shellPart !== null) {
-          flushToolResults([
-            {
-              role: 'tool',
-              tool_call_id: parentCallId,
-              content: patchPart,
-              ...(Object.hasOwn(message || {}, 'uiDiff') ? { uiDiff: message.uiDiff } : {}),
-            },
-            { role: 'tool', tool_call_id: twinCallId, content: shellPart },
-          ], toolCards, cardByCallId, toolGroups, resultsDone);
-          return;
-        }
-        // Unsplittable (offloaded/preview-shaped result): parent keeps the
-        // combined text; settle the twin instead of leaving it Running.
-        flushToolResults([
-          message,
-          { role: 'tool', tool_call_id: twinCallId, content: '(post_shell output included in the patch result above)' },
-        ], toolCards, cardByCallId, toolGroups, resultsDone);
         return;
       }
       flushToolResults([message], toolCards, cardByCallId, toolGroups, resultsDone);
@@ -918,24 +796,7 @@ export function createRunTurn(bag) {
           }
           const batchCalls = (calls || []).filter(Boolean);
           if (batchCalls.length === 0) return;
-          // Expand each apply_patch carrying post_shell into itself PLUS a
-          // synthetic trailing shell call, so the (possibly long) verify phase
-          // renders as its own Running command card in call order.
-          const displayCalls = [];
-          for (const c of batchCalls) {
-            displayCalls.push(c);
-            if (toolCallName(c) !== 'apply_patch') continue;
-            let patchCallArgs = toolCallArgs(c);
-            if (typeof patchCallArgs === 'string') {
-              try { patchCallArgs = JSON.parse(patchCallArgs); } catch { patchCallArgs = null; }
-            }
-            const postShellCmd = typeof patchCallArgs?.post_shell === 'string' ? patchCallArgs.post_shell.trim() : '';
-            const parentCallId = toolCallId(c);
-            if (!postShellCmd || !parentCallId) continue;
-            const twinCallId = `${parentCallId}::post_shell`;
-            postShellTwins.set(parentCallId, twinCallId);
-            displayCalls.push({ id: twinCallId, name: 'shell', args: { command: postShellCmd } });
-          }
+          const displayCalls = batchCalls;
           const agentBatch = ++providerToolBatch;
           const committedAssistantSegment = commitAssistantSegment({ sealToolBlock: true });
           if (committedAssistantSegment) {
@@ -972,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());
@@ -1024,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 };
@@ -1227,11 +1090,14 @@ export function createRunTurn(bag) {
           flushStreamBatch();
         },
         onReasoningDelta: (chunk) => {
-          if (!isCurrentTurn() || watchdog.tripped) return;
+          if (!isCurrentTurn()) return;
           if (String(chunk ?? '')) {
             if (!markTurnProgress('reasoning-delta')) return;
-            markPromptCommitted();
           }
+          // Reasoning is NOT a commit boundary (Claude Code parity): a turn
+          // interrupted while it is still thinking produced no model-visible
+          // message, so Esc must hand the prompt back to the input box. Text,
+          // tool calls and turn end still commit it below.
           startThinkingSegment();
           thinkingText += String(chunk ?? '');
           // Accumulate reasoning text; fire at most one render per STREAM_BATCH_INTERVAL_MS.
@@ -1341,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) {
@@ -1367,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()) {
@@ -1383,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
@@ -1434,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;
   }