mixdog 0.9.19 → 0.9.21

package/src/runtime/agent/orchestrator/session/manager/prefetch-bridge.mjs

@@ -0,0 +1,268 @@
+// manager/prefetch-bridge.mjs
+// Explicit-prefetch bridge extracted verbatim from manager.mjs. Runs Lead-
+// supplied files[]/callers[]/references[] prefetch (outside the agent loop),
+// with a pass-through permission guard for API compatibility.
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { isAgentOwner } from '../../agent-owner.mjs';
+import { executeInternalTool } from '../../internal-tools.mjs';
+import { classifyResultKind } from '../result-classification.mjs';
+import { tryPrefetchCached, setPrefetchCached } from '../read-dedup.mjs';
+import { _executeCodeGraphToolLazy } from './runtime-loaders.mjs';
+
+// ── Prefetch permission guard ─────────────────────────────────────────────────
+// Runs the shared permission evaluator for tool calls that originate in the
+// prefetch path (outside the agent loop). Permission enforcement is disabled
+// (the evaluator always returns allow), so this is effectively a pass-through
+// kept for API compatibility. Returns an error string if blocked, or null.
+const _permEvalForPrefetch = (() => {
+    const _req = createRequire(import.meta.url);
+    try {
+        const { dirname: _pdir, resolve: _pres } = _req('path');
+        const _hooksLib = _pres(_pdir(fileURLToPath(import.meta.url)), '../../../../../hooks/lib/permission-evaluator.cjs');
+        return _req(_hooksLib).evaluatePermission;
+    } catch { return null; }
+})();
+function _guardedPrefetchTool(toolName, toolArgs, session) {
+    if (!_permEvalForPrefetch) return null;
+    // When no explicit mode is attached to the session, run the evaluator
+    // under 'default'. The evaluator now always allows, so this never blocks.
+    const permissionMode = session?.permissionMode || 'default';
+    const projectDir = session?.cwd || undefined;
+    const userCwd = session?.cwd || undefined;
+    const MCP_PFX = 'mcp__plugin_mixdog_mixdog__';
+    const fullName = toolName.startsWith(MCP_PFX) || toolName.startsWith('mcp__') ? toolName : `${MCP_PFX}${toolName}`;
+    try {
+        const { decision, reason } = _permEvalForPrefetch({ toolName: fullName, toolInput: toolArgs || {}, permissionMode, projectDir, userCwd });
+        if (decision === 'deny' || decision === 'ask') {
+            return `Error: prefetch tool "${toolName}" blocked (decision=${decision}): ${reason}`;
+        }
+    } catch (e) {
+        process.stderr.write(`[prefetch-guard] evaluator error: ${e?.message}\n`);
+    }
+    return null;
+}
+
+export async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
+    if (!explicitPrefetch || typeof explicitPrefetch !== 'object') return null;
+    if (!isAgentOwner(session)) return null;
+    const parts = [];
+    const failed = [];
+    const totalEntries = [];
+    // files[] — string entries use the default head excerpt; object entries
+    // {path, n?, full?} let the caller widen the window or pull the full file
+    // so worker doesn't have to re-read deep ranges of an already-prefetched
+    // file (a recurring iter burner observed in baseline session telemetry).
+    const _rawFilesIn = Array.isArray(explicitPrefetch.files) ? explicitPrefetch.files : [];
+    const _readOptsByFile = new Map();
+    const files = [];
+    const _seenFiles = new Set();
+    const _addPrefetchFile = (file, opts = null) => {
+        if (typeof file !== 'string' || !file) return;
+        if (!_seenFiles.has(file)) {
+            _seenFiles.add(file);
+            files.push(file);
+        }
+        if (!opts || Object.keys(opts).length === 0) return;
+        const prev = _readOptsByFile.get(file) || {};
+        const merged = { ...prev };
+        if (opts.mode === 'full') {
+            merged.mode = 'full';
+            delete merged.n;
+        } else if (merged.mode !== 'full' && Number.isFinite(opts.n) && opts.n > 0) {
+            merged.n = Math.max(Number(merged.n) || 0, opts.n);
+        }
+        if (Object.keys(merged).length > 0) _readOptsByFile.set(file, merged);
+    };
+    for (const entry of _rawFilesIn) {
+        if (typeof entry === 'string' && entry) {
+            _addPrefetchFile(entry);
+        } else if (entry && typeof entry === 'object' && typeof entry.path === 'string' && entry.path) {
+            const opts = {};
+            if (entry.full === true) opts.mode = 'full';
+            else if (Number.isFinite(entry.n) && entry.n > 0) opts.n = entry.n;
+            _addPrefetchFile(entry.path, opts);
+        }
+    }
+    if (files.length > 0) {
+        const _pfGuard = _guardedPrefetchTool('read', { path: files }, session);
+        if (_pfGuard) {
+            process.stderr.write(`[agent-prefetch] files read blocked: ${_pfGuard}\n`);
+            failed.push(...files);
+            totalEntries.push(...files);
+        } else {
+        totalEntries.push(...files);
+        // R20: per-file prefetch cache (cross-dispatch, process-local).
+        // Try each file from cache first; batch misses into one disk read.
+        const { resolve: _pfResolve, isAbsolute: _pfIsAbs, normalize: _pfNorm } = await import('path');
+        const _pfCwd = session.cwd || null;
+        function _pfAbsPath(f) {
+            const abs = _pfIsAbs(f) ? f : _pfResolve(_pfCwd || process.cwd(), f);
+            return _pfNorm(abs);
+        }
+        const fileHits = [];   // { file, abs, content } — satisfied from cache
+        const fileMisses = []; // { file, abs } — need disk read
+        for (const f of files) {
+            const abs = _pfAbsPath(f);
+            // Skip the cross-dispatch cache when the caller asked for a
+            // non-default window (custom n or full-file). Cache key is the
+            // path alone, so a default-window cache hit would silently feed
+            // the wrong slice back to the next caller.
+            const hit = _readOptsByFile.has(f) ? null : tryPrefetchCached(abs);
+            if (hit) {
+                fileHits.push({ file: f, abs, content: hit.content });
+            } else {
+                fileMisses.push({ file: f, abs });
+            }
+        }
+        // Disk read for misses (single batch call).
+        const missFiles = fileMisses.map(m => m.file);
+        const missResults = {}; // file → content string
+        if (missFiles.length > 0) {
+            // Read each miss file individually so we can cache per-file.
+            // The files list is small (typically 2-5), so N awaits is fine.
+            await Promise.all(missFiles.map(async (f) => {
+                const opts = _readOptsByFile.get(f) || {};
+                const readArgs = { path: f };
+                if (opts.mode === 'full') {
+                    readArgs.mode = 'full';
+                } else {
+                    readArgs.mode = 'head';
+                    readArgs.n = Number.isFinite(opts.n) ? opts.n : 120;
+                }
+                const out = await executeInternalTool('read', readArgs).catch((e) => {
+                    process.stderr.write(`[agent-prefetch] file read failed (${f}): ${e && e.message || e}\n`);
+                    return null;
+                });
+                if (out !== null) {
+                    missResults[f] = String(out);
+                }
+            }));
+            // Cache successful miss results.
+            for (const { file, abs } of fileMisses) {
+                const content = missResults[file];
+                if (content && classifyResultKind(content) !== 'error') {
+                    // Only cache default-window reads; custom-window results
+                    // would poison the shared cross-dispatch cache.
+                    if (!_readOptsByFile.has(file)) setPrefetchCached(abs, content);
+                } else if (content === undefined || classifyResultKind(content) === 'error') {
+                    failed.push(file);
+                }
+            }
+        }
+        // Assemble combined output preserving original file order.
+        const readParts = [];
+        const hitByFile = new Map(fileHits.map((h) => [h.file, h]));
+        for (const f of files) {
+            const hitEntry = hitByFile.get(f);
+            if (hitEntry) {
+                readParts.push(hitEntry.content);
+                continue;
+            }
+            const content = missResults[f];
+            if (content && classifyResultKind(content) !== 'error') {
+                readParts.push(content);
+            }
+            // else: already pushed to failed above
+        }
+        if (readParts.length > 0) {
+            parts.push(`### prefetch files\nread ${readParts.length}\n\n${readParts.join('\n\n')}`);
+        }
+        // Log hit/miss counters so dispatch telemetry shows prefetch effectiveness.
+        if (process.env.MIXDOG_DEBUG_SESSION_LOG) {
+            process.stderr.write(
+                `[prefetch] files=${files.length} cached=${fileHits.length} miss=${fileMisses.length} failed=${failed.length}\n`
+            );
+        }
+        // Attach stats to session so post-hoc analyzers (inspect-session.mjs)
+        // can see prefetch effectiveness without parsing stderr logs.
+        if (session && typeof session === 'object') {
+            if (!session.prefetchStats) session.prefetchStats = { files: 0, cached: 0, miss: 0, failed: 0 };
+            session.prefetchStats.files += files.length;
+            session.prefetchStats.cached += fileHits.length;
+            session.prefetchStats.miss += fileMisses.length;
+            session.prefetchStats.failed += failed.length;
+        }
+        }
+    }
+    // callers[]
+    const callers = Array.isArray(explicitPrefetch.callers) ? explicitPrefetch.callers.filter(c => c && typeof c.symbol === 'string') : [];
+    {
+        const callerTasks = callers.map(({ symbol, file }) => {
+            const cgArgs = { mode: 'callers', symbol };
+            if (file) cgArgs.file = file;
+            if (session?.cwd) cgArgs.cwd = session.cwd;
+            totalEntries.push(symbol);
+            const blocked = _guardedPrefetchTool('code_graph', cgArgs, session);
+            if (blocked) {
+                process.stderr.write(`[agent-prefetch] callers(${symbol}) blocked: ${blocked}\n`);
+                return Promise.resolve({ symbol, out: null, blocked: true });
+            }
+            return _executeCodeGraphToolLazy('code_graph', cgArgs, session?.cwd)
+                .then(out => ({ symbol, out }))
+                .catch(e => {
+                    process.stderr.write(`[agent-prefetch] callers(${symbol}) failed: ${e && e.message || e}\n`);
+                    return { symbol, out: null };
+                });
+        });
+        const callerResults = await Promise.allSettled(callerTasks);
+        for (const r of callerResults) {
+            const { symbol, out, blocked } = r.status === 'fulfilled' ? r.value : { symbol: '?', out: null };
+            if (blocked) { failed.push(symbol); continue; }
+            if (out && classifyResultKind(String(out)) !== 'error') {
+                parts.push(`### prefetch callers ${symbol}\n${out}`);
+            } else {
+                failed.push(symbol);
+            }
+        }
+    }
+    // references[]
+    const references = Array.isArray(explicitPrefetch.references) ? explicitPrefetch.references.filter(r => r && typeof r.symbol === 'string') : [];
+    {
+        const refTasks = references.map(({ symbol, file }) => {
+            const cgArgs = { mode: 'references', symbol };
+            if (file) cgArgs.file = file;
+            if (session?.cwd) cgArgs.cwd = session.cwd;
+            totalEntries.push(symbol);
+            const blocked = _guardedPrefetchTool('code_graph', cgArgs, session);
+            if (blocked) {
+                process.stderr.write(`[agent-prefetch] references(${symbol}) blocked: ${blocked}\n`);
+                return Promise.resolve({ symbol, out: null, blocked: true });
+            }
+            return _executeCodeGraphToolLazy('code_graph', cgArgs, session?.cwd)
+                .then(out => ({ symbol, out }))
+                .catch(e => {
+                    process.stderr.write(`[agent-prefetch] references(${symbol}) failed: ${e && e.message || e}\n`);
+                    return { symbol, out: null };
+                });
+        });
+        const refResults = await Promise.allSettled(refTasks);
+        for (const r of refResults) {
+            const { symbol, out, blocked } = r.status === 'fulfilled' ? r.value : { symbol: '?', out: null };
+            if (blocked) { failed.push(symbol); continue; }
+            if (out && classifyResultKind(String(out)) !== 'error') {
+                parts.push(`### prefetch references ${symbol}\n${out}`);
+            } else {
+                failed.push(symbol);
+            }
+        }
+    }
+    if (session && typeof session === 'object' && (callers.length > 0 || references.length > 0)) {
+        if (!session.prefetchStats) session.prefetchStats = { files: 0, cached: 0, miss: 0, failed: 0, callers: 0, references: 0 };
+        session.prefetchStats.callers = (session.prefetchStats.callers || 0) + callers.length;
+        session.prefetchStats.references = (session.prefetchStats.references || 0) + references.length;
+    }
+    if (parts.length === 0) {
+        // All entries failed but Lead presence must still be signalled — emit
+        // warn-only so the gate logic can distinguish "prefetch was requested"
+        // from "no prefetch at all".
+        if (totalEntries.length > 0 && failed.length > 0) {
+            return `<prefetch-warn>${failed.length} of ${totalEntries.length} prefetch entries failed: ${[...new Set(failed)].join(', ')}</prefetch-warn>`;
+        }
+        return null;
+    }
+    const warnLine = failed.length > 0
+        ? `<prefetch-warn>${failed.length} of ${totalEntries.length} prefetch entries failed: ${[...new Set(failed)].join(', ')}</prefetch-warn>\n`
+        : '';
+    return `${warnLine}<prefetch>\n${parts.join('\n\n')}\n</prefetch>`;
+}

package/src/runtime/agent/orchestrator/session/manager/provider-cache-key.mjs

@@ -0,0 +1,22 @@
+// manager/provider-cache-key.mjs
+// Provider-scoped unified cache key extracted verbatim from manager.mjs. Goal:
+// all orchestrator-internal dispatches (agent/maintenance/mcp/scheduler/webhook)
+// targeting the same provider land in a single server-side cache shard, so the
+// shared prefix (tools + system + pool system prompt) is reused regardless of
+// role. Per-role / per-session differentiation lives after the system prefix
+// (BP3 sessionMarker system block / later messages), which is naturally
+// separated by provider-side content hashing.
+const PROVIDER_ALIAS = {
+    'openai-oauth': 'codex',      // ChatGPT subscription (OpenAI OAuth backend)
+    'anthropic-oauth': 'claude',  // Claude Max subscription
+    'openai': 'openai',
+    'anthropic': 'anthropic',
+    'gemini': 'gemini',
+    'deepseek': 'deepseek',
+    'xai': 'xai',
+};
+export function providerCacheKey(provider, override) {
+    if (override) return String(override);
+    if (!provider) return 'mixdog-default';
+    return `mixdog-${PROVIDER_ALIAS[provider] || provider}`;
+}

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

@@ -0,0 +1,26 @@
+// manager/runtime-loaders.mjs
+// Lazy runtime import bridges extracted from manager.mjs. Dynamic import()
+// keeps the heavy code_graph tool / agent loop / bash-session runtimes out of
+// the session-creation path and avoids a circular import through loop.mjs.
+let _codeGraphRuntimePromise = null;
+let _agentLoopPromise = null;
+let _bashSessionRuntimePromise = null;
+export async function _executeCodeGraphToolLazy(name, args, cwd, signal = null, options = {}) {
+    _codeGraphRuntimePromise ??= import('../../tools/code-graph.mjs');
+    const mod = await _codeGraphRuntimePromise;
+    if (typeof mod.executeCodeGraphTool !== 'function') throw new Error('code_graph runtime is not available');
+    return mod.executeCodeGraphTool(name, args, cwd, signal, options);
+}
+export async function _getAgentLoop() {
+    _agentLoopPromise ??= import('../loop.mjs');
+    const mod = await _agentLoopPromise;
+    if (typeof mod.agentLoop !== 'function') throw new Error('agent loop runtime is not available');
+    return mod.agentLoop;
+}
+export function _closeBashSessionLazy(sessionId, reason) {
+    if (!sessionId) return;
+    _bashSessionRuntimePromise ??= import('../../tools/bash-session.mjs');
+    _bashSessionRuntimePromise
+        .then((mod) => { if (typeof mod.closeBashSession === 'function') mod.closeBashSession(sessionId, reason); })
+        .catch(() => {});
+}

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

@@ -0,0 +1,124 @@
+// manager/session-close.mjs
+// Session teardown extracted verbatim from manager.mjs. closeSession plants a
+// disk tombstone (or bumps generation when tombstone=false), aborts the
+// in-flight controller, tears down runtime/bash/dedup/offload/pending state,
+// and defers the runtime-map clear. abortSessionTurn cancels the current turn
+// without tombstoning.
+import { loadSession, markSessionClosed, bumpSessionGeneration } from '../store.mjs';
+import { clearReadDedupSession } from '../read-dedup.mjs';
+import { clearOffloadSession } from '../tool-result-offload.mjs';
+import { SessionClosedError } from './session-errors.mjs';
+import { _dropPendingMessageState } from './pending-messages.mjs';
+import { _stopToolActivityHeartbeat, _getRuntimeEntry, _clearSessionRuntime } from './runtime-liveness.mjs';
+import { _closeBashSessionLazy } from './runtime-loaders.mjs';
+
+/**
+ * Close a session. Plants a `closed=true` tombstone on disk with a bumped
+ * generation (so any racing saveSession() drops its write), aborts the
+ * in-flight controller if one exists, and clears the in-memory runtime entry.
+ *
+ * IMPORTANT: we deliberately do NOT unlink the session file here. The tombstone
+ * on disk is the authoritative signal that blocks resurrection — a late
+ * saveSession() re-reads disk via _shouldDrop() and will find the tombstone.
+ * If we delete the file, a late save sees no file, decides nothing to drop,
+ * and recreates the session in its pre-close state.
+ *
+ * Long-term cleanup: `sweepTombstones()` below unlinks tombstones older than
+ * TOMBSTONE_MAX_AGE_MS (24h — vastly longer than any realistic in-flight race).
+ */
+export function closeSession(id, reason = 'manual', opts = {}) {
+    // tombstone=false: detach runtime resources (heartbeat, bash shells,
+    // controller abort, runtime-map clear) WITHOUT planting the disk
+    // tombstone. Used for non-empty sessions on /resume-away, /new, and
+    // TUI exit — previously every one of those paths unconditionally
+    // tombstoned the outgoing session, which made it vanish from the
+    // Resume list immediately and get hard-deleted by sweepTombstones()
+    // after 24h even though it had real conversation content worth
+    // resuming. Only truly-empty scratch sessions should still tombstone.
+    const tombstone = opts.tombstone !== false;
+    if (!id) return false;
+    _stopToolActivityHeartbeat(id);
+    // Prefer in-memory runtime session — allBashSessionIds may not be persisted
+    // yet for shells opened in the current turn (BL-bash-disk-sync).
+    const inMemory = _getRuntimeEntry(id)?.session;
+    const persisted = inMemory || loadSession(id);
+    const bashSessionId = persisted?.implicitBashSessionId || null;
+    // Collect all persistent bash shells created during this session.
+    const allBashIds = Array.isArray(persisted?.allBashSessionIds)
+        ? persisted.allBashSessionIds.filter(Boolean)
+        : (bashSessionId ? [bashSessionId] : []);
+    // Deduplicate: allBashIds already covers implicitBashSessionId, but guard
+    // against old session records that only have implicitBashSessionId.
+    if (bashSessionId && !allBashIds.includes(bashSessionId)) allBashIds.push(bashSessionId);
+    // 1. Tombstone first — this wins the race against saveSession().
+    //    Skipped when tombstone=false: no closed:true marker is planted, so
+    //    the session file stays intact and resumeSession() will accept it.
+    //    We still bump the on-disk generation via bumpSessionGeneration() —
+    //    that alone is what protects the session from a late save race: any
+    //    saveSession() still in flight from this detached turn (e.g. the
+    //    cancel-cleanup save below) carries the OLD generation as its
+    //    expectedGeneration, so _shouldDrop()'s ownership-counter rule drops
+    //    it once disk generation moves past that. Without this bump the late
+    //    write could silently overwrite the session after the user resumes
+    //    it back (BL: burned-session late-save clobber).
+    const newGen = tombstone ? markSessionClosed(id, reason) : bumpSessionGeneration(id, reason);
+    // 2. Mark runtime as closed so post-await validation in askSession fires.
+    const entry = _getRuntimeEntry(id);
+    if (entry) {
+        entry.closed = true;
+        entry.closedReason = reason;
+        if (typeof newGen === 'number') entry.generation = newGen;
+        entry.stage = 'cancelling';
+        entry.updatedAt = Date.now();
+        // 3. Abort the in-flight controller. Providers that honour the signal
+        //    unwind immediately; providers that don't will still be caught by
+        //    the generation check after their await eventually returns.
+        try { entry.controller?.abort(new SessionClosedError(id, `closeSession (reason=${reason})`, reason)); } catch { /* ignore */ }
+    }
+    // Diagnostic: one-line stderr so operators can distinguish the four close
+    // pathways (request-abort / manual / idle-sweep / runner-crash). iterCount
+    // is not currently tracked on runtime state; askStartedAt is — derive
+    // duration from it when present.
+    try {
+        const askStartedAt = entry?.askStartedAt;
+        const durationMs = (typeof askStartedAt === 'number') ? (Date.now() - askStartedAt) : null;
+        const parts = [`session=${id}`, `reason=${reason}`, `tombstone=${tombstone}`];
+        if (durationMs != null) parts.push(`duration=${durationMs}ms`);
+        if (process.env.MIXDOG_DEBUG_SESSION_LOG) process.stderr.write(`[agent-close] ${parts.join(' ')}\n`);
+    } catch { /* best-effort */ }
+    for (const bsid of allBashIds) {
+        try { _closeBashSessionLazy(bsid, `agent-close:${id}`); } catch { /* ignore */ }
+    }
+    // Drop session-scoped read dedup cache so the Map doesn't accumulate
+    // entries across mcp-server lifetime.
+    try { clearReadDedupSession(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
+    // should not await disk IO; errors are swallowed inside.
+    try { clearOffloadSession(id); } catch { /* ignore */ }
+    // Drop the in-memory pending-message queue and any buffered-persist entry
+    // for this session — otherwise both Maps accumulate one entry per closed
+    // session for the life of the mcp-server.
+    _dropPendingMessageState(id, { clearPersisted: tombstone });
+    // 4. Defer runtime map clear to next tick so any settling askSession can
+    //    observe `closed=true` / bumped generation before we yank the entry.
+    //    Disk tombstone remains — that's what blocks resurrection.
+    setImmediate(() => {
+        _clearSessionRuntime(id);
+    });
+    return true;
+}
+export function abortSessionTurn(id, reason = 'turn-abort') {
+    if (!id) return false;
+    _stopToolActivityHeartbeat(id);
+    const entry = _getRuntimeEntry(id);
+    if (!entry || entry.closed) return false;
+    entry.stage = 'cancelling';
+    entry.closedReason = reason;
+    entry.updatedAt = Date.now();
+    try {
+        entry.controller?.abort(new SessionClosedError(id, `abortSessionTurn (reason=${reason})`, reason));
+    } catch { /* ignore */ }
+    return true;
+}