mixdog 0.9.37 → 0.9.38

package/src/rules/agent/30-explorer.md

@@ -12,10 +12,13 @@ Coordinate locator. Deliver WHERE as `path:line`, never WHY. You ARE
 Tools: grep/find/glob/code_graph ONLY. `read`/`list` are forbidden with no
 exception; grep/code_graph lines already carry the `path:line` answer.
 
-Turn 1 is the whole search in ONE message: grep `pattern[]` with 3-6 code-token
-variants, code_graph symbol_search for identifiers, and (for unknown/broad
-targets) find `query[]` with path/name fragments from multiple tokens. A
-single-pattern or single-tool first turn is a defect.
+Turn 1 is the WHOLE search in ONE message, non-negotiable: in that single tool
+message fire grep `pattern[]` (3-6 code-token variants) AND code_graph
+symbol_search (identifiers) AND — for unknown/broad targets — find `query[]`
+(path/name fragments from multiple tokens), all together. Never emit grep alone
+and wait for its result before adding code_graph/find: serial one-tool-per-turn
+is the top budget defect and forfeits the expected turn 1 -> answer path. A
+single-pattern or single-tool first turn is malformed.
 
 Broad grep must use `output_mode:"files_with_matches"`. Use
 `content_with_context` only on a path returned earlier in THIS session and with
@@ -24,14 +27,15 @@ Broad grep must use `output_mode:"files_with_matches"`. Use
 Translate natural/non-English queries to probable English identifiers first;
 grep non-ASCII only for quoted literal strings.
 
-Scope = session working directory. Omit `path` only for a verified project cwd;
-otherwise use only paths returned earlier in this session. If the query or plan
-names an unverified path/name fragment (`src`, `lib`, package/file stem, etc.),
-run `find` for it before any `grep`/`glob` using that path; only an exact
-returned path may be passed to `grep`/`glob`. Never use `path:"."` with guessed
-globs (`src/**`, `lib/**`, etc.) to mask misses, especially from a home or
-machine-wide cwd. Never invent directories; after zero hits change TOKENS/scope,
-not wording or guessed paths.
+Scope = session working directory. Omitting `path` (project cwd default scope)
+is always allowed. When the query or plan names an unverified path/name fragment
+(`src`, `lib`, package/file stem, etc.), its `find query[]` rides the SAME turn-1
+batch as the unscoped `grep pattern[]`/`code_graph` — a find-only turn is a
+defect. A scoped `grep`/`glob` may use that fragment only via an exact
+`find`-returned path (turn 2 recovery at the earliest), never a guess. Never use
+`path:"."` with guessed globs (`src/**`, `lib/**`, etc.) to mask misses,
+especially from a home or machine-wide cwd. Never invent directories; after zero
+hits change TOKENS/scope, not wording or guessed paths.
 
 Hit test is mechanical: any `path:line` containing a query token or obvious
 synonym is an anchor; generic-only words (schema/handler/config/resolver…)
@@ -45,12 +49,26 @@ matched zero specific tokens); a turn spent to confirm, refine, or upgrade an
 anchor you already hold is a defect.
 
 Turns: max 3, expected 1; start tool messages with `turn N/3`. Turns 2-3 are
-miss recovery only and must change tokens or scope.
+miss recovery only and must change tokens or scope. BUDGET = TWO MESSAGES
+normally: message 1 = the multi-tool batch, message 2 = your answer text. A 3rd
+message (any extra tool call) is a defect unless message 1 returned zero
+specific-token lines — extra code_graph/grep calls to confirm or upgrade an
+anchor you already hold are the biggest source of overspend.
 
 Flow/how and compound queries: first matching entry/definition anchors answer
-the concept/value/default; never trace chains or launch extra value searches.
+the concept/value/default; do not trace chains or launch extra value searches —
+with ONE exception: when the query EXPLICITLY asks a flow/default-resolution
+question and turn 1 produced only an entry anchor (not the resolved value),
+turn 2 may follow a SINGLE hop to the resolving site, then stop.
 
 Answer only: up to 3 lines `path:line — symbol — short reason` (`?` if weak),
-choosing the most specific token matches. Emit `EXPLORATION_FAILED` only after
-budget is spent with zero specific-token anchors; before failing, re-scan prior
-results and prefer any weak specific-token anchor over a false miss.
+choosing the most specific token matches. For a CODE-location answer every line
+MUST carry a `:line` (explicit line number) — a bare filename with no `:line`
+is a defect; with no line-anchored code evidence, return `EXPLORATION_FAILED`
+rather than a vague file-only or prose answer. EXCEPTION — file/dir-location
+queries (where X stores its config/logs/data on disk, which directory or file
+holds Y): an exact verified path (the file or directory itself, no `:line`) IS
+the valid answer; do not force a line number or fail. Emit `EXPLORATION_FAILED`
+only after budget is spent with zero specific-token anchors; before failing,
+re-scan prior results and prefer any weak specific-token anchor over a false
+miss.

package/src/rules/shared/01-tool.md

@@ -16,9 +16,13 @@
   error origin, ...) and send them as ONE `query[]` call — facets run in
   parallel. Never fan out rephrasings of the same target; on
   EXPLORATION_FAILED, retry once with changed tokens.
-- Verified paths = user-provided or tool-returned. Guessed/unknown path →
-  `find`/`glob`/`explore` first; ENOENT → `find` basename, never retry a guess
-  or invent absolute paths outside the project.
+- Verified = user-provided, tool-returned, or the session project cwd itself.
+  Unscoped grep/glob/list from the project root needs NO find hop; find only
+  resolves a genuinely guessed path-name fragment, and it rides the SAME turn
+  as independent probes (unscoped grep, code_graph) — never a solo
+  path-verification turn. ENOENT → `find` basename, never retry a guess; don't
+  mask a miss with a guessed glob scope (path "." + `src/**`) or an invented
+  absolute path, but plain project-root searches are fine.
 - Retrieval stops when evidence covers the deliverable: single-answer tasks
   end at the first sufficient anchor; enumeration tasks (review, audit) end
   when the stated scope is covered. Never re-verify a hit already on screen;

package/src/runtime/agent/orchestrator/dispatch-persist.mjs

@@ -372,6 +372,27 @@ export function recoverPending(dataDir, notifyFn, { sessionId, priorSessionId, c
         const entry = map[handle] || {};
         const tool = entry.tool || 'dispatch';
         const queries = Array.isArray(entry.queries) ? entry.queries : [];
+        // Determine the true owner session for this entry. A scoped recovery
+        // may have matched purely on clientHostPid (not on the owner session
+        // id); in that case we must NOT stamp the reconnecting filter session's
+        // id onto another session's abort — that injects an old-session abort
+        // into the wrong resumed session. Deliver to the true owner session, or
+        // leave the entry persisted when it carries no owner session to target.
+        const cid = entry.callerSessionId != null && String(entry.callerSessionId)
+          ? String(entry.callerSessionId)
+          : null;
+        const ownerMatch = cid != null && (cid === filterSid || (priorSid != null && cid === priorSid));
+        if (scoped && !ownerMatch && cid == null) {
+          // hostPid-only match with no owner session id — cannot target a
+          // session safely. Leave persisted for a correctly-scoped recovery.
+          continue;
+        }
+        // Owner match → prefer the reconnecting filter session id (the owner's
+        // new session). When only priorSessionId matched and no current
+        // sessionId was supplied, filterSid is null — keep the entry's known
+        // owner `cid` for stamping/ack scoping rather than dropping it.
+        // Non-owner matches (hostPid-only) always stamp the entry's true owner.
+        const stampSid = (ownerMatch && filterSid) ? filterSid : cid;
         // Single recovery mode: the worker was in flight at restart. Emit the
         // Aborted boilerplate so the Lead can retry. Completed result bodies are
         // never persisted, so there is nothing to replay here.
@@ -383,21 +404,23 @@ export function recoverPending(dataDir, notifyFn, { sessionId, priorSessionId, c
           dispatch_id: handle,
           tool,
           error: String(isError),
-          ...(filterSid
-            ? { caller_session_id: filterSid }
-            : (entry.callerSessionId ? { caller_session_id: entry.callerSessionId } : {})),
+          ...(stampSid ? { caller_session_id: stampSid } : {}),
           ...(filterHostPid > 0
             ? { client_host_pid: String(filterHostPid) }
             : (entry.clientHostPid > 0 ? { client_host_pid: String(entry.clientHostPid) } : {})),
           instruction: `Earlier ${tool} dispatch (${handle}) was aborted by a plugin restart. Retry if the answer is still needed.`,
         };
         try { process.stderr.write(`[dispatch-persist] recover handle=${handle} tool=${tool} kind=abort\n`); } catch { /* best-effort */ }
-        // Entry remains on disk until notifyFn resolves.  A crash between
-        // fire and ack is safe: the entry survives and recoverPending re-fires
-        // it on the next restart.  Only clear AFTER ack to prevent silent loss.
+        // Entry remains on disk until notifyFn settles as DELIVERED. Matching
+        // notifyToolCompletion settlement semantics (tool-execution-contract),
+        // only an explicit `false`/`0` resolve counts as undelivered and keeps
+        // the entry for retry; any other resolve (including `undefined`/void
+        // from a delivered notifyFn) removes it — otherwise it re-fires until
+        // TTL. A crash between fire and ack is likewise safe: the entry survives
+        // and recoverPending re-fires it on the next restart.
         try {
-          Promise.resolve(notifyFn(content, meta)).then(() => {
-            removePending(dataDir, handle);
+          Promise.resolve(notifyFn(content, meta)).then((ok) => {
+            if (ok !== false && ok !== 0) removePending(dataDir, handle);
           }).catch(() => { /* best-effort — entry stays for next recoverPending */ });
         } catch { /* best-effort */ }
       }

package/src/runtime/agent/orchestrator/providers/anthropic-oauth-credentials.mjs

@@ -411,6 +411,14 @@ export async function beginOAuthLogin() {
     };
     const url = buildUrl(OAUTH_REDIRECT_URI);
     const manualUrl = buildUrl(OAUTH_MANUAL_REDIRECT_URI);
+    const openLoginUrl = async (targetUrl, label = 'login') => {
+        try {
+            const { openInBrowser } = await import('../../../shared/open-url.mjs');
+            openInBrowser(targetUrl.toString());
+        } catch (err) {
+            process.stderr.write(`[anthropic-oauth] browser open failed for ${label} URL: ${String(err?.message || err).slice(0, 200)}\n`);
+        }
+    };
 
     let server = null;
     let timeout = null;
@@ -454,14 +462,12 @@ export async function beginOAuthLogin() {
         timeout = setTimeout(() => finish(null), OAUTH_LOGIN_TIMEOUT_MS);
         server.listen(OAUTH_CALLBACK_PORT, OAUTH_CALLBACK_HOST, async () => {
             process.stderr.write(`\n[anthropic-oauth] Open this URL to log in with Claude:\n${url.toString()}\n\nIf the localhost callback cannot complete, open this manual URL and paste the shown code#state:\n${manualUrl.toString()}\n\n`);
-            try {
-                const { openInBrowser } = await import('../../../shared/open-url.mjs');
-                openInBrowser(url.toString());
-            } catch (err) {
-                process.stderr.write(`[anthropic-oauth] browser open failed: ${String(err?.message || err).slice(0, 200)}\n`);
-            }
+            await openLoginUrl(url, 'callback');
+        });
+        server.on('error', async (err) => {
+            process.stderr.write(`\n[anthropic-oauth] localhost callback unavailable on ${OAUTH_CALLBACK_HOST}:${OAUTH_CALLBACK_PORT}: ${err?.message || err}\n[anthropic-oauth] Opening manual login URL instead. Paste the shown code#state:\n${manualUrl.toString()}\n\n`);
+            await openLoginUrl(manualUrl, 'manual');
         });
-        server.on('error', (err) => finish(null, new Error(`[anthropic-oauth] callback server failed on ${OAUTH_CALLBACK_HOST}:${OAUTH_CALLBACK_PORT}: ${err?.message || err}`)));
     });
 
     return {

package/src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs

@@ -897,12 +897,12 @@ export async function sendViaWebSocket({
 
             // Warmup writes the same prefix with generate:false, but the first
             // real response must still be a FULL generating frame. Reusing the
-            // warmup response_id here causes _buildResponseCreateFrame() to drop
-            // `instructions` (previous_response_id frames cannot carry them) and
-            // can also reduce the frame input to [] when the warmup input matches.
-            // That made first-turn lead/system rules effectively disappear
-            // ("who are you?" answered as a generic OpenAI assistant). Keep the
-            // warmup state for cache/trace, but compute the main frame as cold.
+            // warmup response_id here would make _computeDelta reduce the frame
+            // input to [] when the warmup input matches, and a generate:false
+            // warmup is not a chainable response to continue from — so the first
+            // real turn would generate from an empty frame. Keep the warmup state
+            // for cache/trace, but compute the main frame as cold (full input +
+            // instructions).
             const deltaEntry = warmupResult
                 ? {
                     ...entry,

package/src/runtime/agent/orchestrator/providers/openai-ws-delta.mjs

@@ -195,9 +195,11 @@ const TRANSPORT_ONLY_FRAME_FIELDS = new Set(['stream', 'background']);
 // identical byte-for-byte: `type` always leads, then the body's codex
 // struct-order keys follow verbatim. A delta send passes previousResponseId
 // (inserted immediately before `input`, matching codex's refs position) and
-// inputOverride (the stripped tail); instructions are dropped whenever
-// previous_response_id is present because the server resolves them from the
-// chained response and rejects sending both fields together.
+// inputOverride (the stripped tail). `instructions` MUST still be resent on
+// previous_response_id frames: per the OpenAI Responses API, the previous
+// response's top-level instructions are NOT carried over to the chained
+// response, so dropping them here strips the system/lead prompt from every
+// continuation turn. Only an empty instructions string is omitted.
 // Full/warmup frames pass the body unchanged and keep every key in place.
 // omitTransportFields is used by wire-parity/prewarm helpers to drop stream/background.
 export function _buildResponseCreateFrame(body, { previousResponseId = null, inputOverride, omitTransportFields = false } = {}) {
@@ -215,7 +217,6 @@ export function _buildResponseCreateFrame(body, { previousResponseId = null, inp
     for (const key of Object.keys(src)) {
         if (omitTransportFields && TRANSPORT_ONLY_FRAME_FIELDS.has(key)) continue;
         if (key === 'instructions') {
-            if (previousResponseId != null) continue;
             const instr = src.instructions;
             if (typeof instr === 'string' && instr.length) frame.instructions = instr;
             continue;

package/src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs

@@ -15,6 +15,10 @@ import { codexOriginator, codexUserAgent, codexVersionHeader } from './codex-cli
 import {
     PROVIDER_WS_ACQUIRE_TIMEOUT_MS,
     PROVIDER_WS_HANDSHAKE_TIMEOUT_MS,
+    PROVIDER_WS_PING_ENABLED,
+    PROVIDER_WS_PING_INTERVAL_MS,
+    PROVIDER_WS_PONG_TIMEOUT_MS,
+    PROVIDER_WS_LIVENESS_STALE_MS,
     resolveTimeoutMs,
 } from '../stall-policy.mjs';
 
@@ -36,6 +40,10 @@ export const WS_IDLE_MS = resolveTimeoutMs(
 );
 const WS_HANDSHAKE_TIMEOUT_MS = PROVIDER_WS_HANDSHAKE_TIMEOUT_MS;
 const WS_ACQUIRE_TIMEOUT_MS = PROVIDER_WS_ACQUIRE_TIMEOUT_MS;
+const WS_PING_INTERVAL_MS = PROVIDER_WS_PING_INTERVAL_MS;
+const WS_PONG_TIMEOUT_MS = PROVIDER_WS_PONG_TIMEOUT_MS;
+const WS_LIVENESS_STALE_MS = PROVIDER_WS_LIVENESS_STALE_MS;
+const WS_PING_ENABLED = PROVIDER_WS_PING_ENABLED;
 
 // WS socket pool buckets are keyed by `poolKey` (the per-call sessionId)
 // to isolate parallel agent invocations — each gets its own socket so
@@ -263,6 +271,10 @@ function _getPoolArr(poolKey) {
 }
 
 function _removeFromPool(poolKey, entry) {
+    // Always tear down per-entry timers so evicting a socket never leaks an
+    // idle-close or liveness-ping interval.
+    _clearIdle(entry);
+    _clearLiveness(entry);
     if (!poolKey) return;
     const arr = _wsPool.get(poolKey);
     if (!arr) return;
@@ -293,6 +305,70 @@ function _isOpen(entry) {
     return entry?.socket?.readyState === WebSocket.OPEN;
 }
 
+function _clearLiveness(entry) {
+    if (entry?.pingTimer) {
+        clearInterval(entry.pingTimer);
+        entry.pingTimer = null;
+    }
+}
+
+// Force a dead/half-open socket out of the pool. close() alone can hang on a
+// wedged socket, so follow with terminate() to guarantee FD release.
+function _evictDead(poolKey, entry) {
+    try { entry.socket.close(1000, 'ws_liveness_dead'); } catch {}
+    try { entry.socket.terminate?.(); } catch {}
+    _removeFromPool(poolKey, entry);
+}
+
+// Send one ws-level ping and resolve true iff a pong lands within timeoutMs.
+// Never rejects. On any success it refreshes lastAliveAt so the caller/loop
+// treats the socket as fresh.
+function _pingProbe(entry, timeoutMs) {
+    return new Promise((resolve) => {
+        const socket = entry?.socket;
+        if (!socket || socket.readyState !== WebSocket.OPEN) { resolve(false); return; }
+        let done = false;
+        const finish = (alive) => {
+            if (done) return;
+            done = true;
+            clearTimeout(timer);
+            try { socket.removeListener('pong', onPong); } catch {}
+            resolve(alive);
+        };
+        const onPong = () => { entry.lastAliveAt = Date.now(); finish(true); };
+        const timer = setTimeout(() => finish(false), timeoutMs);
+        try { timer.unref?.(); } catch {}
+        try {
+            socket.on('pong', onPong);
+            socket.ping();
+        } catch {
+            finish(false);
+        }
+    });
+}
+
+// While an entry sits idle in the pool, ping it every WS_PING_INTERVAL_MS.
+// A missed pong (or a socket that is no longer OPEN) evicts the entry so it can
+// never be handed out dead. Busy entries are skipped — an in-flight turn has
+// its own inter-chunk/semantic-idle watchdogs.
+function _armLiveness(poolKey, entry) {
+    _clearLiveness(entry);
+    entry.pingTimer = setInterval(async () => {
+        if (entry.busy || entry.closing || entry.probing) return;
+        if (!_isOpen(entry)) { _evictDead(poolKey, entry); return; }
+        // Recent activity ⇒ assume live, skip the probe this tick.
+        if (Date.now() - (entry.lastAliveAt || 0) < WS_LIVENESS_STALE_MS) return;
+        entry.probing = true;
+        try {
+            const alive = await _pingProbe(entry, WS_PONG_TIMEOUT_MS);
+            if (!alive && !entry.busy) _evictDead(poolKey, entry);
+        } finally {
+            entry.probing = false;
+        }
+    }, WS_PING_INTERVAL_MS);
+    try { entry.pingTimer.unref?.(); } catch {}
+}
+
 // Awaited frame send. Asserts the socket is OPEN and resolves only after
 // the underlying transport reports the buffered write succeeded (or fails)
 // via the WebSocket send callback. Raw `socket.send(JSON.stringify(...))`
@@ -596,15 +672,36 @@ export async function acquireWebSocket({ auth, poolKey, cacheKey, codexHeaders,
         for (let i = arr.length - 1; i >= 0; i--) {
             if (!_isOpen(arr[i]) || arr[i].closing) {
                 _clearIdle(arr[i]);
+                _clearLiveness(arr[i]);
                 arr.splice(i, 1);
             }
         }
         if (arr.length === 0) _wsPool.delete(poolKey);
-        // Reuse any idle open entry (cache-warm path).
-        const idle = arr.find(e => !e.busy);
-        if (idle) {
+        // Reuse an idle open entry (cache-warm path). An entry with no observed
+        // activity within the freshness window is ping-probed under a short
+        // bound before hand-out; a dead one is evicted and the scan retries the
+        // next idle entry so a busy caller is never handed a wedged socket.
+        let idle;
+        while ((idle = arr.find(e => !e.busy))) {
             _clearIdle(idle);
+            _clearLiveness(idle);
+            // Reserve the entry BEFORE awaiting the probe: _pingProbe yields the
+            // event loop, so without this a second concurrent acquire could scan
+            // the same still-idle entry and both would take it. Marking busy up
+            // front makes the find() above skip it; on probe failure it is
+            // evicted (removed from arr) so the loop continues cleanly.
             idle.busy = true;
+            if (WS_PING_ENABLED && Date.now() - (idle.lastAliveAt || 0) >= WS_LIVENESS_STALE_MS) {
+                const alive = await _pingProbe(idle, WS_PONG_TIMEOUT_MS);
+                if (!alive) {
+                    if (process.env.MIXDOG_DEBUG_AGENT) {
+                        process.stderr.write(`[agent-trace] acquire-evict-dead poolKey=${poolKey} reason=missed_pong elapsed=${Date.now() - _acqStart}ms\n`);
+                    }
+                    _evictDead(poolKey, idle);
+                    continue;
+                }
+            }
+            idle.lastAliveAt = Date.now();
             // Defensive: pre-existing pooled entries created before the
             // prefix-hash field was introduced may not have it set. Normalize
             // to null so the first delta check reads a deterministic value
@@ -646,6 +743,11 @@ export async function acquireWebSocket({ auth, poolKey, cacheKey, codexHeaders,
                 ephemeral: true,
                 sessionToken: ephSessionToken,
             };
+            entry.lastAliveAt = Date.now();
+            entry.pingTimer = null;
+            entry.probing = false;
+            socket.on('pong', () => { entry.lastAliveAt = Date.now(); });
+            socket.on('message', () => { entry.lastAliveAt = Date.now(); });
             socket.on('close', () => { entry.closing = true; });
             return { entry, reused: false };
         }
@@ -674,6 +776,11 @@ export async function acquireWebSocket({ auth, poolKey, cacheKey, codexHeaders,
         ephemeral: false,
         sessionToken,
     };
+    entry.lastAliveAt = Date.now();
+    entry.pingTimer = null;
+    entry.probing = false;
+    socket.on('pong', () => { entry.lastAliveAt = Date.now(); });
+    socket.on('message', () => { entry.lastAliveAt = Date.now(); });
     if (poolKey && !forceFresh) _getPoolArr(poolKey).push(entry);
     socket.on('close', () => {
         entry.closing = true;
@@ -690,7 +797,12 @@ export function releaseWebSocket({ entry, poolKey, keep }) {
         _removeFromPool(poolKey, entry);
         return;
     }
+    // Mark activity at release, then arm both the idle-close timer and the
+    // periodic liveness ping so a socket that dies while pooled is evicted
+    // before the next acquire can hand it out.
+    entry.lastAliveAt = Date.now();
     _scheduleIdleClose(poolKey, entry);
+    if (WS_PING_ENABLED) _armLiveness(poolKey, entry);
 }
 
 // Drain-complete fence — set true once _closeAllPooledSockets runs so any
@@ -706,6 +818,10 @@ export function _closeAllPooledSockets(reason = 'shutdown') {
     _drainComplete = true;
     for (const arr of _wsPool.values()) {
         for (const entry of arr) {
+            // Tear down per-entry timers before dropping the map, otherwise the
+            // idle-close and liveness-ping intervals outlive the drained pool.
+            _clearIdle(entry);
+            _clearLiveness(entry);
             try { entry.socket.close(1000, reason); } catch {}
         }
     }

package/src/runtime/agent/orchestrator/session/manager/ask-session.mjs

@@ -44,14 +44,6 @@ import { _tryBridgeExplicitPrefetch } from './prefetch-bridge.mjs';
 import { sanitizeSessionMessagesForModel, persistCompactedOutgoingAfterAskFailure } from './message-sanitize.mjs';
 import { _getAgentLoop } from './runtime-loaders.mjs';
 import { getAgentRuntimeSync } from './agent-runtime-singleton.mjs';
-import { nonNegativeIntEnv } from './env-utils.mjs';
-
-// Cap how long the terminal unwind blocks on the post-result session save.
-// The result is already produced (and relayed for agent surfaces) before this
-// save, so a stalled disk write must not hold askSession() open — otherwise the
-// owning background task is stranded in `running` and its completion
-// notification never fires. A slow write finishes in the background.
-const TERMINAL_SAVE_TIMEOUT_MS = nonNegativeIntEnv('MIXDOG_TERMINAL_SAVE_TIMEOUT_MS', 5_000);
 
 /**
  * Wrap an async call so that if the session's controller aborts mid-flight,
@@ -567,37 +559,17 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // query/provider send (agentLoop pre-send), not after the previous
             // answer. This lets queued follow-up prompts resume immediately;
             // if they need compaction, their own spinner shows compacting first.
-            // Bounded, best-effort terminal save. The result is already produced
-            // and (for agent surfaces) relayed via onTerminalResult above. If the
-            // disk write stalls, blocking the terminal unwind here would strand the
-            // owning background task in `running` and suppress its completion
-            // notification. Cap the wait; let a slow write finish in the
-            // background instead of holding askSession() open indefinitely.
-            let terminalSaveTimedOut = false;
-            {
-                const savePromise = saveSessionAsync(session, { expectedGeneration: askGeneration });
-                let saveTimer = null;
-                const saveTimeout = new Promise((resolveTimeout) => {
-                    saveTimer = setTimeout(() => resolveTimeout('__save_timeout__'), TERMINAL_SAVE_TIMEOUT_MS);
-                    saveTimer.unref?.();
-                });
-                try {
-                    const outcome = await Promise.race([
-                        savePromise.then(() => '__save_ok__', (err) => { throw err; }),
-                        saveTimeout,
-                    ]);
-                    if (outcome === '__save_timeout__') {
-                        terminalSaveTimedOut = true;
-                        try { process.stderr.write(`[session] terminal save exceeded ${TERMINAL_SAVE_TIMEOUT_MS}ms; continuing best-effort (${sessionId})\n`); } catch {}
-                        // Don't drop the write — let it settle in the background.
-                        savePromise.catch((err) => {
-                            try { process.stderr.write(`[session] deferred terminal save failed: ${err?.message || err}\n`); } catch {}
-                        });
-                    }
-                } finally {
-                    if (saveTimer) { try { clearTimeout(saveTimer); } catch {} }
-                }
-            }
+            // Fire-and-forget terminal save. The result is already produced and
+            // (for agent surfaces) relayed via onTerminalResult above, and
+            // saveSessionAsync() has already published the in-memory snapshot via
+            // setLiveSession(), so read-your-writes holds in-process without
+            // awaiting disk. Never block the terminal unwind on the write — that
+            // would strand the owning background task in `running` and suppress
+            // its completion notification. A slow write finishes in the
+            // background.
+            saveSessionAsync(session, { expectedGeneration: askGeneration }).catch((err) => {
+                try { process.stderr.write(`[session] terminal save failed: ${err?.message || err}\n`); } catch {}
+            });
             activeSession = session;
             runtime.session = session;
             // Tag empty-synthesis BEFORE markSessionDone so the watchdog
@@ -675,19 +647,13 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             const _mergedTail = _mergePendingMessageEntries(_drained);
             if (_mergedTail?.content) {
                 _pendingTail.push(_mergedTail.content);
-                if (terminalSaveTimedOut) {
-                    // The disk snapshot may still be stale; carry the just-
-                    // committed in-memory session into the follow-up turn so
-                    // the queued tail sees the preceding assistant/tool context.
-                    activeSession = session;
-                    runtime.session = session;
-                } else {
-                    const refreshed = loadSession(sessionId);
-                    if (refreshed && refreshed.closed !== true) {
-                        activeSession = refreshed;
-                        runtime.session = refreshed;
-                    }
-                }
+                // Carry the just-committed in-memory session into the follow-up
+                // turn so the queued tail sees the preceding assistant/tool
+                // context. loadSession() would return this same live snapshot
+                // (setLiveSession published it), so skip the disk round-trip.
+                // NOTE: `session` (try-block const, :179) is out of scope here —
+                // `activeSession` already holds the committed session.
+                runtime.session = activeSession;
                 continue;
             }
         }