mixdog 0.9.93 → 0.9.95

package/src/runtime/agent/orchestrator/session/cache/scoped-cache.mjs

@@ -5,6 +5,7 @@
 import { join, resolve as _pathResolve, isAbsolute as _pathIsAbs, normalize as _pathNorm } from 'node:path';
 import { writeJsonAtomicSync } from '../../../../shared/atomic-file.mjs';
 import { _normalizeCacheKey } from './util.mjs';
+import { GREP_AUTO_CONTEXT_LINES } from '../../tools/builtin/path-utils.mjs';
 
 const MAX_PER_SESSION = 100;
 
@@ -43,6 +44,22 @@ function _firstArg(args, names) {
     return undefined;
 }
 
+const _GREP_CONTEXT_GROUPS = [
+    ['-A', ['-A', 'A', 'after', 'after_context', 'afterContext', '--after-context', 'after-context', 'afterLines', 'after_lines']],
+    ['-B', ['-B', 'B', 'before', 'before_context', 'beforeContext', '--before-context', 'before-context', 'beforeLines', 'before_lines']],
+    ['context', ['context', '-C', 'C', 'context_lines', 'contextLines', '--context', 'contextN', 'around', 'surrounding']],
+];
+
+function _canonicalizeGrepContextArgs(args) {
+    for (const [canonical, aliases] of _GREP_CONTEXT_GROUPS) {
+        const value = _firstArg(args, aliases);
+        for (const alias of aliases) delete args[alias];
+        if (value === undefined) continue;
+        const numeric = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+        args[canonical] = Number.isFinite(numeric) && Number.isInteger(numeric) ? numeric : value;
+    }
+}
+
 function _canonicalToolArgs(toolName, args) {
     if (!args || typeof args !== 'object') return args;
     const next = { ...args };
@@ -59,12 +76,35 @@ function _canonicalToolArgs(toolName, args) {
             const alias = _firstArg(next, ['root', 'directory', 'dir']);
             if (alias !== undefined) next.path = alias;
         }
+        _canonicalizeGrepContextArgs(next);
         if ((next.output_mode === undefined || next.output_mode === null || next.output_mode === '') && typeof next.mode === 'string') {
             const mode = next.mode.trim();
-            if (['files_with_matches', 'content', 'count'].includes(mode)) next.output_mode = mode;
+            if (['files_with_matches', 'content', 'content_with_context', 'count'].includes(mode)) next.output_mode = mode;
         }
         for (const k of ['query', 'regex', 'regexp', 'needle', 'search', 'literal', 'file_pattern', 'filePattern', 'include', 'includes', 'files', 'root', 'directory', 'dir']) delete next[k];
-        if (next.output_mode && next.mode === next.output_mode) delete next.mode;
+        delete next.mode;
+
+        // Canonicalize by execution semantics, not caller spelling:
+        // omitted/content_with_context => content + automatic 25-line context;
+        // context:0 => bare content; context flags are ignored in count/files.
+        const requestedMode = typeof next.output_mode === 'string' ? next.output_mode.trim() : '';
+        if (requestedMode === 'files_with_matches' || requestedMode === 'count') {
+            next.output_mode = requestedMode;
+            delete next['-A'];
+            delete next['-B'];
+            delete next.context;
+        } else {
+            const hasExplicitContext = ['-A', '-B', 'context']
+                .some((key) => Object.prototype.hasOwnProperty.call(next, key));
+            next.output_mode = 'content';
+            if ((requestedMode === '' || requestedMode === 'content_with_context') && !hasExplicitContext) {
+                next.context = GREP_AUTO_CONTEXT_LINES;
+            }
+            if (next.context === 0 && !Object.prototype.hasOwnProperty.call(next, '-A')
+                && !Object.prototype.hasOwnProperty.call(next, '-B')) {
+                delete next.context;
+            }
+        }
     } else if (toolName === 'glob') {
         if (next.pattern === undefined || next.pattern === null || next.pattern === '') {
             const alias = _firstArg(next, ['glob', 'file_pattern', 'filePattern', 'name', 'include', 'includes', 'files']);

package/src/runtime/agent/orchestrator/session/context-compaction-policy.mjs

@@ -2,7 +2,9 @@ import { isAgentOwner } from '../agent-owner.mjs';
 
 export const DEFAULT_COMPACTION_BUFFER_TOKENS = 0;
 export const DEFAULT_COMPACTION_BUFFER_RATIO = 0.1;
-export const DEFAULT_MAIN_COMPACTION_BUFFER_RATIO = 0.05;
+// Main/user sessions default to full-window trigger (buffer 0): RFT compact
+// runs at the boundary. Agent sessions keep DEFAULT_COMPACTION_BUFFER_RATIO.
+export const DEFAULT_MAIN_COMPACTION_BUFFER_RATIO = 0;
 export const MAX_COMPACTION_BUFFER_RATIO = 0.25;
 const MAX_BUFFER_INPUT_RATIO = 0.999_999;
 export const DEFAULT_COMPACTION_KEEP_TOKENS = 8_000;
@@ -16,9 +18,14 @@ function envTokenInt(name) {
     return positiveTokenInt(process.env[name]);
 }
 export function normalizeCompactionBufferRatio(value, fallback = DEFAULT_COMPACTION_BUFFER_RATIO) {
+    // Explicit 0 is a valid buffer (main full-window trigger). Only nullish /
+    // empty / non-finite / negative values fall back. Do not treat Number(null)
+    // as zero here — null must mean "unset".
+    if (value == null || value === '') return fallback;
     const n = Number(value);
-    if (Number.isFinite(n) && n > 0) return n > 1 ? n / 100 : n;
-    return fallback;
+    if (!Number.isFinite(n) || n < 0) return fallback;
+    if (n === 0) return 0;
+    return n > 1 ? n / 100 : n;
 }
 export function resolveBufferRatioCandidate(percentInputs = [], ratioInputs = []) {
     for (const raw of percentInputs) {

package/src/runtime/agent/orchestrator/session/context-utils.mjs

@@ -160,11 +160,10 @@ export function providerTokenCalibration(provider) {
     if (p.startsWith('gemini') || p.startsWith('google')) return calibrationEnv('MIXDOG_TOKEN_CALIBRATION_GEMINI') ?? 1.15;
     return calibrationEnv('MIXDOG_TOKEN_CALIBRATION_DEFAULT') ?? 1.0;
 }
-// Claude Code parity (services/tokenEstimation.ts): images/documents count a
-// flat 2000 tokens when dimensions are unknown — the conservative constant CC
-// shares with microCompact's IMAGE_MAX_TOKEN_SIZE. Known dimensions may only
-// RAISE the allowance via Anthropic's real vision formula (w*h/750), capped at
-// the 2000x2000 resize ceiling (5333 tokens).
+// Images/documents count a flat 2000 tokens when dimensions are unknown —
+// the conservative constant also used by the micro-compaction path. Known
+// dimensions may only RAISE the allowance via Anthropic's real vision
+// formula (w*h/750), capped at the 2000x2000 resize ceiling (5333 tokens).
 export const IMAGE_VISUAL_TOKEN_ALLOWANCE = 2_000;
 const IMAGE_MAX_TOKEN_ALLOWANCE = 5_333;
 
@@ -249,8 +248,8 @@ function legacyEstimateTokens(s) {
     // for those runs without penalizing ordinary spaced prose.
     let denseAsciiFloor = 0;
     for (const match of s.matchAll(/[\x21-\x7e]{16,}/g)) {
-        // Claude Code prices dense JSON/JSONL at chars/2 (bytesPerTokenForFileType);
-        // 0.5/char keeps that parity for long unmerged printable runs.
+        // Dense JSON/JSONL prices at chars/2; 0.5/char keeps that ratio for
+        // long unmerged printable runs.
         denseAsciiFloor += match[0].length * 0.5;
     }
     const encodedWords = s.match(/\b(?=[A-Za-z0-9]{8,}\b)(?=[A-Za-z0-9]*[A-Za-z])(?=[A-Za-z0-9]*\d)[A-Za-z0-9]+\b/g) || [];
@@ -272,7 +271,7 @@ function legacyEstimateTokens(s) {
         && (jsonLikeLines >= Math.ceil(lines.length / 2) || structural / nonWhitespace >= 0.12)) {
         // JSONL, compact tables and generated line protocols can consist
         // entirely of short runs while still tokenizing like minified data.
-        // chars/2 on the dense payload chars (Claude Code JSON parity).
+        // chars/2 on the dense payload chars (dense-JSON pricing).
         denseAsciiFloor = Math.max(denseAsciiFloor, (nonWhitespace * 0.5) + ((s.length - nonWhitespace) * 0.25));
     }
     const asciiFloor = s.length / 4; // never below the legacy chars/4 lower bound
@@ -355,8 +354,8 @@ function messageEstimateText(m) {
 function imageDescriptorAllowance(descriptor) {
     if (descriptor.width && descriptor.height) {
         // Anthropic vision cost: tokens = (width * height) / 750, with images
-        // resized down to at most 2000x2000 (5333 tokens) — Claude Code uses
-        // the same formula/cap. Caller-supplied dimensions may RAISE the
+        // resized down to at most 2000x2000 (5333 tokens). Caller-supplied
+        // dimensions may RAISE the
         // allowance above the unknown-image floor but never lower it (the
         // provider normalizer may not preserve caller metadata).
         const formula = Math.ceil((descriptor.width * descriptor.height) / 750);
@@ -365,7 +364,7 @@ function imageDescriptorAllowance(descriptor) {
             Math.max(IMAGE_VISUAL_TOKEN_ALLOWANCE, formula),
         );
     }
-    // Unknown-size images: flat conservative allowance (Claude Code parity).
+    // Unknown-size images: flat conservative allowance.
     return IMAGE_VISUAL_TOKEN_ALLOWANCE;
 }
 function messageImageDescriptors(m) {

package/src/runtime/agent/orchestrator/session/eager-dispatch.mjs

@@ -100,6 +100,7 @@ export function createEagerDispatcher({
             if (_dedupEligible) _eagerInFlightSigs.set(_sig, call.id);
             entry.promise = (async () => {
                 try {
+                    await opts.beforeToolExecution?.();
                     return { ok: true, value: await executeToolFn(call.name, call.arguments, cwd, sessionId, sessionRef, { toolCallId: call.id, signal, notifyFn: opts.notifyFn, toolApprovalHook: opts.onToolApproval, iteration: getNextIteration(), deferShellCwdCommit: true }) };
                 } catch (error) {
                     return { ok: false, error };

package/src/runtime/agent/orchestrator/session/loop/compact-policy.mjs

@@ -112,8 +112,8 @@ export function resolveWorkerCompactPolicy(sessionRef, tools) {
     if (!boundaryTokens) return null;
     const compactBoundaryTokens = Math.max(1, Math.floor(boundaryTokens * COMPACT_SAFETY_PERCENT));
     // Shared session-compaction policy (context-utils): agent semantic keeps the
-    // default early-trigger buffer (90%); main/user use their independently
-    // configurable 25% default headroom (75%);
+    // default early-trigger buffer (90%); main/user default to full-window
+    // trigger (buffer 0 / 100%), still overridable via mainBuffer*;
     // a truly-explicit sub-boundary limit wins. explicitAutoCompactTokenLimit
     // is the sanitized (null when legacy full-window) value so telemetry never
     // re-persists a boundary-collapsing limit.
@@ -216,7 +216,7 @@ function providerPressureTokens(sessionRef, usage) {
 /**
  * Align an authoritative provider usage snapshot to the message prefix it
  * covers. Later pressure checks add estimates only for messages after this
- * baseline, matching Claude Code's actual-usage-plus-growth accounting.
+ * baseline: actual-usage-plus-growth accounting.
  */
 export function recordProviderContextBaseline(sessionRef, messages, usage, {
     boundary = 'complete',

package/src/runtime/agent/orchestrator/session/loop/completion-guards.mjs

@@ -38,20 +38,6 @@ export function isEditProgressTool(name, isEager) {
     return !NON_PROGRESS_TOOLS.has(bare);
 }
 
-// Step 1 — level-2 escalation steering. N = cumulative level-1 fires.
-// `readOnlyRole` swaps the edit-oriented directive for a report-oriented one:
-// read-permission sessions (reviewer-style) cannot apply_patch, so telling
-// them to edit is self-contradictory and pushes premature termination.
-const LEVEL2_DIMINISHING_RETURNS = ' Further reads add cost, not evidence.';
-
-export function level2SteerMessage(n, readOnlyRole = false, level2Fires = 1) {
-    const tail = Number(level2Fires) >= 2 ? LEVEL2_DIMINISHING_RETURNS : '';
-    if (readOnlyRole) {
-        return `<system-reminder>\nEnough evidence gathered — report findings now; name any gaps.${tail}\n</system-reminder>`;
-    }
-    return `<system-reminder>\nStop exploring — apply the edit you know, or report blocked with what's missing.${tail}\n</system-reminder>`;
-}
-
 // Step 2 — cross-turn dedup stub. `stuck` appends the escalation tail at the
 // 5th+ dedup stub in the session.
 export function crossTurnDedupStub(name, firstIteration, stuck) {

package/src/runtime/agent/orchestrator/session/loop/stop-hooks.mjs

@@ -1,11 +1,12 @@
-// Codex-style turn stop hook (refs/codex core/src/session/turn.rs:372-404).
+// Turn stop hook.
 //
-// Codex semantics: a sampling request that needs no follow-up ends the turn.
-// Before breaking, the turn runs its stop hooks; a hook may block ONCE by
-// returning continuation fragments, which are recorded as a prompt message
-// before sampling resumes (`stop_hook_active = true`, never cleared inside the
-// turn). Nothing else can force another turn: no mandatory terminal tool, no
-// completion strikes, no lexical inspection of the assistant text.
+// Termination semantics: a sampling request that needs no follow-up ends the
+// turn. Before breaking, the turn runs its stop hooks; a hook may block ONCE
+// by returning continuation fragments, which are recorded as a prompt message
+// before sampling resumes (the hook stays armed for the rest of the turn and
+// is never cleared inside it). Nothing else can force another turn: no
+// mandatory terminal tool, no completion strikes, no lexical inspection of
+// the assistant text.
 //
 // The single hook implemented here preserves the original failed-apply_patch
 // protection: while a real tool failure is unresolved, the first terminal
@@ -41,7 +42,7 @@ export function toolFailureContinuationPrompt(failedTool) {
  *    success clears it.
  *  - takeContinuationPrompt(): returns the continuation prompt the FIRST time
  *    a terminal assistant message arrives while a failure is unresolved, then
- *    stays silent for the rest of the turn (Codex `stop_hook_active`).
+ *    stays silent for the rest of the turn.
  */
 export function createToolFailureStopHook() {
     let unresolvedFailure = false;

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

@@ -672,11 +672,14 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     },
                     onToolResult: _trackToolResult,
                     onToolApproval: typeof askOpts?.onToolApproval === 'function' ? askOpts.onToolApproval : undefined,
+                    beforeToolExecution: typeof askOpts?.beforeToolExecution === 'function'
+                        ? askOpts.beforeToolExecution
+                        : undefined,
                     onCompactEvent: (event) => {
                         _scheduleTurnCheckpoint(true);
                         try { askOpts?.onCompactEvent?.(event); } catch {}
                     },
-                    // Claude Code parity: mid-chain queued prompt/notification
+                    // Mid-chain queued prompt/notification
                     // drain is owned by agentLoop at provider-continuation
                     // boundaries (after a tool batch, before the next send).
                     // The post-loop _pendingTail drain below still handles
@@ -692,9 +695,9 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                         // Manager/pending-messages entries carry no
                         // mode/priority/slash metadata, so they stay OUT of the
                         // mid-chain (post-tool-batch) drain — that would bypass
-                        // Claude Code's queued_command filters. At the TERMINAL
-                        // boundary they are exactly Codex `has_pending_input`
-                        // (turn.rs:304-318): an `agent type=send` queued while
+                        // the queued-command filters. At the TERMINAL boundary
+                        // they are exactly pending input: an `agent type=send`
+                        // queued while
                         // the terminal sample was in flight must be folded into
                         // THIS turn before any stop hook runs, instead of losing
                         // its slot to a synthetic continuation prompt. The mutex

package/src/runtime/agent/orchestrator/session/manager/context-meta.mjs

@@ -210,7 +210,7 @@ export function resolveSessionContextMeta(provider, model, seed = {}) {
 }
 export function compactTriggerForSession(session, boundaryTokens) {
     // Delegates to the shared session-compaction policy (context-utils):
-    // agent semantic -> 90% (default buffer), main/user -> 75% (default),
+    // agent semantic -> 90% (default buffer), main/user -> 100% (buffer 0),
     // truly-explicit sub-boundary limit wins.
     return resolveSessionCompactPolicy(session, boundaryTokens).triggerTokens;
 }

package/src/runtime/agent/orchestrator/session/manager/idle-cleanup.mjs

@@ -150,7 +150,7 @@ export function _runCleanupCycle() {
         // Drain every settled runtime entry on each pass, not just the one or two
         // sessions whose on-disk idle TTL happened to expire in this interval.
         _sweepTerminalSessionRuntimes();
-        sweepOrphanedPendingMessages();
+        await sweepOrphanedPendingMessages();
         await sweepIdleSessions({ includeTombstones: true });
         // Reclaim same-process session snapshots whose state is durable on disk
         // (memory-leak guard: _liveSessions used to grow for process lifetime).

package/src/runtime/agent/orchestrator/session/manager/pending-messages.mjs

@@ -4,7 +4,7 @@ import { join } from 'path';
 import { readFileSync, statSync } from 'fs';
 import { createHash, randomBytes } from 'crypto';
 import { resolvePluginData } from '../../../../shared/plugin-paths.mjs';
-import { updateJsonAtomicSync, updateJsonAtomic } from '../../../../shared/atomic-file.mjs';
+import { updateJsonAtomic } from '../../../../shared/atomic-file.mjs';
 import { promptContentText, isInternalRuntimeNotificationText } from './prompt-utils.mjs';
 import { loadSession, readSessionLifecycleStateFromDisk, saveSessionAsync } from '../store.mjs';
 import { isDeliveredCompletion, logDuplicateSkip } from './delivered-completions.mjs';
@@ -942,11 +942,11 @@ function shouldEvictPendingSession(sessionId, ttlMs, entryTouchedAt, now = Date.
     return entryTouch > 0 && (now - entryTouch) > PENDING_ORPHAN_GRACE_MS;
 }
 
-export function sweepOrphanedPendingMessages({ ttlMs = PENDING_ORPHAN_TTL_MS } = {}) {
+export async function sweepOrphanedPendingMessages({ ttlMs = PENDING_ORPHAN_TTL_MS } = {}) {
     const now = Date.now();
     const removed = [];
     try {
-        updateJsonAtomicSync(pendingMessagesPath(), (raw) => {
+        await updateJsonAtomic(pendingMessagesPath(), (raw) => {
             const next = normalizePendingStore(raw);
             const ids = Object.keys(next.sessions);
             if (ids.length === 0) return undefined;
@@ -988,9 +988,9 @@ function modelVisiblePendingMessages(messages) {
 }
 
 export function _mergePendingMessageEntries(entries) {
-    // CC-parity delivery priority (reference messageQueueManager.ts: user
-    // input enqueues at 'next', task notifications at 'later', and dequeue
-    // always serves 'next' first). Our single merged turn message is the
+    // Delivery priority: user input enqueues at 'next', task notifications at
+    // 'later', and dequeue always serves 'next' first. Our single merged turn
+    // message is the
     // analogue of that dequeue order: genuine user/steering entries are
     // merged BEFORE deferred completion notifications so queued user input
     // is never buried under system notification text. FIFO is preserved
@@ -1074,7 +1074,16 @@ export function enqueueRemotePendingMessage(sessionId, message) {
     // spool lock (see persistPendingMessages).
     runPendingTestHook('enqueue:beforePublish', { sessionId });
     if (pendingLifecycleInvalidated(sessionId, token)) return 0;
-    const remoteEntry = stampLifecycleToken({ ...normalized, id: newPendingMessageId() }, token);
+    // Preserve the viewer's submission id end-to-end. Minting a fresh id here
+    // made pipe-delivered + spool-fallback twins look like two messages
+    // (owner accepted the pipe copy, then re-took the spool copy).
+    const preservedId = pendingMessageId(normalized) || pendingMessageId(message);
+    const remoteEntry = stampLifecycleToken({
+        ...normalized,
+        id: (typeof preservedId === 'string' && preservedId.trim())
+            ? preservedId.trim()
+            : newPendingMessageId(),
+    }, token);
     return persistPendingMessages(sessionId, [remoteEntry]);
 }
 
@@ -1104,7 +1113,7 @@ function _rememberForeignSpoolScan(sessionId, mtime) {
  * internal-notification entries are left untouched for the normal
  * askSession hydrate path.
  */
-export function drainForeignUserInjections(sessionId) {
+export async function drainForeignUserInjections(sessionId) {
     if (!isValidPendingSessionId(sessionId)) return [];
     // DELIVERY path, not cleanup: this takes rows out of the spool and hands
     // them to a live turn. A tombstoned (or otherwise invalidated) session may
@@ -1147,7 +1156,13 @@ export function drainForeignUserInjections(sessionId) {
     // spool immediately pollable again.
     let lifecycleDecided = false;
     try {
-        updateJsonAtomicSync(pendingMessagesPath(), (raw) => {
+        // ASYNC spool lock. The sync variant parked the owning process's event
+        // loop in Atomics.wait for the whole timeout: in the daemon (PTYs,
+        // engines, IPC and SSE fan-out share one loop) every poll that lost the
+        // race froze the entire app, and it could never win against an async
+        // holder in the SAME process. Waiting off the loop also lets the
+        // in-process lock queue serialize sibling sessions for free.
+        await updateJsonAtomic(pendingMessagesPath(), (raw) => {
             // Same authority re-read INSIDE the spool lock: a close/detach
             // landing in this window must neither deliver to the old owner nor
             // remove the reopened owner's rows.
@@ -1172,8 +1187,10 @@ export function drainForeignUserInjections(sessionId) {
                 // late-delivery header instead of being silently removed
                 // (user report: remote sends silently discarded around owner
                 // restarts).
-                if (foreignUser && isStaleUserInjection(entry)) taken.push(lateDeliveryText(text, entry));
-                else if (foreignUser) taken.push(text);
+                if (foreignUser && isStaleUserInjection(entry)) {
+                    taken.push({ text: lateDeliveryText(text, entry), id });
+                }
+                else if (foreignUser) taken.push({ text, id });
                 else kept.push(entry);
             }
             if (taken.length === 0) return undefined;
@@ -1184,8 +1201,18 @@ export function drainForeignUserInjections(sessionId) {
             }
             next.updatedAt = Date.now();
             return next;
-        }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false });
+        }, {
+            compact: true,
+            lock: true,
+            mode: PENDING_MESSAGES_MODE,
+            fsync: false,
+            // Delivery polling must never wait on an async spool writer in the
+            // same daemon process: waiting synchronously prevents that writer
+            // from ever reaching its finally/release path.
+            timeoutMs: 0,
+        });
     } catch (err) {
+        if (err?.code === 'ELOCKCONTENDED') return [];
         try { process.stderr.write(`[session] foreign-injection drain failed sessionId=${sessionId}: ${err?.message || err}\n`); } catch {}
         return [];
     }
@@ -1422,5 +1449,5 @@ setImmediate(() => {
     // the cross-process lock against the lead's writes for zero
     // benefit — the lead already sweeps.
     if (process.env.MIXDOG_WORKER_MODE === '1') return;
-    try { sweepOrphanedPendingMessages(); } catch { /* ignore */ }
+    void sweepOrphanedPendingMessages().catch(() => {});
 });

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

@@ -12,6 +12,7 @@ import { _dropPendingMessageState } from './pending-messages.mjs';
 import { _stopToolActivityHeartbeat, _getRuntimeEntry, _clearSessionRuntime } from './runtime-liveness.mjs';
 import { _closeBashSessionLazy } from './runtime-loaders.mjs';
 import { clearTurnCheckpoint } from './turn-checkpoint.mjs';
+import { releaseReadSnapshotScope } from '../../tools/builtin/snapshot-store.mjs';
 
 /**
  * Close a session. Plants a `closed=true` tombstone on disk with a bumped
@@ -137,6 +138,7 @@ export function closeSession(id, reason = 'manual', opts = {}) {
     // Drop session-scoped read dedup cache so the Map doesn't accumulate
     // entries across mcp-server lifetime.
     try { clearReadDedupSession(id); } catch { /* ignore */ }
+    try { releaseReadSnapshotScope(id); } catch { /* ignore */ }
     // Drop offload sidecars + module-level counter for this session so a
     // long-running mcp-server doesn't leak disk (tool-results/<id>/*.txt)
     // or Map entries across session lifetime. Fire-and-forget — close path
@@ -226,6 +228,7 @@ export function unloadSessionRuntime(id, reason = 'runtime-unload') {
     try { globalThis.__mixdogCloseProviderConnectionsForSession?.(id, `runtime-unload:${reason}`); } catch { /* ignore */ }
     // Pure caches — a resumed turn rebuilds them from the transcript/disk.
     try { clearReadDedupSession(id); } catch { /* ignore */ }
+    try { releaseReadSnapshotScope(id); } catch { /* ignore */ }
     _clearSessionRuntime(id);
     if (process.env.MIXDOG_DEBUG_SESSION_LOG) {
         try { process.stderr.write(`[agent-unload] session=${id} reason=${reason} shells=${allBashIds.length}\n`); } catch { /* best-effort */ }

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

@@ -169,7 +169,14 @@ export function createSession(opts) {
     const provider = getProvider(providerName);
     if (!provider)
         throw new Error(`Provider "${providerName}" not found or not enabled`);
-    const id = mintSessionId();
+    const requestedId = String(opts.id || '').trim();
+    if (requestedId && !/^[A-Za-z0-9_-]+$/.test(requestedId)) {
+        throw new Error('createSession: id is invalid');
+    }
+    // The daemon may reserve the durable address before provider/session
+    // materialization. Supplying that reservation here keeps the address
+    // stable across intake -> queued turn -> provider execution.
+    const id = requestedId || mintSessionId();
     // Provider cache strategy — agentRuntime.resolveSync() above is a
     // best-effort injection point (setAgentRuntime() has no live caller
     // today, so that branch never fires); build it directly here so every

package/src/runtime/agent/orchestrator/session/manager/turn-interruption.mjs

@@ -7,10 +7,10 @@ import { filterModelVisibleSessionMessages } from './message-sanitize.mjs';
 
 const INTERRUPT_MESSAGE = '[Request interrupted by user]';
 const INTERRUPT_MESSAGE_FOR_TOOL_USE = '[Request interrupted by user for tool use]';
-const STREAMING_INTERRUPTED_TOOL_RESULT = 'Interrupted by user';
 const PROCESS_RESTART_INTERRUPT_MESSAGE = '[Request interrupted by process restart]';
-const PROCESS_RESTART_TOOL_RESULT = 'Interrupted by process restart';
-const TOOL_USE_REJECT_RESULT = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+// Short tool_result body for any unfinished call closed by
+// cancel/crash. UI maps this (and legacy long reject bodies) to Cancelled.
+const INTERRUPTED_TOOL_RESULT = 'Cancelled';
 
 // Abort reasons that represent an EXPLICIT user cancellation of this turn.
 // Only these rewind a not-yet-answered user turn out of history — the TUI/
@@ -136,11 +136,7 @@ function finalizeInterruptedTurn({
         const executionStarted = phase === 'tools' || observed?.eagerStarted === true;
         messages.push({
             role: 'tool',
-            content: abortReason === 'process-crash'
-                ? PROCESS_RESTART_TOOL_RESULT
-                : (executionStarted
-                    ? TOOL_USE_REJECT_RESULT
-                    : STREAMING_INTERRUPTED_TOOL_RESULT),
+            content: INTERRUPTED_TOOL_RESULT,
             toolCallId: callId,
             toolKind: 'error',
         });
@@ -148,7 +144,7 @@ function finalizeInterruptedTurn({
     }
 
     const pairedMessages = sanitizeToolPairs(messages);
-    // Claude Code omits the synthetic marker when a queued user submission
+    // The synthetic marker is omitted when a queued user submission
     // interrupted the active request; that queued message is the boundary.
     if (abortReason !== 'interrupt' && abortReason !== 'provider-error') {
         pairedMessages.push({

package/src/runtime/agent/orchestrator/session/send-with-recovery.mjs

@@ -36,7 +36,7 @@ function normalizedIncompleteUsage(raw) {
     };
 }
 
-// Loop-level transport replay (codex retry_transport parity). The provider
+// Loop-level transport replay. The provider
 // layer already retries transient failures with a ~15s total envelope
 // (PROVIDER_RETRY_BACKOFF_MS); a real network blip (router/VPN flap — the
 // 2026-08-02 17:37 incident also dropped the Discord gateway) outlasts it and
@@ -192,8 +192,8 @@ export async function sendWithRecovery(ctx) {
             // have been mid-sentence, and there is no completion signal that
             // says the work is done. Promoting it to a normal terminal response
             // silently reported truncated/aborted turns as finished. Keep it an
-            // explicit failure (like codex's no-completed stream handling and
-            // opencode's persisted partial-failure): the already-streamed text
+            // explicit failure (no completion signal means no completed turn,
+            // and the partial is persisted): the already-streamed text
             // is preserved by the interruption/error persistence path
             // (turn-interruption.mjs records the deltas and commits them as the
             // partial assistant message alongside the error), so nothing visible