mixdog 0.8.0 → 0.8.1

package/src/runtime/agent/orchestrator/session/loop.mjs

@@ -38,13 +38,9 @@ function _stripMcpPrefix(name) {
 function _isReadTool(name) {
     return _stripMcpPrefix(name) === 'read';
 }
-function _isScalarWriteEditTool(name) {
-    const n = _stripMcpPrefix(name);
-    return n === 'write' || n === 'edit';
-}
 function _isMutationTool(name) {
     const n = _stripMcpPrefix(name);
-    return n === 'apply_patch' || n === 'write' || n === 'edit';
+    return n === 'apply_patch';
 }
 const SCOPED_CACHEABLE_TOOLS = new Set([
     'code_graph',
@@ -375,8 +371,6 @@ function _ensureTranscriptPairing(msgs, sessionId) {
 // is the fail-safe reject at call time.
 const READ_BLOCKED_TOOLS = new Set([
     'shell', 'bash_session',
-    'write',
-    'edit',
     'apply_patch',
 ]);
 const MCP_ONLY_ALLOWED_KINDS = new Set(['mcp', 'internal', 'skill']);
@@ -1848,9 +1842,9 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         //
         // Intra-turn duplicate suppression: when an LLM emits two tool_use
         // blocks with identical (name, args) inside the SAME assistant turn,
-        // re-executing wastes tokens. Restricted to tools with
-        // `readOnlyHint:true` (= isEagerDispatchable) — bash/write/edit/
-        // apply_patch may be intentional repeats with distinct side effects.
+                // re-executing wastes tokens. Restricted to tools with
+                // `readOnlyHint:true` (= isEagerDispatchable) — bash/apply_patch
+                // may be intentional repeats with distinct side effects.
         // Pre-pass identifies duplicates BEFORE startEagerRun so eager
         // dispatch also skips them, not just the for-body.
         const _duplicateCallIds = new Set();
@@ -2038,11 +2032,11 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                 }
             }
             // A failed executed call keeps its FULL argument body in history so the
-            // model can retry against the original (a large apply_patch `patch` /
-            // edit `old_string` would otherwise be hidden behind a
+            // model can retry against the original (a large apply_patch `patch`
+            // would otherwise be hidden behind a
             // `[mixdog compacted …]` placeholder). Restored IMMEDIATELY — not at end
             // of loop — so an abort or post-processing throw after this point cannot
-            // leave a failed edit compacted. Cache-safe: _assistantTurnMsg is not
+            // leave a failed patch compacted. Cache-safe: _assistantTurnMsg is not
             // transmitted until the next provider.send. Early-continue paths (dedup /
             // repeat-failure-guard) never reach here and stay compacted.
             if ((!_executeOk || _resultKind === 'error') && call?.id) {
@@ -2059,10 +2053,10 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             if (sessionId && _executeOk && _resultKind === 'normal') {
                 const _toolBare = _stripMcpPrefix(call.name);
                 if (_readCacheHit === null && _isReadTool(call.name)) {
-                    // Post-edit advisory: handle BOTH scalar and array forms
+                    // Post-patch advisory: handle BOTH scalar and array forms
                     // of args.path. The array form (path:[a,b,c] or
                     // path:[{path:a},{path:b}]) was a coverage gap in R1 —
-                    // an LLM that edits X then reads [X,Y] should still see
+                    // an LLM that patches X then reads [X,Y] should still see
                     // the advisory for X.
                     const _argsPath = call.arguments?.path;
                     const _pathList = [];
@@ -2116,59 +2110,14 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                     } else {
                         clearScopedToolsForSession(sessionId);
                     }
-                } else if (_isScalarWriteEditTool(call.name)) {
-                    // Scalar `args.path` only: precise invalidate + advisory mark.
-                    // Array-form (`edits[]`/`writes[]`): the tool may have partial-
-                    // failed across paths and the result string aggregates;
-                    // full-clear instead of falsely marking every path.
-                    const _scalarPath = call.arguments?.path || call.arguments?.file_path;
-                    const _hasArrayForm = Array.isArray(call.arguments?.edits)
-                        || Array.isArray(call.arguments?.writes);
-                    if (_hasArrayForm) {
-                        clearReadDedupSession(sessionId);
-                        clearScopedToolsForSession(sessionId);
-                        // R20: array-form — walk each entry, extract its path,
-                        // and invalidate the prefetch cache + mark post-edit for
-                        // every distinct touched path. Falls back to the top-
-                        // level `path` (or `file_path`) when an entry omits its
-                        // own path. This covers both edit edits[] and write
-                        // writes[] forms; entries without a resolvable path are
-                        // silently skipped (their stat-validation safety net at
-                        // next lookup still applies).
-                        const _topPath = call.arguments?.path || call.arguments?.file_path;
-                        const _entries = call.arguments?.edits || call.arguments?.writes || [];
-                        const _seenPaths = new Set();
-                        for (const _e of _entries) {
-                            const _ep = _e?.path || _e?.file_path || _topPath;
-                            if (typeof _ep === 'string' && _ep && !_seenPaths.has(_ep)) {
-                                _seenPaths.add(_ep);
-                                invalidatePathForSession(sessionId, _ep, cwd);
-                                markPostEdit({ sessionId, path: _ep, cwd, toolName: _toolBare });
-                                invalidatePrefetchCache(_ep, cwd);
-                            }
-                        }
-                        if (_seenPaths.size > 0) {
-                            clearScopedToolsForSessionPaths(sessionId, [..._seenPaths], cwd);
-                        }
-                    } else if (typeof _scalarPath === 'string') {
-                        invalidatePathForSession(sessionId, _scalarPath, cwd);
-                        markPostEdit({ sessionId, path: _scalarPath, cwd, toolName: _toolBare });
-                        // R20: cross-dispatch prefetch cache invalidation.
-                        invalidatePrefetchCache(_scalarPath, cwd);
-                        // Targeted scoped-cache invalidation for the single touched path (D).
-                        clearScopedToolsForSessionPaths(sessionId, [_scalarPath], cwd);
-                    } else {
-                        // No path extractable — full wipe fallback.
-                        clearScopedToolsForSession(sessionId);
-                    }
                 }
             } // end _executeOk+_resultKind gate (scoped tool cache set)
-            // E: mutation tools (apply_patch / write / edit) must invalidate caches
+            // E: mutation tools (apply_patch) must invalidate caches
             // even on returned-error/partial-fail — the file state is unknown after
             // an error exit, and some tools report failure as an Error: result string
             // rather than throwing.
             // This block runs unconditionally (not gated on _executeOk or _resultKind).
-            if (sessionId && (!_executeOk || _resultKind === 'error') && (_stripMcpPrefix(call.name) === 'apply_patch' || _isScalarWriteEditTool(call.name))) {
+            if (sessionId && (!_executeOk || _resultKind === 'error') && _stripMcpPrefix(call.name) === 'apply_patch') {
                 clearReadDedupSession(sessionId);
             }
             if (_isMutationTool(call.name)) {

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

@@ -23,7 +23,7 @@ import { CODE_GRAPH_TOOL_DEFS } from '../tools/code-graph-tool-defs.mjs';
 import { executeCodeGraphTool } from '../tools/code-graph.mjs';
 import { closeBashSession } from '../tools/bash-session.mjs';
 import { collectSkillsCached, buildSkillToolDefs, loadAgentTemplate, loadRoleTemplate, composeSystemPrompt, collectMixdogMd } from '../context/collect.mjs';
-import { saveSession, saveSessionAsync, loadSession, listStoredSessions, sweepStaleSessions, markSessionClosed, publishHeartbeat, deleteHeartbeat, setLiveSession } from './store.mjs';
+import { saveSession, saveSessionAsync, loadSession, listStoredSessionSummaries, sweepStaleSessions, markSessionClosed, publishHeartbeat, deleteHeartbeat, setLiveSession } from './store.mjs';
 import { clearReadDedupSession, tryPrefetchCached, setPrefetchCached } from './read-dedup.mjs';
 import { clearOffloadSession } from './tool-result-offload.mjs';
 import { classifyResultKind } from './result-classification.mjs';
@@ -251,7 +251,6 @@ const SESSION_ROUTE_TOOL_ORDER = [
     'task',
 ];
 const SESSION_ROUTE_TOOL_RANK = new Map(SESSION_ROUTE_TOOL_ORDER.map((name, index) => [name, index]));
-const MODEL_HIDDEN_FILE_MUTATION_TOOLS = new Set(['edit', 'write']);
 const FILESYSTEM_TOOL_NAMES = new Set([
     'code_graph',
     'glob',
@@ -280,7 +279,7 @@ function orderSessionTools(tools) {
 }
 
 const ALL_BUILTIN_SESSION_TOOLS = orderSessionTools(_dedupByName([
-    ...BUILTIN_TOOLS.filter(t => !MODEL_HIDDEN_FILE_MUTATION_TOOLS.has(t?.name)),
+    ...BUILTIN_TOOLS,
     ...PATCH_TOOL_DEFS,
     ...CODE_GRAPH_TOOL_DEFS,
 ]));
@@ -732,6 +731,7 @@ async function runSessionCompaction(session, opts = {}) {
     const changed = beforeEncoded && afterEncoded
         ? beforeEncoded !== afterEncoded
         : (compacted.length !== messages.length || afterMessageTokens !== beforeMessageTokens);
+    const unchangedReason = changed ? null : (force ? 'nothing to compact' : 'below threshold');
     const now = Date.now();
     session.messages = compacted;
     session.providerState = undefined;
@@ -766,6 +766,7 @@ async function runSessionCompaction(session, opts = {}) {
     if (changed && mode === 'auto') session.lastContextTokensStaleAfterCompact = true;
     return {
         changed,
+        reason: unchangedReason,
         beforeMessages: messages.length,
         afterMessages: compacted.length,
         beforeTokens,
@@ -2572,12 +2573,13 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
 // scope session when the caller passes --scope (agent/<name>).
 export function findSessionByScopeKey(scopeKey) {
     if (!scopeKey) return null;
-    const sessions = listStoredSessions();
+    const summaries = listStoredSessionSummaries();
     // Exclude tombstoned sessions (`closed === true`) so callers never receive
     // a session whose controller was aborted by closeSession(). The `closed`
     // bit is the authoritative tombstone flag; `status === 'error'` is not,
     // since transient-error sessions remain resumable.
-    return sessions.find(s => s.scopeKey === scopeKey && s.closed !== true) || null;
+    const summary = summaries.find(s => s.scopeKey === scopeKey && s.closed !== true) || null;
+    return summary?.id ? loadSession(summary.id) : null;
 }
 // --- resume (reload tools for a stored session) ---
 export async function resumeSession(sessionId, preset) {
@@ -2617,7 +2619,7 @@ export function getSession(id) {
 }
 export function listSessions(opts = {}) {
     const includeClosed = opts.includeClosed === true;
-    const sessions = listStoredSessions();
+    const sessions = listStoredSessionSummaries();
     const hiddenIds = new Set([..._runtimeState.entries()].filter(([, e]) => e.listHidden).map(([id]) => id));
     // Tombstoned sessions (closed===true) are excluded unless the caller opts in
     // (e.g. bridge list includeClosed:true).
@@ -2818,7 +2820,7 @@ export function abortSessionTurn(id, reason = 'turn-abort') {
 
 // --- Periodic idle session cleanup ---
 const CLEANUP_INTERVAL_MS = nonNegativeIntEnv('MIXDOG_SESSION_CLEANUP_INTERVAL_MS', 5 * 60 * 1000); // check every 5 minutes
-const CLEANUP_INITIAL_DELAY_MS = nonNegativeIntEnv('MIXDOG_SESSION_CLEANUP_INITIAL_DELAY_MS', 60 * 1000);
+const CLEANUP_INITIAL_DELAY_MS = nonNegativeIntEnv('MIXDOG_SESSION_CLEANUP_INITIAL_DELAY_MS', CLEANUP_INTERVAL_MS > 0 ? CLEANUP_INTERVAL_MS : 0);
 const CLEANUP_SLOW_LOG_MS = nonNegativeIntEnv('MIXDOG_SESSION_CLEANUP_SLOW_LOG_MS', 250);
 const TOMBSTONE_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24h — far longer than any realistic ask race window
 let _cleanupTimer = null;
@@ -2922,7 +2924,17 @@ export function sweepTombstones() {
     }
 }
 
+function hasActiveRuntimeWork() {
+    for (const [, entry] of _runtimeState) {
+        if (!entry || entry.closed === true) continue;
+        if (entry.controller && !entry.controller.signal?.aborted) return true;
+        if (['connecting', 'requesting', 'streaming', 'tool_running', 'cancelling'].includes(entry.stage)) return true;
+    }
+    return false;
+}
+
 function _runCleanupCycle() {
+    if (hasActiveRuntimeWork()) return;
     sweepIdleSessions({ includeTombstones: true });
 }
 

package/src/runtime/agent/orchestrator/session/store.mjs

@@ -9,9 +9,10 @@ import { randomBytes } from 'crypto';
 import { join } from 'path';
 import { Worker } from 'worker_threads';
 import { getPluginData } from '../config.mjs';
-import { renameWithRetrySync } from '../../../shared/atomic-file.mjs';
+import { renameWithRetrySync, updateJsonAtomicSync, writeJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 
 const _lastSaveError = new Map(); // id -> { message, at }
+const SESSION_SUMMARY_INDEX_VERSION = 1;
 
 function _renameWithRetrySync(tmp, target) {
     return renameWithRetrySync(tmp, target);
@@ -32,6 +33,11 @@ function sessionPath(id) {
     }
     return join(getStoreDir(), `${id}.json`);
 }
+function summaryIndexPath() {
+    const dir = getPluginData();
+    mkdirSync(dir, { recursive: true });
+    return join(dir, 'session-summaries.json');
+}
 /**
  * Ensure generation/closed defaults on every session object.
  * Older persisted sessions predate these fields; we normalise at load and save.
@@ -44,6 +50,177 @@ function _ensureLifecycleFields(session) {
     return session;
 }
 
+function _messageText(content) {
+    if (typeof content === 'string') return content;
+    if (Array.isArray(content)) {
+        return content.map((part) => {
+            if (typeof part === 'string') return part;
+            if (part?.type === 'text') return part.text || '';
+            if (typeof part?.text === 'string') return part.text;
+            try { return JSON.stringify(part); } catch { return ''; }
+        }).filter(Boolean).join('\n');
+    }
+    if (content && typeof content === 'object') {
+        if (typeof content.text === 'string') return content.text;
+        try { return JSON.stringify(content); } catch { return ''; }
+    }
+    return '';
+}
+
+function _cleanPreview(text, max = 240) {
+    const value = String(text || '').replace(/\s+/g, ' ').trim();
+    return value.length > max ? value.slice(0, max).replace(/\s+\S*$/, '').trim() : value;
+}
+
+function _isPreviewNoise(text) {
+    const value = String(text || '').trim();
+    if (!value) return true;
+    if (value.startsWith('<system-reminder>')) return true;
+    if (/^Reference files:/i.test(value)) return true;
+    if (value.includes('<!-- bp3-sentinel -->')) return true;
+    return false;
+}
+
+function _sessionPreview(session) {
+    const messages = Array.isArray(session?.messages) ? session.messages : [];
+    let first = '';
+    for (const m of messages) {
+        if (m?.role !== 'user') continue;
+        const text = _cleanPreview(_messageText(m.content));
+        if (_isPreviewNoise(text)) continue;
+        if (!first) first = text;
+    }
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const m = messages[i];
+        if (m?.role !== 'user') continue;
+        const text = _cleanPreview(_messageText(m.content));
+        if (_isPreviewNoise(text)) continue;
+        return text || first;
+    }
+    return first;
+}
+
+function _sessionMessageCount(session) {
+    const messages = Array.isArray(session?.messages) ? session.messages : [];
+    let count = 0;
+    for (const m of messages) {
+        if (m && (m.role === 'user' || m.role === 'assistant')) count++;
+    }
+    return count;
+}
+
+function _positiveNumber(value, fallback = 0) {
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+function _sessionSummary(session) {
+    if (!session?.id) return null;
+    return {
+        id: String(session.id),
+        updatedAt: _positiveNumber(session.updatedAt, Date.now()),
+        createdAt: _positiveNumber(session.createdAt, 0),
+        lastHeartbeatAt: _positiveNumber(session.lastHeartbeatAt, 0),
+        closed: session.closed === true,
+        status: String(session.status || (session.closed === true ? 'closed' : 'idle')),
+        owner: session.owner || 'user',
+        role: session.role || null,
+        sourceType: session.sourceType || null,
+        sourceName: session.sourceName || null,
+        scopeKey: session.scopeKey || null,
+        ownerSessionId: session.ownerSessionId || null,
+        clientHostPid: _positiveNumber(session.clientHostPid, 0) || null,
+        cwd: session.cwd || '',
+        provider: session.provider || null,
+        model: session.model || null,
+        bridgeTag: session.bridgeTag || null,
+        task_id: session.task_id || session.taskId || null,
+        permission: session.permission || null,
+        toolPermission: session.toolPermission || null,
+        messageCount: _sessionMessageCount(session),
+        preview: _sessionPreview(session),
+        generation: typeof session.generation === 'number' ? session.generation : 0,
+        implicitBashSessionId: session.implicitBashSessionId || null,
+    };
+}
+
+function _normalizeSummaryRow(row) {
+    if (!row?.id || typeof row.id !== 'string' || !/^[A-Za-z0-9_-]+$/.test(row.id)) return null;
+    return {
+        id: row.id,
+        updatedAt: _positiveNumber(row.updatedAt, 0),
+        createdAt: _positiveNumber(row.createdAt, 0),
+        lastHeartbeatAt: _positiveNumber(row.lastHeartbeatAt, 0),
+        closed: row.closed === true,
+        status: String(row.status || (row.closed === true ? 'closed' : 'idle')),
+        owner: row.owner || 'user',
+        role: row.role || null,
+        sourceType: row.sourceType || null,
+        sourceName: row.sourceName || null,
+        scopeKey: row.scopeKey || null,
+        ownerSessionId: row.ownerSessionId || null,
+        clientHostPid: _positiveNumber(row.clientHostPid, 0) || null,
+        cwd: row.cwd || '',
+        provider: row.provider || null,
+        model: row.model || null,
+        bridgeTag: row.bridgeTag || null,
+        task_id: row.task_id || null,
+        permission: row.permission || null,
+        toolPermission: row.toolPermission || null,
+        messageCount: Math.max(0, Math.floor(Number(row.messageCount) || 0)),
+        preview: _cleanPreview(row.preview || ''),
+        generation: typeof row.generation === 'number' ? row.generation : 0,
+        implicitBashSessionId: row.implicitBashSessionId || null,
+    };
+}
+
+function _normalizeSummaryIndex(raw) {
+    const rows = Array.isArray(raw?.rows) ? raw.rows.map(_normalizeSummaryRow).filter(Boolean) : [];
+    rows.sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+    return { version: SESSION_SUMMARY_INDEX_VERSION, updatedAt: _positiveNumber(raw?.updatedAt, 0), rows };
+}
+
+function _writeSummaryIndex(rows) {
+    const cleanRows = (rows || []).map(_normalizeSummaryRow).filter(Boolean)
+        .sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+    writeJsonAtomicSync(summaryIndexPath(), {
+        version: SESSION_SUMMARY_INDEX_VERSION,
+        updatedAt: Date.now(),
+        rows: cleanRows,
+    }, { compact: true, lock: true });
+    return cleanRows;
+}
+
+function _upsertSessionSummary(session) {
+    const row = _sessionSummary(session);
+    if (!row) return;
+    try {
+        updateJsonAtomicSync(summaryIndexPath(), (cur) => {
+            const index = _normalizeSummaryIndex(cur);
+            const rows = index.rows.filter((r) => r.id !== row.id);
+            const cleanRow = _normalizeSummaryRow(row);
+            if (!cleanRow) return undefined;
+            const existing = index.rows.find((r) => r.id === row.id) || null;
+            if (existing && JSON.stringify(existing) === JSON.stringify(cleanRow)) return undefined;
+            rows.push(cleanRow);
+            rows.sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+            return { version: SESSION_SUMMARY_INDEX_VERSION, updatedAt: Date.now(), rows };
+        }, { compact: true, lock: true });
+    } catch { /* summary index is best-effort */ }
+}
+
+function _removeSessionSummary(id) {
+    if (!id) return;
+    try {
+        updateJsonAtomicSync(summaryIndexPath(), (cur) => {
+            const index = _normalizeSummaryIndex(cur);
+            const rows = index.rows.filter((r) => r.id !== id);
+            if (rows.length === index.rows.length) return undefined;
+            return { version: SESSION_SUMMARY_INDEX_VERSION, updatedAt: Date.now(), rows };
+        }, { compact: true, lock: true });
+    } catch { /* summary index is best-effort */ }
+}
+
 /** Module-level map tracking in-flight saves per session ID to prevent concurrent write corruption. */
 const _savePending = new Map();
 
@@ -297,6 +474,7 @@ function _doSaveSync(payload) {
             return;
         }
         _renameWithRetrySync(tmp, target);
+        _upsertSessionSummary(session);
     } catch (err) {
         try { unlinkSync(tmp); } catch { /* ignore cleanup failure */ }
         throw err;
@@ -390,6 +568,7 @@ async function _doSave(payload) {
             return;
         }
         _renameWithRetrySync(tmp, target);
+        _upsertSessionSummary(session);
     } catch (err) {
         try { unlinkSync(tmp); } catch { /* ignore cleanup failure */ }
         _savePending.delete(id);
@@ -426,6 +605,7 @@ export function markSessionClosed(id, reason = 'manual') {
     _savePending.delete(id);
     _clearLiveSession(id);
     _deleteHeartbeat(id);
+    _upsertSessionSummary(tombstone);
     // Structured close metric. Single emission point because every close
     // path funnels through markSessionClosed. lifeMs = updatedAt-createdAt
     // straddles the tombstone (updatedAt was just set to Date.now()), so
@@ -488,6 +668,7 @@ export function deleteSession(id) {
         catch { /* fall through to .hb cleanup */ }
     }
     _deleteHeartbeat(id);
+    if (removed) _removeSessionSummary(id);
     return removed;
 }
 const DEFAULT_SESSION_TTL_MS = 5 * 60 * 1000; // 5 minutes idle — aligned with Anthropic 5m messages tier and OpenAI in-memory cache window
@@ -518,6 +699,28 @@ export function listStoredSessions() {
     return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
 }
 
+export function rebuildSessionSummaryIndex() {
+    const rows = listStoredSessions().map(_sessionSummary).filter(Boolean);
+    return _writeSummaryIndex(rows);
+}
+
+export function listStoredSessionSummaries(options = {}) {
+    const rebuildIfMissing = options.rebuildIfMissing !== false;
+    const p = summaryIndexPath();
+    if (!existsSync(p)) {
+        return rebuildIfMissing ? rebuildSessionSummaryIndex() : [];
+    }
+    try {
+        const index = _normalizeSummaryIndex(JSON.parse(readFileSync(p, 'utf-8')));
+        if (index.rows.length > 0) return index.rows;
+        const dir = getStoreDir();
+        const hasSessionFiles = existsSync(dir) && readdirSync(dir).some((f) => f.endsWith('.json'));
+        return hasSessionFiles && rebuildIfMissing ? rebuildSessionSummaryIndex() : index.rows;
+    } catch {
+        return rebuildIfMissing ? rebuildSessionSummaryIndex() : [];
+    }
+}
+
 /**
  * Raw directory scan — returns every parseable session file without any
  * TTL-based inline deletion. Callers (e.g. sweepTombstones) need to own the
@@ -552,7 +755,7 @@ export function sweepStaleSessions(ttlMs, options = {}) {
     const dir = getStoreDir();
     if (!existsSync(dir))
         return { cleaned: 0, remaining: 0, details: [], tombstonesCleaned: 0, tombstoneDetails: [], tombstoneErrors: [] };
-    const files = readdirSync(dir).filter(f => f.endsWith('.json'));
+    const summaries = listStoredSessionSummaries();
     const now = Date.now();
     let cleaned = 0;
     let remaining = 0;
@@ -560,38 +763,42 @@ export function sweepStaleSessions(ttlMs, options = {}) {
     const details = [];
     const tombstoneDetails = [];
     const tombstoneErrors = [];
-    for (const f of files) {
+    for (const row of summaries) {
         try {
-            const jsonPath = join(dir, f);
+            if (!row?.id) continue;
+            const jsonPath = sessionPath(row.id);
+            if (!existsSync(jsonPath)) {
+                _removeSessionSummary(row.id);
+                continue;
+            }
             let jsonMtime = 0;
             let heartbeatMtime = 0;
             try { jsonMtime = statSync(jsonPath).mtimeMs || 0; } catch {}
             try {
-                const hbPath = join(dir, f.replace(/\.json$/, '.hb'));
+                const hbPath = join(dir, `${row.id}.hb`);
                 if (existsSync(hbPath)) heartbeatMtime = statSync(hbPath).mtimeMs || 0;
             } catch { /* .hb unavailable — fall back to JSON fields */ }
             const freshnessGateMs = sweepIdle ? maxAge : (sweepTombstones ? tombstoneMaxAgeMs : 0);
-            const newestMtime = Math.max(jsonMtime, heartbeatMtime);
-            if (freshnessGateMs > 0 && newestMtime > 0 && now - newestMtime <= freshnessGateMs) {
+            const newestKnown = Math.max(row.updatedAt || 0, row.lastHeartbeatAt || 0, row.createdAt || 0, jsonMtime, heartbeatMtime);
+            if (freshnessGateMs > 0 && newestKnown > 0 && now - newestKnown <= freshnessGateMs) {
                 remaining++;
                 continue;
             }
-            const session = JSON.parse(readFileSync(jsonPath, 'utf-8'));
             // Already-closed tombstones are handled here before heartbeat
             // sidecar checks; they do not need liveness probing.
-            if (session.closed === true || session.status === 'closed') {
+            if (row.closed === true || row.status === 'closed') {
                 if (sweepTombstones) {
-                    const updated = Number(session.updatedAt);
+                    const updated = Number(row.updatedAt);
                     const age = now - updated;
                     if (Number.isFinite(updated) && age >= tombstoneMaxAgeMs) {
                         try {
-                            if (deleteSession(session.id)) {
+                            if (deleteSession(row.id)) {
                                 tombstonesCleaned++;
-                                tombstoneDetails.push({ id: session.id, ageSeconds: Math.floor(age / 1000) });
+                                tombstoneDetails.push({ id: row.id, ageSeconds: Math.floor(age / 1000) });
                                 continue;
                             }
                         } catch (err) {
-                            tombstoneErrors.push({ id: session.id, message: err?.message || String(err) });
+                            tombstoneErrors.push({ id: row.id, message: err?.message || String(err) });
                             remaining++;
                             continue;
                         }
@@ -602,7 +809,7 @@ export function sweepStaleSessions(ttlMs, options = {}) {
             }
             // Sweep bridge-owned and ownerless (legacy) sessions; skip explicit
             // user sessions before touching heartbeat sidecars.
-            if (typeof session.owner === 'string' && session.owner.length > 0 && session.owner !== 'bridge') {
+            if (typeof row.owner === 'string' && row.owner.length > 0 && row.owner !== 'bridge') {
                 remaining++;
                 continue;
             }
@@ -613,30 +820,30 @@ export function sweepStaleSessions(ttlMs, options = {}) {
             // Prefer .hb sidecar mtime — updated at tight cadence (≤5s) without
             // serialising the full JSON, so it reflects true liveness more
             // accurately than the JSON timestamp fields.
-            let lastActive = session.lastHeartbeatAt || session.updatedAt || session.createdAt || 0;
+            let lastActive = row.lastHeartbeatAt || row.updatedAt || row.createdAt || 0;
             if (heartbeatMtime) lastActive = Math.max(lastActive, heartbeatMtime);
             // Running sessions are normally reaped by the stream-watchdog
             // within ~120s. Skip them here unless they've been silent past
             // RUNNING_STALL_MS, at which point they are treated as zombies.
-            if (session.status === 'running' && now - lastActive <= RUNNING_STALL_MS) {
+            if (row.status === 'running' && now - lastActive <= RUNNING_STALL_MS) {
                 remaining++;
                 continue;
             }
-            const isCompletedBridge = session.owner === 'bridge'
-                && BRIDGE_TERMINAL_STATUSES.has(session.status);
+            const isCompletedBridge = row.owner === 'bridge'
+                && BRIDGE_TERMINAL_STATUSES.has(row.status);
             const sessionMaxAge = isCompletedBridge ? BRIDGE_TERMINAL_TTL_MS : maxAge;
             if (now - lastActive > sessionMaxAge) {
-                try { markSessionClosed(session.id, 'idle-sweep'); }
+                try { markSessionClosed(row.id, 'idle-sweep'); }
                 catch (err) {
-                    process.stderr.write(`[session-store] idle-sweep close failed for ${session.id}: ${err?.message}\n`);
+                    process.stderr.write(`[session-store] idle-sweep close failed for ${row.id}: ${err?.message}\n`);
                     continue;
                 }
                 cleaned++;
                 details.push({
-                    id: session.id,
-                    owner: session.owner || 'unknown',
+                    id: row.id,
+                    owner: row.owner || 'unknown',
                     idleMinutes: Math.round((now - lastActive) / 60000),
-                    bashSessionId: session.implicitBashSessionId || null,
+                    bashSessionId: row.implicitBashSessionId || null,
                 });
             } else {
                 remaining++;

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

@@ -1,4 +1,4 @@
-// Cross-process advisory lock for write/edit operations. Uses a sibling
+// Cross-process advisory lock for patch/write operations. Uses a sibling
 // lockfile written exclusively (`wx`) and a process.kill(pid, 0) liveness
 // check to clean up after crashed holders. Pair with the in-process
 // withPathLock for the same target: in-process serialises async callers

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

@@ -3,7 +3,7 @@ import { join } from 'path';
 import { writeJsonAtomicSync } from '../../../../shared/atomic-file.mjs';
 import { resolvePluginData } from '../../../../shared/plugin-paths.mjs';
 
-// Mixdog read/write/edit share a scoped snapshot store. Value stores the
+// Mixdog read/patch paths share a scoped snapshot store. Value stores the
 // mtime + size at read-time. A missing scope is fail-closed: snapshots without
 // a real scope id are NOT recorded under a shared default bucket (would let
 // worker A's read satisfy worker B's edit-gate across sessions via a persisted

package/src/runtime/channels/lib/tool-format.mjs

@@ -80,8 +80,6 @@ function buildToolLine(name, input, hiddenCheck = isHidden) {
       detail = (input?.command || input?.cmd || desc || "").substring(0, 500);
       break;
     }
-    case "edit":
-    case "write":
     case "apply_patch":
       detail = input?.file_path || "";
       break;