mixdog 0.9.39 → 0.9.41

package/src/runtime/agent/orchestrator/session/tool-result-offload.mjs

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync } from 'fs';
-import { readdir, rmdir, unlink, writeFile } from 'fs/promises';
+import { readdir, rmdir, stat, unlink, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { getPluginData } from '../config.mjs';
 import { normalizeOutputPath } from '../tools/builtin/path-utils.mjs';
@@ -11,6 +11,7 @@ const TOOL_RESULT_SHELL_THRESHOLD_CHARS = 30_000;
 const TOOL_RESULT_SEARCH_THRESHOLD_CHARS = 50_000;
 const TOOL_RESULT_GREP_THRESHOLD_CHARS = 20_000;
 export const TOOL_RESULT_OFFLOAD_PREFIX = '[tool output offloaded:';
+const OFFLOAD_PRUNE_MIN_AGE_MS = 10 * 60 * 1000;
 
 // Per-tool persistence limits mirror reference per-tool maxResultSizeChars
 // rather than a single global value: Grep persists at 20k (CC GrepTool), Glob
@@ -147,6 +148,47 @@ export async function clearOffloadSession(sessionId) {
     } catch { /* best-effort */ }
 }
 
+// Remove sidecars that no longer occur in the live transcript. A serialized
+// path match is conservative: if messages cannot be serialized, or a path is
+// mentioned anywhere in a message, retain the file rather than risk deleting
+// one that can still be read by the model.
+export async function pruneOffloadSession(sessionId, getMessages) {
+    if (!sessionId || typeof getMessages !== 'function') return;
+    const dir = join(getPluginData(), 'tool-results', safeSessionSegment(sessionId));
+    if (!existsSync(dir)) return;
+    let candidates;
+    try {
+        const entries = await readdir(dir);
+        candidates = (await Promise.all(entries
+            .filter((name) => name.endsWith('.txt'))
+            .map(async (name) => {
+                const filePath = join(dir, name);
+                try {
+                    const fileStat = await stat(filePath);
+                    if (Date.now() - fileStat.mtimeMs < OFFLOAD_PRUNE_MIN_AGE_MS) return null;
+                    return { name, filePath };
+                } catch {
+                    return null;
+                }
+            })
+        )).filter(Boolean);
+    } catch { /* best-effort */ }
+    if (!candidates) return;
+    let serialized;
+    try { serialized = JSON.stringify(getMessages()); } catch { return; }
+    const haystack = process.platform === 'win32' ? serialized.toLowerCase() : serialized;
+    await Promise.all(candidates
+        .filter(({ name, filePath }) => {
+            const normalizedPath = normalizeOutputPath(filePath);
+            const needles = [normalizedPath, name];
+            return !needles.some((needle) => {
+                const value = process.platform === 'win32' ? needle.toLowerCase() : needle;
+                return haystack.includes(value);
+            });
+        })
+        .map(({ filePath }) => unlink(filePath).catch(() => { /* best-effort */ })));
+}
+
 export function isOffloadedToolResultText(text) {
     return typeof text === 'string' && text.startsWith(TOOL_RESULT_OFFLOAD_PREFIX);
 }

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs

@@ -124,23 +124,31 @@ export function _isBenignSearchExitOne(command, exitCode, signal, stderr) {
 function _combineAbortSignals(sessionSignal, externalSignal) {
     const a = sessionSignal || null;
     const b = externalSignal || null;
-    if (!a && !b) return null;
-    if (!a) return b;
-    if (!b) return a;
-    if (a === b) return a;
+    if (!a && !b) return { signal: null, cleanup() {} };
+    if (!a) return { signal: b, cleanup() {} };
+    if (!b) return { signal: a, cleanup() {} };
+    if (a === b) return { signal: a, cleanup() {} };
     if (typeof AbortSignal !== 'undefined' && typeof AbortSignal.any === 'function') {
-        try { return AbortSignal.any([a, b]); } catch { /* fall through */ }
+        try { return { signal: AbortSignal.any([a, b]), cleanup() {} }; } catch { /* fall through */ }
     }
     const ctl = new AbortController();
     const onAbort = (sig) => {
         if (ctl.signal.aborted) return;
         try { ctl.abort(sig?.reason); } catch { try { ctl.abort(); } catch {} }
     };
-    if (a.aborted) { onAbort(a); return ctl.signal; }
-    if (b.aborted) { onAbort(b); return ctl.signal; }
-    try { a.addEventListener('abort', () => onAbort(a), { once: true }); } catch {}
-    try { b.addEventListener('abort', () => onAbort(b), { once: true }); } catch {}
-    return ctl.signal;
+    if (a.aborted) { onAbort(a); return { signal: ctl.signal, cleanup() {} }; }
+    if (b.aborted) { onAbort(b); return { signal: ctl.signal, cleanup() {} }; }
+    const onAbortA = () => onAbort(a);
+    const onAbortB = () => onAbort(b);
+    try { a.addEventListener('abort', onAbortA, { once: true }); } catch {}
+    try { b.addEventListener('abort', onAbortB, { once: true }); } catch {}
+    return {
+        signal: ctl.signal,
+        cleanup() {
+            try { a.removeEventListener('abort', onAbortA); } catch {}
+            try { b.removeEventListener('abort', onAbortB); } catch {}
+        },
+    };
 }
 
 function _prefixPowerShellUtf8(command) {
@@ -228,7 +236,11 @@ export async function executeBashTool(args, workDir, options = {}) {
         const userProvidedSession = typeof args.session_id === 'string' && args.session_id.trim().length > 0;
         const shouldCreate = args.create === true || !userProvidedSession;
         effectiveArgs = { ...effectiveArgs, create: shouldCreate };
-        return executeBashSessionTool('bash_session', effectiveArgs, bashWorkDir, { abortSignal: combinedPersistAbort, sessionId: options?.sessionId });
+        try {
+            return await executeBashSessionTool('bash_session', effectiveArgs, bashWorkDir, { abortSignal: combinedPersistAbort.signal, sessionId: options?.sessionId });
+        } finally {
+            combinedPersistAbort.cleanup();
+        }
     }
 
     let command = args.command;
@@ -276,6 +288,7 @@ export async function executeBashTool(args, workDir, options = {}) {
     }
 
     let shellEffects;
+    let combinedBashAbort = null;
     try {
         shellEffects = await analyzeShellCommandEffects(command, bashWorkDir);
     } catch (err) {
@@ -284,10 +297,9 @@ export async function executeBashTool(args, workDir, options = {}) {
     // Keep foreground commands on a long tool-owned timeout. The MCP dispatch
     // layer must not add a shorter fallback ceiling when timeout is omitted.
     // Reference-CLI parity (opencode/codex/claude-code): sync-first, no hard
-    // upper ceiling on a caller-provided timeout. Default 120 s (2 min) when
-    // omitted; BASH_DEFAULT_TIMEOUT_MS / BASH_MAX_TIMEOUT_MS env overrides keep
-    // their semantics (max floored at default) but only bound the *omitted*
-    // default — an explicit args.timeout is honored UNCAPPED.
+    // upper ceiling on a caller-provided total timeout. Default 120 s (2 min)
+    // when omitted; BASH_DEFAULT_TIMEOUT_MS / BASH_MAX_TIMEOUT_MS env overrides
+    // bound the blocking window when timeout promotion is available.
     const _envDefaultTimeout = parseInt(process.env.BASH_DEFAULT_TIMEOUT_MS ?? '', 10);
     const DEFAULT_BASH_TIMEOUT_MS = _envDefaultTimeout > 0 ? _envDefaultTimeout : 120_000;
     // Background (async / run_in_background) jobs get NO omitted default: 0
@@ -302,8 +314,14 @@ export async function executeBashTool(args, workDir, options = {}) {
         : DEFAULT_BASH_TIMEOUT_MS;
     const hasExplicitTimeout = typeof args.timeout === 'number' && args.timeout > 0;
     const timeoutMs = hasExplicitTimeout ? args.timeout : defaultTimeoutMs;
-    // Explicit caller timeout is uncapped (only the wmic-rewrite ceiling, when
-    // present, still bounds it); the omitted default keeps the MAX ceiling.
+    const _bgTasksDisabled = /^(1|true|yes|on)$/i.test(
+        String(process.env.MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS || '').trim(),
+    );
+    const backgroundOnTimeout = !runInBackground
+        && !_bgTasksDisabled
+        && isAutobackgroundingAllowed(command, resolvedSpec.shellType);
+    // Explicit caller timeout remains the total deadline. When promotion is
+    // available, cap only its foreground blocking portion at MAX.
     // JS timers (setTimeout) and PS WaitForExit(ms) are 32-bit: a delay above
     // 2^31-1 wraps to a tiny/negative value and fires immediately. Clamp the
     // uncapped explicit timeout once here (~24.8 days ceiling) so every
@@ -312,11 +330,15 @@ export async function executeBashTool(args, workDir, options = {}) {
     const TIMER_MAX_MS = 2_147_483_647;
     // timeoutMs <= 0 (omitted background default) means unlimited: pass it
     // through untouched — the min() clamps below must not turn 0 into a bound.
-    const timeout = timeoutMs <= 0
+    const totalTimeout = timeoutMs <= 0
         ? 0
-        : (hasExplicitTimeout
-            ? Math.min(timeoutMs, wmicRewrite?.timeoutMs || TIMER_MAX_MS)
-            : Math.min(timeoutMs, wmicRewrite?.timeoutMs || MAX_BASH_TIMEOUT_MS));
+        : Math.min(timeoutMs, wmicRewrite?.timeoutMs || (hasExplicitTimeout ? TIMER_MAX_MS : MAX_BASH_TIMEOUT_MS));
+    const timeout = hasExplicitTimeout && backgroundOnTimeout
+        ? Math.min(totalTimeout, MAX_BASH_TIMEOUT_MS)
+        : totalTimeout;
+    const promotedTimeoutMs = hasExplicitTimeout && backgroundOnTimeout
+        ? Math.max(0, totalTimeout - timeout)
+        : 0;
     const mergeStderr = args.merge_stderr === true;
     const longForegroundHint = foregroundLongCommandHint(command, timeout, { ...args, run_in_background: runInBackground });
     if (longForegroundHint) return formatShellToolFailure(longForegroundHint);
@@ -423,7 +445,7 @@ export async function executeBashTool(args, workDir, options = {}) {
         let bashAbortSignal = null;
         try { bashAbortSignal = (await getAbortSignalForSession(options?.sessionId)) || null; }
         catch { bashAbortSignal = null; }
-        const combinedBashAbort = _combineAbortSignals(bashAbortSignal, options?.abortSignal || null);
+        combinedBashAbort = _combineAbortSignals(bashAbortSignal, options?.abortSignal || null);
         // Sync path only: chain a trailing cwd probe so the session's final
         // working directory persists to the next shell call. Async jobs run
         // detached and are intentionally excluded (they never reach here). The
@@ -445,22 +467,17 @@ export async function executeBashTool(args, workDir, options = {}) {
         // base commands (isAutobackgroundingAllowed), (b) the truthy
         // MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS env. Never applies to
         // run_in_background (already detached, handled above).
-        const _bgTasksDisabled = /^(1|true|yes|on)$/i.test(
-            String(process.env.MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS || '').trim(),
-        );
-        const backgroundOnTimeout = !runInBackground
-            && !_bgTasksDisabled
-            && isAutobackgroundingAllowed(command, shellType);
         const result = await execShellCommand({
             shell, shellArg, shellArgs, command: syncCommand,
             env: spawnEnv,
             cwd: bashWorkDir,
             timeoutMs: timeout,
-            abortSignal: combinedBashAbort,
+            abortSignal: combinedBashAbort.signal,
             autoBackgroundMs,
             // On a foreground timeout, promote the still-running child to a
             // tracked background job (unlimited) instead of killing it.
             backgroundOnTimeout,
+            promotedTimeoutMs,
             // Threaded so an auto-backgrounded foreground job is stamped with
             // the dispatching terminal's claude.exe pid (per-terminal scope).
             clientHostPid: options?.clientHostPid,
@@ -494,10 +511,7 @@ export async function executeBashTool(args, workDir, options = {}) {
                             stdout: result.stdoutPath ? normalizeOutputPath(result.stdoutPath) : null,
                             stderr: (!mergeStderr && result.stderrPath) ? normalizeOutputPath(result.stderrPath) : null,
                             cwd: bashWorkDir,
-                            // Adopted foreground jobs run unlimited (timeoutMs 0)
-                            // — matches the async default; the original
-                            // foreground timeout no longer bounds the promoted job.
-                            timeoutMs: 0,
+                            timeoutMs: result.backgroundTimeoutMs || 0,
                         },
                         resultType: 'shell_task_result',
                         cancel: () => killShellJob(result.jobId),
@@ -517,7 +531,7 @@ export async function executeBashTool(args, workDir, options = {}) {
             const lines = [
                 task ? renderBackgroundTask(task) : (result.jobId ? `[task_id: ${result.jobId}]` : null),
                 '',
-                result.backgroundMessage || 'auto-backgrounded; still running',
+                result.backgroundMessage || 'auto-backgrounded; still running — judge from the partial output whether waiting can finish in budget, or diagnose and pursue an alternative.',
                 partialStdout ? `\n[partial stdout]\n${partialStdout}` : '',
                 (!mergeStderr && partialStderr) ? `\n[partial stderr]\n${partialStderr}` : '',
             ].filter((l) => l !== null && l !== '');
@@ -592,6 +606,7 @@ export async function executeBashTool(args, workDir, options = {}) {
         return _prependDestructiveWarning(command, warningBlock ? `${warningBlock}\n${payload}` : payload);
     }
     finally {
+        combinedBashAbort?.cleanup?.();
         if (shellEffects.mutationMode === 'paths') {
             invalidateBuiltinResultCache(shellEffects.paths);
             markCodeGraphDirtyPaths(shellEffects.paths);

package/src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs

@@ -83,7 +83,7 @@ export const BUILTIN_TOOLS = [
             properties: {
                 command: { type: 'string', description: 'Command.' },
                 cwd: { type: 'string', description: 'Working directory; persists across calls. Omit to reuse; absolute path changes it.' },
-                timeout: { type: 'number', description: `Timeout ms. Default ${_shellDefaultTimeoutMs()} (${_shellDefaultTimeoutMs() / 60000} min) when omitted; an explicit value is honored uncapped — long-running commands may set it higher. On timeout the command is MOVED TO BACKGROUND (a task_id you can wait/status/read/cancel) and keeps running instead of being killed; sleep-like commands and MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS opt out (killed with a [timeout] marker). async/background runs with timeout omitted have NO timeout (run until done/cancelled); an explicit timeout is still enforced.` },
+                timeout: { type: 'number', description: `Timeout ms. Default ${_shellDefaultTimeoutMs()} (${_shellDefaultTimeoutMs() / 60000} min) when omitted. On sync timeout the command is MOVED TO BACKGROUND (a task_id you can wait/status/read/cancel) and keeps running instead of being killed; an explicit timeout blocks for at most BASH_MAX_TIMEOUT_MS (default 10 min), and only its remainder beyond that cap is still enforced as a background deadline. Sleep-like commands and MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS opt out (killed with a [timeout] marker after blocking for the full explicit timeout). async/background runs with timeout omitted have NO timeout (run until done/cancelled); an explicit timeout is still enforced.` },
                 merge_stderr: { type: 'boolean', description: 'Merge stderr.' },
                 mode: { type: 'string', enum: ['sync', 'async'], description: executionModeSchemaDescription('sync') },
                 shell: { type: 'string', enum: ['bash', 'powershell'], description: 'Force shell. Windows defaults to PowerShell; bash = Git Bash/POSIX.' },

package/src/runtime/agent/orchestrator/tools/shell-command.mjs

@@ -500,6 +500,7 @@ export function execShellCommand({
   onProgress,
   clientHostPid,
   backgroundOnTimeout,
+  promotedTimeoutMs = 0,
 }) {
   return new Promise(async (resolve) => {
     const taskId = `shell_${randomUUID().slice(0, 8)}`;
@@ -741,9 +742,8 @@ export function execShellCommand({
     //      BACKGROUND_MS opt-in) — an EARLIER promotion before the timeout, and
     //   2. the foreground timeout deadline (backgroundOnTimeout) — the default
     //      promote-on-timeout that replaces the old tree-kill.
-    // Either way the adopted job runs UNLIMITED (timeoutMs 0, matching the
-    // async default): the original foreground timeout no longer bounds it, and
-    // the adopted-job cap poll still enforces the 100 MB output ceiling.
+    // A capped explicit foreground timeout supplies its remaining deadline to
+    // the adopted job; otherwise adoption remains unlimited as before.
     // Mutually exclusive with settle() via the autoBackgrounded flag set
     // synchronously at the top before any await.
     const _autoBackground = async ({ reason = 'threshold' } = {}) => {
@@ -754,8 +754,7 @@ export function execShellCommand({
       if (child.exitCode != null || child.signalCode != null) return;
       autoBackgrounded = true;
       // The foreground capture is over; stop the local watchdogs/timers so
-      // they cannot treeKill the now-adopted child. The adopted job runs
-      // unlimited; refreshShellJob only enforces the output cap.
+      // they cannot treeKill the now-adopted child.
       if (timer) { clearTimeout(timer); timer = null; }
       _clearProgressTimer();
       if (sizeWatchdog) { clearInterval(sizeWatchdog); sizeWatchdog = null; }
@@ -777,14 +776,13 @@ export function execShellCommand({
       const stdoutPath = taskOutput.spilled ? taskOutput.stdoutPath : null;
       const stderrPath = taskOutput.spilled ? taskOutput.stderrPath : null;
       let job = null;
+      const adoptedTimeoutMs = reason === 'timeout' ? promotedTimeoutMs : 0;
       try {
         job = adoptForegroundShellJob({
           command,
           cwd,
           pid: child.pid,
-          // Unlimited: the promoted job is no longer bounded by the foreground
-          // timeout (matches the async omitted-default behavior).
-          timeoutMs: 0,
+          timeoutMs: adoptedTimeoutMs,
           mergeStderr: false,
           stdoutPath,
           stderrPath,
@@ -854,9 +852,10 @@ export function execShellCommand({
           outputCaptureError: taskOutput.writeError,
           backgrounded: true,
           jobId,
+          backgroundTimeoutMs: adoptedTimeoutMs,
           backgroundMessage: jobId
-            ? `${_verb}; still running — completion will be delivered as a background task notification. Use task with task_id:${jobId} only for manual wait/status/read/cancel.`
-            : `${_verb}; still running`,
+            ? `${_verb}; still running. Waiting is a decision, not a default: judge from the partial output whether this will finish within your remaining budget — if progress looks slow or stalled, diagnose the cause and pursue an alternative instead of waiting. Completion will be delivered as a background task notification; use task with task_id:${jobId} only for manual wait/status/read/cancel.`
+            : `${_verb}; still running — judge from the partial output whether waiting can finish in budget, or diagnose and pursue an alternative.`,
         }),
       );
     };

package/src/runtime/shared/buffered-appender.mjs

@@ -38,6 +38,13 @@ function scheduleFlush(path, q) {
     q.timer.unref?.();
 }
 
+function deleteIfIdle(path, q) {
+    if (!q.timer && !q.flushing && !q.inFlight && q.chunks.length === 0
+        && queues.get(path) === q) {
+        queues.delete(path);
+    }
+}
+
 function _flush(path, q) {
     if (q.flushing) return;
     if (q.chunks.length === 0) return;
@@ -70,7 +77,7 @@ function _flush(path, q) {
             if (q.chunks.length > 0) {
                 if (q.bytes >= BUFFER_FLUSH_BYTES) _flush(path, q);
                 else scheduleFlush(path, q);
-            }
+            } else deleteIfIdle(path, q);
         });
 }
 
@@ -120,7 +127,10 @@ export function drainPathSync(path) {
         }
         q.inFlight = null;
     }
-    if (q.chunks.length === 0) return;
+    if (q.chunks.length === 0) {
+        deleteIfIdle(path, q);
+        return;
+    }
     const data = q.chunks.join('');
     q.chunks = [];
     q.bytes = 0;
@@ -129,6 +139,7 @@ export function drainPathSync(path) {
     } catch {
         // Best-effort exit drain; nothing to recover from here.
     }
+    deleteIfIdle(path, q);
 }
 
 /**

package/src/session-runtime/config-helpers.mjs

@@ -176,16 +176,16 @@ export function autoClearProviderDefaults(providerIdleMs = null) {
 }
 
 // Agent terminal retention is deliberately narrower than Auto Clear's general
-// resolution: only listed provider rows participate. In particular, neither
-// the global idleMs nor the Advanced "default" row can retain a completed
-// agent, because those values do not describe a provider cache lifetime.
-// Null means leave the completed agent alone (no live timer, row expiry, or
-// durable store sweep).
+// resolution: listed providers use their provider cache lifetime. Unlisted
+// providers use the Advanced "default" row, or the built-in default when no
+// override is configured, so completed agents are still eventually reclaimed.
 export function resolveAgentTerminalReapMs(config, provider) {
   const key = clean(provider).toLowerCase();
-  if (!key || key === 'default' || !Object.hasOwn(AUTO_CLEAR_PROVIDER_IDLE_MS, key)) return null;
   const raw = config?.autoClear && typeof config.autoClear === 'object' ? config.autoClear : {};
   const overrides = normalizeAutoClearProviderIdleMs(raw.providerIdleMs);
+  if (!key || key === 'default' || !Object.hasOwn(AUTO_CLEAR_PROVIDER_IDLE_MS, key)) {
+    return overrides.default ?? AUTO_CLEAR_PROVIDER_IDLE_MS.default;
+  }
   return overrides[key] ?? AUTO_CLEAR_PROVIDER_IDLE_MS[key];
 }
 

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

@@ -30,6 +30,7 @@ export function createLifecycleApi(deps) {
     invalidateContextStatusCache, invalidatePreSessionToolSurface,
     applyResolvedCwd, resolveRoute, applyDeferredToolSurface, standaloneTools,
     pushTranscriptRebind,
+    notificationListeners, remoteStateListeners,
   } = deps;
   return {
     async close(reason = 'cli-exit', options = {}) {
@@ -132,6 +133,9 @@ export function createLifecycleApi(deps) {
         ok = mgr.closeSession(session.id, reason, { tombstone });
         setSession(null);
       }
+      invalidateContextStatusCache();
+      notificationListeners?.clear?.();
+      remoteStateListeners?.clear?.();
       const shellJobsStop = globalThis.__mixdogShellJobsRuntimeLoaded === true
         ? import('../runtime/agent/orchestrator/tools/builtin/shell-jobs.mjs')
           .then((mod) => mod?.shutdownShellJobs?.(reason, { sync: !detach }))

package/src/session-runtime/runtime-core.mjs

@@ -2259,6 +2259,7 @@ export async function createMixdogSessionRuntime({
     resolveCwdPath,
     agentStatusState,
     notificationListeners,
+    remoteStateListeners,
     awaitInitialMcpConnect,
   });
 

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

@@ -33,6 +33,18 @@ export function createSessionTurnApi(deps) {
     awaitInitialMcpConnect,
   } = deps;
   return {
+    getTurnLiveness() {
+      const sessionId = getSession()?.id;
+      if (!sessionId || typeof mgr.getSessionProgressSnapshot !== 'function') return null;
+      const snapshot = mgr.getSessionProgressSnapshot(sessionId);
+      if (!snapshot) return null;
+      return {
+        stage: snapshot.stage,
+        lastProgressAt: snapshot.lastProgressAt,
+        toolStartedAt: snapshot.toolStartedAt,
+        toolSelfDeadlineMs: snapshot.toolSelfDeadlineMs,
+      };
+    },
     async ask(prompt, options = {}) {
       setActiveTurnCount(getActiveTurnCount() + 1);
       // Lazy code-graph prewarm: kick off the build ONCE, on the first real

package/src/standalone/agent-tool.mjs

@@ -509,7 +509,11 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     for (const [tag, sessionId] of [...tags.entries()]) {
       if (indexedKeys.has(`${tag}\0${sessionId}`)) continue;
       const session = getLiveSession(sessionId);
-      if (!session || session.closed) tags.delete(tag);
+      if (!session || session.closed) {
+        tags.delete(tag);
+        tagAgents.delete(tag);
+        tagCwds.delete(tag);
+      }
     }
     if (!scanSessions) return;
     for (const session of mgr.listSessions({ includeClosed: false }) || []) {
@@ -1514,6 +1518,9 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     }
     for (const timer of reapTimers.values()) clearTimeout(timer);
     reapTimers.clear();
+    tags.clear();
+    tagAgents.clear();
+    tagCwds.clear();
     flushWorkerIndexMutations();
     writeWorkerRows((byKey) => byKey.clear());
     return { closed, failed };

package/src/tui/App.jsx

@@ -107,7 +107,6 @@ import {
   transcriptItemVariantKey,
   transcriptMeasuredRowsCache,
   buildTranscriptRowIndex,
-  transcriptStructureSignature,
   transcriptRenderWindow,
 } from './app/transcript-window.mjs';
 import {
@@ -2951,6 +2950,8 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     transcriptMeasureRef,
   } = useTranscriptWindow({
     items: state.items,
+    structureRevision: state.structureRevision,
+    streamingTail: state.streamingTail,
     themeEpoch: state.themeEpoch,
     frameColumns,
     toolOutputExpanded,

package/src/tui/app/transcript-window.mjs

@@ -832,7 +832,7 @@ export function buildTranscriptRowIndexIncremental(items, {
   suppressMeasuredRowHeights = false,
   measuredRowsVersion = 0,
   cacheRef = null,
-  prefixSig = null,
+  prefixRevision = null,
 } = {}) {
   const allItems = Array.isArray(items) ? items : [];
   const tail = trailingStreamingItem(allItems);
@@ -850,11 +850,10 @@ export function buildTranscriptRowIndexIncremental(items, {
   }
   const prefixLen = allItems.length - 1;
   const cache = holder.current;
-  // Prefix identity is carried by `prefixSig` (a hash of every prefix item's
-  // WeakMap sigPart, computed once in the hook). String equality catches a
-  // same-length MIDDLE-item replacement (tool-card patch swaps a middle object →
-  // fresh fragment → different sig), which a last-item ref check would miss.
-  // Fast path: same prefix length + tail id + prefixSig, and columns/expanded/
+  // Prefix identity is carried by the engine's monotonic structure revision.
+  // Every settled-item mutation, including same-length middle tool-card patches,
+  // bumps it without requiring a render-time walk over the transcript.
+  // Fast path: same prefix length + tail id + revision, and columns/expanded/
   // suppress/version all match. Only the tail row can differ → recompute + append.
   if (cache
     && cache.columns === columns
@@ -862,10 +861,10 @@ export function buildTranscriptRowIndexIncremental(items, {
     && cache.suppress === suppressMeasuredRowHeights
     && cache.version === measuredRowsVersion
     && cache.prefixLen === prefixLen
-    && prefixSig != null
-    && cache.prefixSig === prefixSig
+    && prefixRevision != null
+    && cache.prefixRevision === prefixRevision
     && cache.tailId === tail.id) {
-    // prefixSig matches → prefix rows provably unchanged; NO prefix walk / no
+    // revision matches → prefix rows provably unchanged; NO prefix walk / no
     // re-estimation. Only the tail row can differ, recompute it.
     {
       const tailMeasured = suppressMeasuredRowHeights
@@ -894,7 +893,7 @@ export function buildTranscriptRowIndexIncremental(items, {
     suppress: suppressMeasuredRowHeights,
     version: measuredRowsVersion,
     prefixLen,
-    prefixSig,
+    prefixRevision,
     tailId: tail.id,
     prefixRowsArr: full.rows.slice(0, prefixLen),
     prefixPrefixRows: full.prefixRows.slice(0, prefixLen + 1),