mixdog 0.9.38 → 0.9.40

package/src/runtime/agent/orchestrator/tools/code-graph/disk-cache.mjs

@@ -5,7 +5,7 @@
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import {
-  readdirSync, readFileSync, statSync, existsSync, mkdirSync, renameSync, unlinkSync,
+  readdirSync, readFileSync, statSync, existsSync, mkdirSync, renameSync, unlinkSync, openSync, readSync, closeSync,
 } from 'node:fs';
 import { getPluginData } from '../../config.mjs';
 import { writeJsonAtomicSync } from '../../../../shared/atomic-file.mjs';
@@ -19,6 +19,7 @@ import {
   CODE_GRAPH_DISK_DIR,
   CODE_GRAPH_DISK_MAX_ENTRIES,
   CODE_GRAPH_DISK_MAX_BYTES,
+  CODE_GRAPH_FAST_PATH_MAX_BYTES,
   ORPHAN_TMP_MIN_AGE_MS,
   RE_CACHE_TMP,
   RE_MANIFEST_TMP,
@@ -83,6 +84,13 @@ function _migrateLegacyDiskCache() {
   }
 }
 
+// This intentionally does not call _loadDiskCodeGraphCache: the parent-side
+// fast path uses it to leave a legacy blob's synchronous read/JSON.parse to
+// the Worker, where normal one-shot migration still happens.
+export function hasLegacyDiskCodeGraphCache() {
+  return existsSync(join(getPluginData(), CODE_GRAPH_DISK_FILE));
+}
+
 function _pruneDiskCodeGraphEntries(_now = Date.now()) {
   for (const [cwd, entry] of _diskCodeGraphCache) {
     if (!entry || typeof entry !== 'object') {
@@ -278,7 +286,10 @@ function _ensureCwdLoaded(cwd) {
   } catch { /* skip corrupt per-cwd file */ }
 }
 
-function _persistDiskCodeGraphCacheNow() {
+export function _persistDiskCodeGraphCacheNow({
+  strict = false,
+  writeJson = writeJsonAtomicSync,
+} = {}) {
   try {
     _loadDiskCodeGraphCache();
     _pruneDiskCodeGraphEntries();
@@ -307,8 +318,15 @@ function _persistDiskCodeGraphCacheNow() {
       // rebuildable — a busy lock just skips this flush; _scheduleDiskCodeGraphCacheFlush
       // re-schedules on the next build. Exit drain still runs (unref'd timer
       // cancelled + direct call).
-      writeJsonAtomicSync(file, entry, { compact: true, lock: true, timeoutMs: 0 });
-      manifest[cwd] = { hash, builtAt: entry.builtAt || Date.now() };
+      writeJson(file, entry, { compact: true, lock: true, timeoutMs: 0 });
+      let bytes = null;
+      try { bytes = statSync(file).size; } catch { /* written entry may be unavailable */ }
+      manifest[cwd] = {
+        hash,
+        builtAt: entry.builtAt || Date.now(),
+        bytes: Number.isFinite(bytes) ? bytes : undefined,
+        maxFiles: Number.isFinite(entry.maxFiles) ? entry.maxFiles : undefined,
+      };
     }
     const pruned = _pruneCodeGraphManifestForBudget(manifest, dir);
     manifest = pruned.manifest;
@@ -320,7 +338,7 @@ function _persistDiskCodeGraphCacheNow() {
     }
 
     const manifestFile = join(dir, 'manifest.json');
-    writeJsonAtomicSync(manifestFile, manifest, { compact: true, lock: true, timeoutMs: 0 });
+    writeJson(manifestFile, manifest, { compact: true, lock: true, timeoutMs: 0 });
     _diskManifest = manifest;
 
     // Sweep orphan per-cwd files. validHashes now includes every hash in
@@ -329,6 +347,7 @@ function _persistDiskCodeGraphCacheNow() {
     _sweepCodeGraphCacheDir(dir, validHashes, { sweepJson: true });
   } catch (err) {
     process.stderr.write(`[code-graph] disk cache persist failed (target: ${_codeGraphDiskDir()}): ${err?.message || err}\n`);
+    if (strict) throw err;
   }
 }
 
@@ -355,6 +374,16 @@ function drainCodeGraphCacheNow() {
 }
 registerCodeGraphDrain(drainCodeGraphCacheNow);
 
+// Worker-only success fencing: unlike the exit/parent drain, a failed
+// persistence must reject the Worker result instead of being log-only.
+export function drainCodeGraphCacheStrict() {
+  if (_diskCodeGraphCacheFlushTimer) {
+    clearTimeout(_diskCodeGraphCacheFlushTimer);
+    _diskCodeGraphCacheFlushTimer = null;
+  }
+  _persistDiskCodeGraphCacheNow({ strict: true });
+}
+
 // Public: delegate to the state module's drain hook (which invokes the
 // registered drainCodeGraphCacheNow). Preserves the original facade behavior.
 export function drainCodeGraphCache() {
@@ -369,6 +398,40 @@ export function getDiskCodeGraphEntry(cwd) {
   return _diskCodeGraphCache.get(key);
 }
 
+// Inspect only manifest metadata (or a stat fallback), never parse the entry.
+// The main-thread fast path uses this to leave large/legacy entries to Worker
+// isolation while still allowing small compatible entries to avoid Worker boot.
+export function probeDiskCodeGraphEntry(cwd, maxBytes = CODE_GRAPH_FAST_PATH_MAX_BYTES) {
+  const key = _canonicalGraphCwd(cwd);
+  const meta = _diskManifest?.[key];
+  if (!meta || typeof meta !== 'object' || !_isCodeGraphCacheHash(meta.hash)) return null;
+  const file = join(_codeGraphDiskDir(), `${meta.hash}.json`);
+  let bytes = Number(meta.bytes);
+  if (!Number.isFinite(bytes) || bytes < 0) {
+    try { bytes = statSync(file).size; } catch { return null; }
+  }
+  let maxFiles = Number.isFinite(meta.maxFiles) ? meta.maxFiles : null;
+  // Legacy manifests have no per-entry metadata. Read only the compact JSON
+  // header (maxFiles precedes nodes) rather than parsing a potentially huge
+  // payload on the main thread.
+  if (maxFiles === null) {
+    let fd = null;
+    try {
+      fd = openSync(file, 'r');
+      const header = Buffer.allocUnsafe(4096);
+      const read = readSync(fd, header, 0, header.length, 0);
+      const match = /"maxFiles":(\d+)/.exec(header.toString('utf8', 0, read));
+      if (match) maxFiles = Number(match[1]);
+    } catch { /* leave legacy/corrupt metadata in the Worker path */ }
+    finally { if (fd !== null) try { closeSync(fd); } catch {} }
+  }
+  return {
+    bytes,
+    maxFiles,
+    isFastPathEligible: bytes <= maxBytes,
+  };
+}
+
 // Ensure the on-disk manifest/sweep boot pass has run (idempotent).
 export function ensureDiskCodeGraphLoaded(now = Date.now()) {
   _loadDiskCodeGraphCache(now);

package/src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs

@@ -103,8 +103,16 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
   // Name-only "symbols" calls (symbols[]/symbol without a file) are symbol
   // lookups, not a file outline — absorb into symbol_search instead of
   // erroring "file not found in graph: (missing file)".
-  if (mode === 'symbols' && !String(args?.file || '').trim()
-      && ((Array.isArray(args?.symbols) && args.symbols.length) || String(args?.symbol || '').trim())) {
+  if (mode === 'symbols'
+      && !String(args?.file || '').trim()
+      && !String(args?.files || '').trim()
+      && ((Array.isArray(args?.symbols) && args.symbols.length)
+        || (typeof args?.symbols === 'string' && args.symbols.trim())
+        || String(args?.symbol || '').trim())) {
+    if (!args.symbol && typeof args.symbols === 'string' && args.symbols.trim()) {
+      args = { ...args, symbol: args.symbols };
+      delete args.symbols;
+    }
     mode = 'symbol_search';
   }
 
@@ -523,8 +531,14 @@ export async function resolveSymbolReadSpan(cwd, { symbol, path = null, language
 export async function executeCodeGraphTool(name, args, cwd, signal = null, options = {}) {
   if (!cwd) throw new Error('find_symbol/code_graph requires cwd — caller did not provide a working directory');
   args = _normalizeGraphFileArgs(args);
-  const fileArg = (args && typeof args.file === 'string' && args.file.trim()) ? args.file.trim() : '';
   const baseCwd = (args && typeof args.cwd === 'string' && args.cwd.trim()) ? args.cwd.trim() : cwd;
+  const symbolMode = ['find_symbol', 'symbol_search', 'search', 'references', 'callers', 'callees', 'symbols'].includes(args?.mode);
+  if (symbolMode && typeof args?.file === 'string' && args.file.trim()
+      && pathResolve(baseCwd, args.file.trim()) === pathResolve(baseCwd)) {
+    args = { ...args };
+    delete args.file;
+  }
+  const fileArg = (args && typeof args.file === 'string' && args.file.trim()) ? args.file.trim() : '';
   let effectiveCwd = baseCwd;
   if (fileArg) {
     const abs = isAbsolute(fileArg) ? pathResolve(fileArg) : pathResolve(baseCwd, fileArg);

package/src/runtime/agent/orchestrator/tools/code-graph/graph-binary.mjs

@@ -33,7 +33,7 @@ function _graphBinaryPath() {
   try { return findCachedGraphBinary(getPluginData()); } catch { return null; }
 }
 
-async function _runGraphBinaryJsonl(absRoot, extraArgs, stdinLines = null) {
+async function _runGraphBinaryJsonl(absRoot, extraArgs, stdinLines = null, signal = null) {
   let binPath = _graphBinaryPath();
   if (!binPath) {
     // No local build or cached binary — fetch the prebuilt from the release
@@ -54,14 +54,10 @@ async function _runGraphBinaryJsonl(absRoot, extraArgs, stdinLines = null) {
 
   // Inner spawn + promise — extracted so we can retry once on EAGAIN.
   //
-  // child-spawn-gate is NOT acquired here. This function runs inside the
-  // code-graph prewarm WORKER THREAD (via _buildCodeGraph), and worker_threads
-  // do not share module-level state with the main thread — acquiring here would
-  // create a SECOND, independent semaphore that never coordinates with the
-  // main-thread rg gate. Instead the gate is held on the MAIN THREAD across the
-  // whole graph-build worker's lifetime (see buildCodeGraphAsync). The binary
-  // child is spawned exclusively from this worker path, so one main-side slot
-  // per worker correctly bounds native graph spawns against rg.
+  // child-spawn-gate is NOT acquired here. Worker builds and main-thread
+  // signature validation both hold their slot in buildCodeGraphAsync; worker
+  // threads do not share module-level state with the main thread, so acquiring
+  // here would create an independent semaphore that cannot coordinate with rg.
   const _spawnOnce = () => new Promise((resolve, reject) => {
     // When stdinLines is supplied (--files mode), stream one JSON object per
     // line to the child's STDIN — the reused nodes' metadata — so Rust can
@@ -79,6 +75,7 @@ async function _runGraphBinaryJsonl(absRoot, extraArgs, stdinLines = null) {
     const STDERR_CAP = 8 * 1024;
     let settled = false;
     let timedOut = false;
+    let aborted = false;
 
     // ── timeout + kill helpers (mirrors rg-runner's _killRgProc/_escalateRgKill) ──
     let timeoutTimer = null;
@@ -130,7 +127,12 @@ async function _runGraphBinaryJsonl(absRoot, extraArgs, stdinLines = null) {
         clearTimeout(forceSettleTimer);
         forceSettleTimer = null;
       }
+      if (onAbort && signal) {
+        try { signal.removeEventListener('abort', onAbort); } catch { /* ignore */ }
+        onAbort = null;
+      }
     };
+    let onAbort = null;
 
     // Arm timeout — unref so it doesn't keep the process alive. On timeout we
     // start SIGTERM→grace→force-kill but do NOT settle yet: the promise stays
@@ -157,6 +159,14 @@ async function _runGraphBinaryJsonl(absRoot, extraArgs, stdinLines = null) {
       if (forceSettleTimer.unref) forceSettleTimer.unref();
     }, timeoutMs);
     if (timeoutTimer.unref) timeoutTimer.unref();
+    if (signal) {
+      onAbort = () => {
+        aborted = true;
+        _killProc();
+      };
+      if (signal.aborted) onAbort();
+      else signal.addEventListener('abort', onAbort, { once: true });
+    }
 
     proc.stdout.on('data', (c) => chunks.push(c));
     proc.stderr.on('data', (c) => {
@@ -186,6 +196,10 @@ async function _runGraphBinaryJsonl(absRoot, extraArgs, stdinLines = null) {
         reject(new Error(`[code-graph] mixdog-graph timed out after ${timeoutMs}ms`));
         return;
       }
+      if (aborted) {
+        reject(new Error('aborted'));
+        return;
+      }
       if (code !== 0) {
         reject(new Error(`[code-graph] mixdog-graph exited ${code}: ${stderrText.trim().slice(0, 200)}`));
         return;
@@ -215,7 +229,7 @@ async function _runGraphBinaryJsonl(absRoot, extraArgs, stdinLines = null) {
     throw err;
   }
 }
-export function _runGraphManifest(absRoot) { return _runGraphBinaryJsonl(absRoot, ['--manifest']); }
+export function _runGraphManifest(absRoot, signal = null) { return _runGraphBinaryJsonl(absRoot, ['--manifest'], null, signal); }
 export function _runGraphWalk(absRoot) { return _runGraphBinaryJsonl(absRoot, []); }
 // --files (design A: full-graph resolution) full-parses only `rels` (argv) but
 // resolves imports across the WHOLE tree. The reused nodes' metas are streamed

package/src/runtime/agent/orchestrator/tools/code-graph-prewarm-worker.mjs

@@ -12,7 +12,7 @@
 //  - On any failure: postMessage({ ok: false }). Main thread propagates
 //    an error — find_symbol / code_graph tools throw. No sync fallback.
 import { parentPort, workerData } from 'node:worker_threads';
-import { _buildCodeGraph } from './code-graph.mjs';
+import { _buildCodeGraph, _postCodeGraphWorkerSuccess } from './code-graph.mjs';
 
 const cwd = workerData && workerData.cwd ? workerData.cwd : null;
 
@@ -27,9 +27,12 @@ try {
   if (!cwd) {
     parentPort.postMessage({ ok: false });
   } else {
-    const graph = await _buildCodeGraph(cwd);
+    const graph = await _buildCodeGraph(cwd, {
+      manifest: Array.isArray(workerData.manifest) ? workerData.manifest : null,
+      signature: typeof workerData.signature === 'string' ? workerData.signature : null,
+    });
     if (graph && typeof graph.signature === 'string') {
-      parentPort.postMessage({ ok: true, signature: graph.signature, graph });
+      _postCodeGraphWorkerSuccess(graph, (message) => parentPort.postMessage(message));
     } else {
       parentPort.postMessage({ ok: false });
     }

package/src/runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs

@@ -3,17 +3,14 @@ export const CODE_GRAPH_TOOL_DEFS = [
     name: 'code_graph',
     title: 'Code Graph',
     annotations: { title: 'Code Graph', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: false, compressibleLossless: true },
-    description: 'Repo-local code structure/flow lookup (not web): symbols/references/calls/deps. Symbols by name need no pre-verification; files[] must be verified paths. Batch symbols[]/files[].',
+    description: 'Repo-local code structure/flow (not web): symbols/references/calls/deps Public files[] must be verified paths; verified source files only. IDs→graph; literal/zero→grep. Exact identifiers: find_symbol/references/callers/callees; keywords: symbol_search/search Unsupported target arrays omitted, never silently mixed. Legacy file/symbol/language compatible, hidden. Batch symbols[]/files[] by mode',
     inputSchema: {
       type: 'object',
       properties: {
-        mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers'], description: 'Repo-local graph operation.' },
-        files: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Verified source file(s); array fans out per file. `file` alias too.' },
-        symbols: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Identifier(s)/keyword(s); array batches in one call. `symbol` alias too. Required for callers/callees/references/find_symbol/symbol_search.' },
-        symbol: { type: 'string', description: 'Singular alias for symbols.' },
-        file: { type: 'string', description: 'Singular alias for files.' },
+        mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers', 'callees'], description: 'Repo-local: file modes={overview,imports,dependents,related,impact}; symbols with files→files[] file outline; symbol modes={find_symbol,symbol_search,search,references,callers,callees}; fileless symbols→symbol_search keywords.' },
+        files: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Verified source files; supported targets only.' },
+        symbols: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Exact identifiers: find_symbol/references/callers/callees; keywords: symbol_search/search; multiple exact symbols use one symbols[] call; one call.' },
         body: { type: 'boolean', description: 'Include body.' },
-        language: { type: 'string', description: 'Language hint.' },
         limit: { type: 'number', minimum: 1, description: 'Max results.' },
         depth: { type: 'number', minimum: 1, maximum: 5, description: 'Caller depth.' },
         page: { type: 'number', minimum: 1, description: 'Caller page.' },

package/src/runtime/agent/orchestrator/tools/code-graph.mjs

@@ -31,6 +31,7 @@ export {
   prewarmCodeGraphIfProject,
   buildCodeGraphAsync,
   _buildCodeGraph,
+  _postCodeGraphWorkerSuccess,
 } from './code-graph/build.mjs';
 export {
   resolveSymbolReadSpan,

package/src/runtime/agent/orchestrator/tools/patch-tool-defs.mjs

@@ -26,7 +26,7 @@ export const PATCH_TOOL_DEFS = [
     name: 'apply_patch',
     title: 'Mixdog Apply Patch',
     annotations: { title: 'Mixdog Apply Patch', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false, compressible: false, compressibleLossless: true },
-    description: 'Apply file patches. Put known edits in one patch, not multiple turns; sections run in listed order.',
+    description: 'Apply known file edits in one patch; sections run in listed order. Do not split a dependent edit across turns.',
     freeformDescription: APPLY_PATCH_FREEFORM_DESCRIPTION,
     freeform: {
       type: 'grammar',

package/src/runtime/memory/lib/memory-cycle2-gate.mjs

@@ -496,10 +496,10 @@ export async function sonnetCascade(candidates, rulesDigest, options = {}) {
     `NO prose, NO preamble, NO meta-commentary. First character must be a digit.`,
   ].join('\n')
 
-  // Hardcoded — resolveMaintenancePreset falls back to first preset (HAIKU)
-  // when no binding exists, which would defeat the cascade. SONNET HIGH
-  // matches the worker pool's default preset id from agent-config.
-  const preset = options.cascadePreset || 'SONNET HIGH'
+  // Keep the cascade on the same maintenance route as every other memory
+  // cycle call. An explicit override remains available for focused tests and
+  // controlled callers.
+  const preset = options.cascadePreset || resolveMaintenancePreset('memory')
   const llmCall = typeof options?.callLlm === 'function' ? options.callLlm : callAgentDispatch
   let raw
   try {

package/src/runtime/memory/lib/memory-cycle2-mutations.mjs

@@ -2,6 +2,7 @@
 // DB status/update/merge writers plus the cosine-similarity dedup pass.
 // Facade (memory-cycle2.mjs) re-exports the public members unchanged.
 import { deleteRootEmbedding, syncRootEmbedding } from './memory-embed.mjs'
+import { resolveMaintenancePreset } from '../../shared/llm/index.mjs'
 import { callAgentDispatch } from './agent-ipc.mjs'
 import { __mixdogMemoryLog, throwIfAborted } from './memory-cycle2-shared.mjs'
 
@@ -318,7 +319,7 @@ async function _llmJudgePair(summaryA, summaryB, siblingContext = [], options =
       agent: 'cycle2-agent',
       taskType: 'maintenance',
       mode: 'cycle2-phase_merge_judge',
-      preset: 'HAIKU',
+      preset: options.preset || resolveMaintenancePreset('memory'),
       timeout: 30000,
       cwd: null,
     }, prompt)
@@ -413,7 +414,7 @@ export async function runPhaseMerge(db, options = {}) {
       // callAgentDispatch (IPC), which is unavailable in the standalone
       // memory service and failed every judge call with
       // `agent-ipc: IPC channel unavailable`.
-      { signal, callLlm: options?.callLlm },
+      { signal, preset: options?.preset, callLlm: options?.callLlm },
     )
     throwIfAborted(signal)
     if (shouldMerge) await doMerge(pair.a, pair.b, pair.sim)
@@ -459,7 +460,7 @@ export async function runPhaseMerge(db, options = {}) {
       String(row.entry_summary ?? ''),
       String(row.core_summary ?? ''),
       [],
-      { signal, callLlm: options?.callLlm },
+      { signal, preset: options?.preset, callLlm: options?.callLlm },
     )
     throwIfAborted(signal)
     if (!verdictMerge) continue

package/src/runtime/memory/lib/memory-cycle3.mjs

@@ -51,6 +51,17 @@ async function invokeLlm(prompt, mode, preset, timeout, llmCall = callAgentDispa
   }, prompt)
 }
 
+export async function invokeCycle3Maintenance(prompt, options = {}) {
+  const preset = options.preset || resolveMaintenancePreset('memory')
+  return await invokeLlm(
+    prompt,
+    'cycle3-review',
+    preset,
+    Number(options.timeout ?? 600000),
+    options.callLlm,
+  )
+}
+
 function throwIfAborted(signal) {
   if (signal?.aborted) throw signal.reason ?? new Error('aborted')
 }
@@ -507,7 +518,6 @@ async function _runCycle3Impl(db, config, dataDir, options = {}) {
     .replace('{{CORE_REVIEW}}', coreReview)
     .replace('{{CURRENT_RULES}}', rulesDigest)
 
-  const preset = resolveMaintenancePreset('memory')
   const timeout = Number(config?.cycle3?.timeout ?? 600000)
   const mode = 'cycle3-review'
 
@@ -516,7 +526,7 @@ async function _runCycle3Impl(db, config, dataDir, options = {}) {
   let raw
   try {
     throwIfAborted(signal)
-    raw = await invokeLlm(prompt, mode, preset, timeout, options.callLlm)
+    raw = await invokeCycle3Maintenance(prompt, { ...options, timeout, mode })
   } catch (err) {
     if (signal?.aborted) throw signal.reason ?? err
     __mixdogMemoryLog(`[cycle3] LLM error: ${err.message}\n`)

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/runtime/shared/tool-primitives.mjs

@@ -250,10 +250,13 @@ export function bridgeAgentModelSummary(args) {
 }
 
 export function summarizeLineWindow(a) {
+  const hasOffset = a.offset != null;
   const offset = a.offset ?? a.start_line ?? a.startLine ?? a.line;
   const limit = a.limit ?? a.line_count ?? a.lineCount ?? a.lines;
   if (offset == null && limit == null) return '';
-  const start = Number(offset);
+  // `read` uses a zero-based offset, while legacy start_line/line inputs are
+  // already one-based. Surface the human line number, never a raw array index.
+  const start = Number(offset) + (hasOffset ? 1 : 0);
   const count = Number(limit);
   if (Number.isFinite(start) && Number.isFinite(count) && count > 0) {
     return `lines ${start}-${Math.max(start, start + count - 1)}`;

package/src/runtime/shared/tool-status.mjs

@@ -0,0 +1,27 @@
+/**
+ * Shared terminal-status parsing for tool result surfaces.
+ *
+ * A terminal result status describes the tool's reported outcome; it is not
+ * evidence that the tool invocation itself failed. Call-failure accounting is
+ * owned by the TUI engine's isError/toolKind envelope fields.
+ */
+export function normalizeToolTerminalStatus(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  if (!raw) return '';
+  if (/^(running|pending|queued|in_progress|in-progress)$/.test(raw)) return 'running';
+  if (/^(completed|complete|done|success|succeeded|ok)$/.test(raw)) return 'completed';
+  if (/^(failed|fail|error|errored|timeout|timed_out|killed)$/.test(raw)) return 'failed';
+  if (/^(cancelled|canceled|cancel)$/.test(raw)) return 'cancelled';
+  if (/^(denied|deny|refused|rejected)$/.test(raw)) return 'denied';
+  return '';
+}
+
+export function toolResultTerminalStatus(text) {
+  const body = String(text || '');
+  const tagged = body.match(/<status[^>]*>([\s\S]*?)<\/status>/i)?.[1]?.trim();
+  if (tagged) return normalizeToolTerminalStatus(tagged);
+  const bracketed = body.match(/^\[status:\s*([^\]]*)\]/mi)?.[1]?.trim();
+  if (bracketed) return normalizeToolTerminalStatus(bracketed);
+  const inline = body.match(/^(?:status|state):\s*([^\s·,;]+)/mi)?.[1]?.trim();
+  return normalizeToolTerminalStatus(inline);
+}

package/src/runtime/shared/tool-surface.mjs

@@ -452,7 +452,10 @@ export function toolWorkUnit(name, args = {}, category = '') {
     case 'read_mcp_resource':
       return unitDescriptor('Read', { count: queryCount(a, 'uri', 'uris') || 1, noun: 'resource' });
     case 'apply_patch': {
-      const creating = a.old_string === '';
+      const patchText = String(a.patch ?? '');
+      const creating = a.old_string === '' || /^\*\*\*\s+Add File:/mi.test(patchText);
+      const deleting = (!creating && a.new_string === '' && a.old_string != null)
+        || /^\*\*\*\s+Delete File:/mi.test(patchText);
       // A dry_run patch validates the diff WITHOUT writing any file, so the
       // header must not claim "Editing/Edited" (which made a pure validation
       // look like a real edit). Surface it as "Checking/Checked" instead.
@@ -466,8 +469,8 @@ export function toolWorkUnit(name, args = {}, category = '') {
       }
       return unitDescriptor('Patch', {
         count: patchFileCount(a) || 1,
-        active: creating ? 'Creating' : 'Editing',
-        done: creating ? 'Created' : 'Edited',
+        active: creating ? 'Creating' : deleting ? 'Deleting' : 'Editing',
+        done: creating ? 'Created' : deleting ? 'Deleted' : 'Edited',
         noun: 'file',
       });
     }

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

@@ -175,6 +175,20 @@ export function autoClearProviderDefaults(providerIdleMs = null) {
   });
 }
 
+// Agent terminal retention is deliberately narrower than Auto Clear's general
+// 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();
+  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];
+}
+
 // Resolve the effective auto-clear idle window for a config + provider:
 // an explicit user-set idleMs (config.autoClear.idleMs) always wins; else
 // fall back to the provider's default; else the global 1h default.

package/src/session-runtime/context-status.mjs

@@ -100,6 +100,7 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
     const lastContextTokens = Number(session?.lastContextTokens || 0);
     const estimatedContextTokens = estimateTranscriptContextUsage(messages, tools, {
       messageCount: messageSummary.count,
+      estimatedMessageTokens: messageSummary.estimatedTokens,
     });
     const compactAt = Number(session?.compaction?.lastChangedAt || session?.compaction?.lastCompactAt || 0);
     const usageAt = Number(session?.lastContextTokensUpdatedAt || 0);

package/src/session-runtime/effort.mjs

@@ -2,7 +2,7 @@
 import { clean } from './session-text.mjs';
 
 export const TOOL_MODES = new Set(['full', 'readonly', 'lead']);
-export const ALL_EFFORT_LEVELS = new Set(['none', 'low', 'medium', 'high', 'xhigh', 'max']);
+export const ALL_EFFORT_LEVELS = new Set(['none', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
 export const EFFORT_LABELS = {
   none: 'None',
   low: 'Low',
@@ -10,11 +10,14 @@ export const EFFORT_LABELS = {
   high: 'High',
   xhigh: 'Extra High',
   max: 'Max',
+  ultra: 'Ultra',
 };
 
 export const EFFORT_OPTIONS_BY_PROVIDER = {
   openai: ['none', 'low', 'medium', 'high', 'xhigh'],
-  'openai-oauth': ['none', 'low', 'medium', 'high', 'xhigh'],
+  // gpt-5.6+ catalogs declare max/ultra; the openai-oauth transport folds
+  // ultra -> max on the wire (openai-oauth.mjs _normalizeReasoningEffort).
+  'openai-oauth': ['none', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'],
   anthropic: ['low', 'medium', 'high', 'xhigh', 'max'],
   'anthropic-oauth': ['low', 'medium', 'high', 'xhigh', 'max'],
   xai: ['none', 'low', 'medium', 'high'],
@@ -36,6 +39,7 @@ export const EFFORT_BY_FAMILY = {
   grok: ['none', 'low', 'medium', 'high'],
 };
 export const EFFORT_FALLBACKS = {
+  ultra: ['ultra', 'max', 'xhigh', 'high', 'medium', 'low'],
   max: ['max', 'xhigh', 'high', 'medium', 'low'],
   xhigh: ['xhigh', 'high', 'medium', 'low'],
   high: ['high', 'medium', 'low'],

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/model-recency.mjs

@@ -56,10 +56,13 @@ export function compareProviderModelRecency(a, b) {
   }
   const ta = providerModelReleaseTime(a);
   const tb = providerModelReleaseTime(b);
-  if (ta !== tb) return tb - ta;
-  if (a.latest !== b.latest) return a.latest ? -1 : 1;
   const versionDelta = compareProviderModelVersion(a, b);
+  // Release dates win only when both sides have one; sparse OAuth catalogs
+  // must not sink undated (often newest) models below dated/latest ones.
+  if (ta > 0 && tb > 0 && ta !== tb) return tb - ta;
   if (versionDelta) return versionDelta;
+  if (a.latest !== b.latest) return a.latest ? -1 : 1;
+  if (ta !== tb) return tb - ta;
   return clean(a.display || a.id).localeCompare(clean(b.display || b.id));
 }