mixdog 0.9.14 → 0.9.15

package/package.json

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

package/src/tui/dist/index.mjs

@@ -22052,6 +22052,19 @@ var TOOL_APPROVAL_TIMEOUT_MS = (() => {
   const value = Number(process.env.MIXDOG_TOOL_APPROVAL_TIMEOUT_MS);
   return Number.isFinite(value) && value > 0 ? Math.max(1e3, Math.round(value)) : 12e4;
 })();
+var LEAD_TURN_TIMEOUT_MS = (() => {
+  const value = Number(process.env.MIXDOG_LEAD_TURN_TIMEOUT_MS);
+  return Number.isFinite(value) && value > 0 ? Math.max(1e4, Math.round(value)) : 30 * 6e4;
+})();
+var TUI_DEBUG = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_TUI_DEBUG || ""));
+var tuiDebug = (msg) => {
+  if (!TUI_DEBUG) return;
+  try {
+    process.stderr.write(`[tui] ${msg}
+`);
+  } catch {
+  }
+};
 var _idSeq = 0;
 var nextId = () => `it_${++_idSeq}`;
 async function createEngineSession({
@@ -22487,6 +22500,7 @@ async function createEngineSession({
   async function runTurn(userText, options = {}) {
     const turnIndex = state.stats.turns || 0;
     const startedAt2 = Date.now();
+    const turnEpoch = ++leadTurnEpoch;
     const inputBaseline = state.stats.inputTokens;
     const outputBaseline = state.stats.outputTokens;
     const submittedIds = Array.isArray(options.submittedIds) ? options.submittedIds : [];
@@ -22506,6 +22520,44 @@ async function createEngineSession({
     set({ busy: true, lastTurn: null, spinner: { active: true, verb: pickVerb(turnIndex), startedAt: startedAt2, responseLength: 0, inputTokens: 0, outputTokens: 0, mode: "requesting" } });
     let assistantText = "";
     let currentAssistantId = null;
+    tuiDebug(`runTurn start turn=${turnIndex} pending=${pending.length} timeoutMs=${LEAD_TURN_TIMEOUT_MS}`);
+    let watchdogTripped = false;
+    let watchdogTimer = null;
+    let watchdogGraceTimer = null;
+    const clearWatchdog = () => {
+      if (watchdogTimer) {
+        clearTimeout(watchdogTimer);
+        watchdogTimer = null;
+      }
+      if (watchdogGraceTimer) {
+        clearTimeout(watchdogGraceTimer);
+        watchdogGraceTimer = null;
+      }
+    };
+    watchdogTimer = setTimeout(() => {
+      if (disposed) return;
+      watchdogTripped = true;
+      const elapsed = Date.now() - startedAt2;
+      tuiDebug(`runTurn WATCHDOG TRIP turn=${turnIndex} elapsedMs=${elapsed} \u2014 aborting stuck turn`);
+      pushNotice(`Turn timed out after ${Math.round(elapsed / 1e3)}s \u2014 aborting stuck request. Input is available again.`, "warn", { transcript: true });
+      try {
+        runtime.abort("cli-react-abort-watchdog");
+      } catch {
+      }
+      watchdogGraceTimer = setTimeout(() => {
+        if (disposed) return;
+        if (!state.busy) return;
+        if (leadTurnEpoch !== turnEpoch) return;
+        tuiDebug(`runTurn WATCHDOG FORCE-RELEASE turn=${turnIndex} \u2014 abort unwind starved`);
+        leadTurnEpoch++;
+        set({ busy: false, spinner: null, thinking: null, lastTurn: null });
+        activePromptRestore = null;
+        if (draining) draining = false;
+        if (pending.length > 0) void drain();
+      }, 5e3);
+      watchdogGraceTimer.unref?.();
+    }, LEAD_TURN_TIMEOUT_MS);
+    watchdogTimer.unref?.();
     let currentAssistantText = "";
     let thinkingText = "";
     let thinkingStartedAt = 0;
@@ -23108,6 +23160,8 @@ async function createEngineSession({
       }
     } finally {
       denyAllToolApprovals(cancelled ? "turn cancelled" : "turn finished");
+      clearWatchdog();
+      const isStaleUnwind = leadTurnEpoch !== turnEpoch;
       if (deferredEntries.length) {
         const last = deferredEntries[deferredEntries.length - 1];
         if (last) flushDeferredUpTo(last);
@@ -23116,7 +23170,7 @@ async function createEngineSession({
       flushDeferredBeforeImmediatePush = null;
       const producedTranscriptItem = state.items.length > itemsAtTurnStart;
       const reclaimed = cancelled && activePromptRestore?.reclaimed === true;
-      activePromptRestore = null;
+      if (!isStaleUnwind) activePromptRestore = null;
       closeThinkingSegment();
       const elapsedMs = Date.now() - startedAt2;
       const thinkingElapsedMs = thinkingStartedAt ? accumulatedThinkingMs : 0;
@@ -23127,31 +23181,37 @@ async function createEngineSession({
       const resultContent = askResult?.content != null ? String(askResult.content).trim() : "";
       const assistantOutput = (currentAssistantText || assistantText || "").trim();
       const isNoOpTurn = turnFinishedNormally && !cancelled && toolCards.length === 0 && !resultContent && !assistantOutput && !producedTranscriptItem;
-      if (!isNoOpTurn) {
-        state.stats.turns = (state.stats.turns || 0) + 1;
-      }
-      if (!reclaimed && !isNoOpTurn) {
-        pushItem({ kind: "turndone", id: nextId(), elapsedMs, status: turnStatus, outputTokens: finalOutputTokens, thinkingElapsedMs, verb: pickDoneVerb(turnIndex) });
+      if (isStaleUnwind) {
+        tuiDebug(`runTurn STALE UNWIND turn=${turnIndex} \u2014 force-released; skipping shared-state writes`);
+      } else {
+        if (!isNoOpTurn) {
+          state.stats.turns = (state.stats.turns || 0) + 1;
+        }
+        if (!reclaimed && !isNoOpTurn) {
+          pushItem({ kind: "turndone", id: nextId(), elapsedMs, status: turnStatus, outputTokens: finalOutputTokens, thinkingElapsedMs, verb: pickDoneVerb(turnIndex) });
+        }
+        set({
+          busy: false,
+          spinner: null,
+          thinking: null,
+          lastTurn: null,
+          stats: { ...state.stats },
+          ...routeState(),
+          toolMode: runtime.toolMode,
+          ...agentStatusState({ force: true })
+        });
+        flushDeferredExecutionPendingResumeKick();
       }
-      set({
-        busy: false,
-        spinner: null,
-        thinking: null,
-        lastTurn: null,
-        stats: { ...state.stats },
-        ...routeState(),
-        toolMode: runtime.toolMode,
-        ...agentStatusState({ force: true })
-      });
-      flushDeferredExecutionPendingResumeKick();
     }
-    clearActiveToolSummary();
+    if (leadTurnEpoch === turnEpoch) clearActiveToolSummary();
     _publishedThinkingActive = false;
+    tuiDebug(`runTurn end turn=${turnIndex} status=${cancelled ? "cancelled" : "done"} elapsedMs=${Date.now() - startedAt2}${watchdogTripped ? " watchdogTripped=1" : ""} pending=${pending.length}`);
     return cancelled ? "cancelled" : "done";
   }
   const pending = [];
   let draining = false;
   let activePromptRestore = null;
+  let leadTurnEpoch = 0;
   const leadSessionId = () => runtime.id;
   function shouldMirrorSteeringEntry(entry) {
     return isQueuedEntryEditable(entry) && !isSlashQueuedEntry(entry);
@@ -23252,6 +23312,7 @@ async function createEngineSession({
         const batch = dequeueQueueBatch("later", { limit: firstBatch ? 1 : Infinity });
         firstBatch = false;
         if (batch.length === 0) break;
+        tuiDebug(`busy-queue drain batch=${batch.length} remaining=${pending.length}`);
         const ids = new Set(batch.map((e) => e.id));
         const merged = mergePromptContents(batch);
         for (const entry of batch) {
@@ -23299,6 +23360,7 @@ async function createEngineSession({
       appendTuiSteeringPersist(leadSessionId(), entry);
     }
     if (isQueuedEntryVisible(entry)) set({ queued: [...state.queued, entry] });
+    if (state.busy) tuiDebug(`busy-queue enqueue mode=${entry.mode} pending=${pending.length}`);
     void drain();
     return true;
   }

package/src/tui/engine.mjs

@@ -96,6 +96,26 @@ const TOOL_APPROVAL_TIMEOUT_MS = (() => {
   return Number.isFinite(value) && value > 0 ? Math.max(1000, Math.round(value)) : 120_000;
 })();
 
+// Wall-clock cap for a single lead TUI turn. A provider call that never
+// resolves (e.g. a rate-limit retry loop that spins forever) otherwise leaves
+// runTurn holding busy=true with no unwind, so submit() only ever queues and
+// the UI is permanently input-dead. On trip we abort the in-flight run through
+// the SAME interrupt path Esc uses, force busy=false, and drain the queue.
+// Generous default (30min); env-overridable for tuning/tests.
+const LEAD_TURN_TIMEOUT_MS = (() => {
+  const value = Number(process.env.MIXDOG_LEAD_TURN_TIMEOUT_MS);
+  return Number.isFinite(value) && value > 0 ? Math.max(10_000, Math.round(value)) : 30 * 60_000;
+})();
+
+// Opt-in diagnostic trace for the hang chain (runTurn start/end, busy-queue
+// enqueue/drain, watchdog trip). Quiet by default so it can never tear through
+// the alternate-screen render; enable with MIXDOG_TUI_DEBUG=1.
+const TUI_DEBUG = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_TUI_DEBUG || ''));
+const tuiDebug = (msg) => {
+  if (!TUI_DEBUG) return;
+  try { process.stderr.write(`[tui] ${msg}\n`); } catch {}
+};
+
 let _idSeq = 0;
 const nextId = () => `it_${++_idSeq}`;
 
@@ -610,6 +630,12 @@ export async function createEngineSession({
   async function runTurn(userText, options = {}) {
     const turnIndex = state.stats.turns || 0;
     const startedAt = Date.now();
+    // 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-state writes (busy, activePromptRestore,
+    // turndone, drain kick). Neutralizes the stale unwind without touching the mutex.
+    const turnEpoch = ++leadTurnEpoch;
     const inputBaseline = state.stats.inputTokens;
     const outputBaseline = state.stats.outputTokens;
     const submittedIds = Array.isArray(options.submittedIds) ? options.submittedIds : [];
@@ -630,6 +656,48 @@ export async function createEngineSession({
 
     let assistantText = '';
     let currentAssistantId = null;
+
+    tuiDebug(`runTurn start turn=${turnIndex} pending=${pending.length} timeoutMs=${LEAD_TURN_TIMEOUT_MS}`);
+    // ── Wall-clock watchdog ───────────────────────────────────────────────
+    // If this turn never unwinds (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. If even
+    // that unwind is starved, forceReleaseTurn() in the timer hard-clears busy
+    // and kicks the drain so input is never permanently dead.
+    let watchdogTripped = false;
+    let watchdogTimer = null;
+    let watchdogGraceTimer = null;
+    const clearWatchdog = () => {
+      if (watchdogTimer) { clearTimeout(watchdogTimer); watchdogTimer = null; }
+      if (watchdogGraceTimer) { clearTimeout(watchdogGraceTimer); watchdogGraceTimer = null; }
+    };
+    watchdogTimer = setTimeout(() => {
+      if (disposed) return;
+      watchdogTripped = true;
+      const elapsed = Date.now() - startedAt;
+      tuiDebug(`runTurn WATCHDOG TRIP turn=${turnIndex} elapsedMs=${elapsed} — aborting stuck turn`);
+      pushNotice(`Turn timed out after ${Math.round(elapsed / 1000)}s — aborting stuck request. Input is available again.`, 'warn', { transcript: true });
+      try { runtime.abort('cli-react-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 (disposed) return;
+        if (!state.busy) return;
+        if (leadTurnEpoch !== turnEpoch) return; // a newer turn already owns the store
+        tuiDebug(`runTurn WATCHDOG FORCE-RELEASE turn=${turnIndex} — abort unwind starved`);
+        // Bump the epoch FIRST so this (still-stuck) turn's later finally becomes
+        // a no-op for shared state and cannot corrupt the turn we hand off to.
+        leadTurnEpoch++;
+        set({ busy: false, spinner: null, thinking: null, lastTurn: null });
+        activePromptRestore = null;
+        if (draining) draining = false;
+        if (pending.length > 0) void drain();
+      }, 5_000);
+      watchdogGraceTimer.unref?.();
+    }, LEAD_TURN_TIMEOUT_MS);
+    watchdogTimer.unref?.();
     let currentAssistantText = '';
     let thinkingText = '';
     let thinkingStartedAt = 0;
@@ -1451,6 +1519,14 @@ export async function createEngineSession({
       }
     } finally {
       denyAllToolApprovals(cancelled ? 'turn cancelled' : 'turn finished');
+      // Turn is unwinding normally (or via abort) — cancel the wall-clock
+      // watchdog + its force-release grace so they never fire on a live turn.
+      clearWatchdog();
+      // If the watchdog force-release already fired, a NEWER turn now owns the
+      // shared store (busy, activePromptRestore, turndone, drain). This stale
+      // unwind must NOT write shared state or it corrupts that turn. It still
+      // runs its own turn-local teardown (approvals, deferred cards) below.
+      const isStaleUnwind = leadTurnEpoch !== turnEpoch;
       // Flush any still-deferred tool cards into the transcript and cancel their
       // pending push timers so nothing fires (or leaks) after the turn ends. The
       // finalize path above already patches results onto visible cards; this just
@@ -1463,7 +1539,7 @@ export async function createEngineSession({
       flushDeferredBeforeImmediatePush = null;
       const producedTranscriptItem = state.items.length > itemsAtTurnStart;
       const reclaimed = cancelled && activePromptRestore?.reclaimed === true;
-      activePromptRestore = null;
+      if (!isStaleUnwind) activePromptRestore = null;
       closeThinkingSegment();
       const elapsedMs = Date.now() - startedAt;
       const thinkingElapsedMs = thinkingStartedAt ? accumulatedThinkingMs : 0;
@@ -1486,6 +1562,9 @@ export async function createEngineSession({
         && !resultContent
         && !assistantOutput
         && !producedTranscriptItem;
+      if (isStaleUnwind) {
+        tuiDebug(`runTurn STALE UNWIND turn=${turnIndex} — force-released; skipping shared-state writes`);
+      } else {
       if (!isNoOpTurn) {
         state.stats.turns = (state.stats.turns || 0) + 1;
       }
@@ -1507,15 +1586,23 @@ export async function createEngineSession({
         ...agentStatusState({ force: true }),
       });
       flushDeferredExecutionPendingResumeKick();
+      }
     }
-    clearActiveToolSummary();
+    // Shared UI state: a stale unwind must not wipe a newer turn's live
+    // tool-summary line (same epoch rule as the shared-state block above).
+    if (leadTurnEpoch === turnEpoch) clearActiveToolSummary();
     _publishedThinkingActive = false; // turn teardown cleared state.thinking
+    tuiDebug(`runTurn end turn=${turnIndex} status=${cancelled ? 'cancelled' : 'done'} elapsedMs=${Date.now() - startedAt}${watchdogTripped ? ' watchdogTripped=1' : ''} pending=${pending.length}`);
     return cancelled ? 'cancelled' : 'done';
   }
 
   const pending = [];
   let draining = false;
   let activePromptRestore = null;
+  // Monotonic per-lead-turn epoch (see runTurn). Bumped on watchdog
+  // force-release so a stale turn's late `finally` can detect it no longer owns
+  // the shared store and skip all shared-state writes.
+  let leadTurnEpoch = 0;
 
   const leadSessionId = () => runtime.id;
 
@@ -1627,6 +1714,7 @@ export async function createEngineSession({
         const batch = dequeueQueueBatch('later', { limit: firstBatch ? 1 : Infinity });
         firstBatch = false;
         if (batch.length === 0) break;
+        tuiDebug(`busy-queue drain batch=${batch.length} remaining=${pending.length}`);
         const ids = new Set(batch.map((e) => e.id));
         const merged = mergePromptContents(batch);
         for (const entry of batch) {
@@ -1686,6 +1774,7 @@ export async function createEngineSession({
       appendTuiSteeringPersist(leadSessionId(), entry);
     }
     if (isQueuedEntryVisible(entry)) set({ queued: [...state.queued, entry] });
+    if (state.busy) tuiDebug(`busy-queue enqueue mode=${entry.mode} pending=${pending.length}`);
     void drain();
     return true;
   }