mixdog 0.9.52 → 0.9.53

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

@@ -28,16 +28,6 @@ import { providerInputExcludesCache } from '../../providers/registry.mjs';
 // the recall-fasttrack injection cap uses (loop.mjs recallTokenCap). One
 // number governs every "share of model context" budget.
 
-function resolveSemanticCompactSetting(sessionRef, cfg = {}) {
-    // Types are hard-locked (agent -> semantic, main/user -> recall-fasttrack).
-    // Semantic must always be available as a compact path or agent sessions
-    // would have none (loop.mjs throws when no type is available). Env/cfg
-    // off-switches no longer apply.
-    void sessionRef;
-    void cfg;
-    return true;
-}
-
 function resolveCompactTypeSetting(sessionRef, cfg = {}) {
     // Agent-owned sessions are ALWAYS semantic. recall-fasttrack rebuilds
     // context from Memory recall, which is scoped to the user's main-session
@@ -171,7 +161,7 @@ export function resolveWorkerCompactPolicy(sessionRef, tools) {
             ? Number(sessionRef.effectiveContextWindowPercent ?? cfg.effectiveContextWindowPercent)
             : null,
         autoCompactTokenLimit: explicitAutoCompactTokenLimit,
-        semantic: compactTypeIsSemantic(compactType) && resolveSemanticCompactSetting(sessionRef, cfg),
+        semantic: compactTypeIsSemantic(compactType),
         recallFastTrack: compactTypeIsRecallFastTrack(compactType),
         semanticTimeoutMs: positiveTokenInt(cfg.timeoutMs) || envTokenInt('MIXDOG_AGENT_COMPACT_TIMEOUT_MS') || 30_000,
         tailTurns: positiveTokenInt(cfg.tailTurns) || envTokenInt('MIXDOG_AGENT_COMPACT_TAIL_TURNS') || 2,
@@ -191,15 +181,15 @@ function compactPressureTokens(messageTokensEst, policy) {
 
 function providerPressureTokens(sessionRef, usage) {
     if (!usage || typeof usage !== 'object') return 0;
-    const input = Math.max(0, Number(usage.inputTokens) || 0);
-    const cachedRead = Math.max(0, Number(usage.cachedTokens) || 0);
-    const cacheWrite = Math.max(0, Number(usage.cacheWriteTokens) || 0);
-    const explicitPrompt = Math.max(0, Number(usage.promptTokens) || 0);
+    const input = Math.max(0, Number(usage.mainInputTokens ?? usage.inputTokens) || 0);
+    const cachedRead = Math.max(0, Number(usage.mainCachedTokens ?? usage.cachedTokens) || 0);
+    const cacheWrite = Math.max(0, Number(usage.mainCacheWriteTokens ?? usage.cacheWriteTokens) || 0);
+    const explicitPrompt = Math.max(0, Number(usage.mainPromptTokens ?? usage.promptTokens) || 0);
     const normalizedPrompt = providerInputExcludesCache(sessionRef?.provider)
         ? input + cachedRead + cacheWrite
         : input;
     const prompt = Math.max(explicitPrompt, normalizedPrompt);
-    const output = Math.max(0, Number(usage.outputTokens) || 0);
+    const output = Math.max(0, Number(usage.mainOutputTokens ?? usage.outputTokens) || 0);
     return Math.max(0, Math.round(prompt + output));
 }
 
@@ -213,10 +203,14 @@ export function recordProviderContextBaseline(sessionRef, messages, usage, {
     sendTools = sessionRef?.tools,
 } = {}) {
     if (!sessionRef || !Array.isArray(messages)) return false;
+    if (usage?.mainUsageAvailable === false) {
+        invalidateProviderContextBaseline(sessionRef);
+        return false;
+    }
     const tokens = providerPressureTokens(sessionRef, usage);
     if (!tokens) return false;
     sessionRef.contextPressureBaselineTokens = tokens;
-    sessionRef.contextPressureBaselineOutputTokens = Math.max(0, Math.round(Number(usage?.outputTokens) || 0));
+    sessionRef.contextPressureBaselineOutputTokens = Math.max(0, Math.round(Number(usage?.mainOutputTokens ?? usage?.outputTokens) || 0));
     sessionRef.contextPressureBaselineMessageCount = messages.length;
     sessionRef.contextPressureBaselinePrefixSignature = contextMessagesSignature(messages);
     sessionRef.contextPressureBaselineProvider = sessionRef.provider || null;

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

@@ -37,6 +37,7 @@ import {
     _touchRuntime,
     _unlinkParentAbortListener,
     _getRuntimeEntry,
+    _evictTerminalSessionRuntime,
 } from './runtime-liveness.mjs';
 import { SessionClosedError } from './session-errors.mjs';
 import { acquireSessionLock } from './session-lock.mjs';
@@ -378,11 +379,12 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                         // tool results/steering.
                         if (d?.source === 'provider_send') {
                             recordProviderContextBaseline(session, outgoing, {
-                                inputTokens: d.deltaInput,
-                                outputTokens: d.deltaOutput,
-                                promptTokens: d.deltaPrompt,
-                                cachedTokens: d.deltaCachedRead,
-                                cacheWriteTokens: d.deltaCacheWrite,
+                                mainUsageAvailable: d.contextUsageAvailable,
+                                inputTokens: d.contextInputTokens ?? d.deltaInput,
+                                outputTokens: d.contextOutputTokens ?? d.deltaOutput,
+                                promptTokens: d.contextPromptTokens ?? d.deltaPrompt,
+                                cachedTokens: d.contextCachedReadTokens ?? d.deltaCachedRead,
+                                cacheWriteTokens: d.contextCacheWriteTokens ?? d.deltaCacheWrite,
                             }, { boundary: 'request', sendTools: d.sendTools });
                         }
                         try { askOpts?.onUsageDelta?.(d); } catch {}
@@ -747,6 +749,11 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // Detach the live session reference; ask is over.
             entry.session = null;
         }
+        // Final-stage runtime diagnostics are useful only while the turn is
+        // unwinding. Once its controller is detached, retaining the full entry
+        // (and any accidental references hanging from it) for the host lifetime
+        // turns one-shot agent traffic into an unbounded manager Map.
+        _evictTerminalSessionRuntime(sessionId);
         unlock();
     }
 }

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

@@ -4,7 +4,12 @@
 // from session-close.mjs (one-way dependency, no cycle).
 import { sweepStaleSessions } from '../store.mjs';
 import { sweepOrphanedPendingMessages } from './pending-messages.mjs';
-import { _getRuntimeEntry, _clearSessionRuntime, _runtimeEntries } from './runtime-liveness.mjs';
+import {
+    _getRuntimeEntry,
+    _clearSessionRuntime,
+    _runtimeEntries,
+    _sweepTerminalSessionRuntimes,
+} from './runtime-liveness.mjs';
 import { _closeBashSessionLazy } from './runtime-loaders.mjs';
 import { closeSession } from './session-close.mjs';
 import { nonNegativeIntEnv } from './env-utils.mjs';
@@ -36,10 +41,11 @@ function _previewIds(items, limit = 5) {
     return ` (${ids.join(', ')}${more})`;
 }
 
-function sweepIdleSessions({ includeTombstones = true } = {}) {
+function sweepIdleSessions({ includeTombstones = true, sweepIdle = true } = {}) {
     const startedAt = Date.now();
     try {
         const result = sweepStaleSessions({
+            sweepIdle,
             tombstoneMaxAgeMs: includeTombstones ? TOMBSTONE_MAX_AGE_MS : 0,
             isSessionLive: _isSessionLive,
         });
@@ -71,7 +77,7 @@ function sweepIdleSessions({ includeTombstones = true } = {}) {
         }
         if (tombstonesCleaned > 0) {
             for (const d of tombstoneDetails) {
-                if (d?.id) _clearSessionRuntime(d.id);
+                if (d?.id && !_isSessionLive(d.id)) _clearSessionRuntime(d.id);
             }
             process.stderr.write(`[session-sweep] unlinked ${tombstonesCleaned} tombstone(s)${_previewIds(tombstoneDetails)}\n`);
         }
@@ -105,9 +111,10 @@ export function sweepTombstones() {
         const { tombstonesCleaned = 0, tombstoneDetails = [], tombstoneErrors = [] } = sweepStaleSessions({
             sweepIdle: false,
             tombstoneMaxAgeMs: TOMBSTONE_MAX_AGE_MS,
+            isSessionLive: _isSessionLive,
         });
         for (const d of tombstoneDetails) {
-            if (d?.id) _clearSessionRuntime(d.id);
+            if (d?.id && !_isSessionLive(d.id)) _clearSessionRuntime(d.id);
         }
         if (tombstonesCleaned > 0) {
             process.stderr.write(`[session-sweep] unlinked ${tombstonesCleaned} tombstone(s)${_previewIds(tombstoneDetails)}\n`);
@@ -133,7 +140,16 @@ function hasActiveRuntimeWork() {
 }
 
 function _runCleanupCycle() {
-    if (hasActiveRuntimeWork()) return;
+    // 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();
+    // A busy host may always have some unrelated agent in flight. Tombstones
+    // are already closed and can still be batch-reclaimed safely; only the
+    // open-session idle sweep remains gated while active work exists.
+    if (hasActiveRuntimeWork()) {
+        sweepIdleSessions({ includeTombstones: true, sweepIdle: false });
+        return;
+    }
     sweepOrphanedPendingMessages();
     sweepIdleSessions({ includeTombstones: true });
 }

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

@@ -1,48 +1,12 @@
 // 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';
+// supplied files[]/callers[]/references[] prefetch outside the agent loop.
 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;
@@ -85,12 +49,6 @@ export async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
         }
     }
     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.
@@ -183,7 +141,6 @@ export async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
             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') : [];
@@ -193,11 +150,6 @@ export async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
             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 => {
@@ -207,8 +159,7 @@ export async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
         });
         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; }
+            const { symbol, out } = r.status === 'fulfilled' ? r.value : { symbol: '?', out: null };
             if (out && classifyResultKind(String(out)) !== 'error') {
                 parts.push(`### prefetch callers ${symbol}\n${out}`);
             } else {
@@ -224,11 +175,6 @@ export async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
             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 => {
@@ -238,8 +184,7 @@ export async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
         });
         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; }
+            const { symbol, out } = r.status === 'fulfilled' ? r.value : { symbol: '?', out: null };
             if (out && classifyResultKind(String(out)) !== 'error') {
                 parts.push(`### prefetch references ${symbol}\n${out}`);
             } else {

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

@@ -34,6 +34,7 @@ const _toolActivityHeartbeats = new Map();
 const VALID_STAGES = new Set([
     'connecting', 'requesting', 'streaming', 'tool_running', 'idle', 'error', 'done', 'cancelling',
 ]);
+const TERMINAL_STAGES = new Set(['done', 'error']);
 
 // Injected deps that would otherwise pull manager.mjs's store/provider surface
 // back into this module (circular). Wired once from manager.mjs at load time.
@@ -502,6 +503,29 @@ export function _clearSessionRuntime(id) {
     }
 }
 
+/**
+ * Evict a settled terminal runtime entry without ever touching an in-flight
+ * controller. askSession calls this after detaching its controller; the
+ * periodic cleanup also uses it to drain any backlog left by older paths.
+ */
+export function _evictTerminalSessionRuntime(id) {
+    if (!id) return false;
+    const entry = _runtimeState.get(id);
+    if (!entry) return false;
+    if (entry.controller && !entry.controller.signal?.aborted) return false;
+    if (entry.closed !== true && !TERMINAL_STAGES.has(entry.stage)) return false;
+    _clearSessionRuntime(id);
+    return true;
+}
+
+export function _sweepTerminalSessionRuntimes() {
+    let cleaned = 0;
+    for (const [id] of _runtimeState) {
+        if (_evictTerminalSessionRuntime(id)) cleaned++;
+    }
+    return cleaned;
+}
+
 // Direct-Map accessors for manager.mjs internals (askSession / closeSession /
 // idle-sweep) that mutate entries in place. Kept as thin exports so the Map
 // stays private to this module.

package/src/runtime/agent/orchestrator/session/manager/usage-metrics.mjs

@@ -258,11 +258,22 @@ export function applyAskTerminalUsageTotals(session, result, options = {}) {
         session.totalUncachedInputTokens = (session.totalUncachedInputTokens || 0) + uncachedInputTokens;
     }
     const _lastTurn = result.lastTurnUsage || result.usage || {};
-    const _lastInputTokens = _lastTurn.inputTokens || 0;
-    const _lastCachedReadTokens = _lastTurn.cachedTokens || 0;
-    const _lastCacheWriteTokens = _lastTurn.cacheWriteTokens || 0;
+    if (_lastTurn.mainUsageAvailable === false) {
+        session.lastInputTokens = null;
+        session.lastOutputTokens = null;
+        session.lastCachedReadTokens = null;
+        session.lastCacheWriteTokens = null;
+        session.lastUncachedInputTokens = null;
+        session.lastContextTokens = null;
+        session.lastContextTokensUpdatedAt = Date.now();
+        session.lastContextTokensStaleAfterCompact = true;
+        return;
+    }
+    const _lastInputTokens = _lastTurn.mainInputTokens ?? _lastTurn.inputTokens ?? 0;
+    const _lastCachedReadTokens = _lastTurn.mainCachedTokens ?? _lastTurn.cachedTokens ?? 0;
+    const _lastCacheWriteTokens = _lastTurn.mainCacheWriteTokens ?? _lastTurn.cacheWriteTokens ?? 0;
     session.lastInputTokens = _lastInputTokens;
-    session.lastOutputTokens = _lastTurn.outputTokens || 0;
+    session.lastOutputTokens = _lastTurn.mainOutputTokens ?? _lastTurn.outputTokens ?? 0;
     session.lastCachedReadTokens = _lastCachedReadTokens;
     session.lastCacheWriteTokens = _lastCacheWriteTokens;
     session.lastUncachedInputTokens = uncachedInputTokensForProvider(
@@ -286,7 +297,20 @@ export function applyAskTerminalUsageTotals(session, result, options = {}) {
  */
 export async function persistIterationMetrics(delta) {
     if (!delta || !delta.sessionId) return;
-    const { sessionId, iterationIndex, deltaInput, deltaOutput, deltaCachedRead, deltaCacheWrite, ts } = delta;
+    const {
+        sessionId,
+        iterationIndex,
+        deltaInput,
+        deltaOutput,
+        deltaCachedRead,
+        deltaCacheWrite,
+        contextInputTokens = deltaInput,
+        contextOutputTokens = deltaOutput,
+        contextCachedReadTokens = deltaCachedRead,
+        contextCacheWriteTokens = deltaCacheWrite,
+        contextUsageAvailable = true,
+        ts,
+    } = delta;
     const runtimeEntry = _getRuntimeEntry(sessionId);
     const session = runtimeEntry?.session ?? loadSession(sessionId);
     if (!session || session.closed) return;
@@ -320,23 +344,40 @@ export async function persistIterationMetrics(delta) {
         // Window snapshot updated per iteration so agent type=list reflects the
         // most-recent provider-reported input size even for short dispatches
         // that finish before askSession's terminal save lands.
-        session.lastInputTokens = deltaInput || 0;
-        session.lastOutputTokens = deltaOutput || 0;
-        session.lastCachedReadTokens = deltaCachedRead || 0;
-        session.lastCacheWriteTokens = deltaCacheWrite || 0;
-        session.lastUncachedInputTokens = deltaUncachedInput;
+        if (contextUsageAvailable === false) {
+            session.lastInputTokens = null;
+            session.lastOutputTokens = null;
+            session.lastCachedReadTokens = null;
+            session.lastCacheWriteTokens = null;
+            session.lastUncachedInputTokens = null;
+            session.lastContextTokens = null;
+            session.lastContextTokensUpdatedAt = ts || Date.now();
+            session.lastContextTokensStaleAfterCompact = true;
+        } else {
+            const contextUncachedInput = uncachedInputTokensForProvider(
+                session.provider,
+                contextInputTokens,
+                contextCachedReadTokens,
+                contextCacheWriteTokens,
+            );
+            session.lastInputTokens = contextInputTokens || 0;
+            session.lastOutputTokens = contextOutputTokens || 0;
+            session.lastCachedReadTokens = contextCachedReadTokens || 0;
+            session.lastCacheWriteTokens = contextCacheWriteTokens || 0;
+            session.lastUncachedInputTokens = contextUncachedInput;
         // Normalized last-call context footprint: how many prompt tokens the
         // model actually saw on the most-recent send, comparable ACROSS
         // providers. Anthropic reports input_tokens EXCLUDING cache (cache_read
         // is a separate field), so the cached portion must be added back to
         // reflect real context size; openai/grok/gemini already fold cached
         // tokens INTO the input count, so input alone is the footprint.
-        const _inputExcludesCache = providerInputExcludesCache(session.provider);
-        session.lastContextTokens = _inputExcludesCache
-            ? (deltaInput || 0) + (deltaCachedRead || 0) + (deltaCacheWrite || 0)
-            : (deltaInput || 0);
-        session.lastContextTokensUpdatedAt = ts || Date.now();
-        session.lastContextTokensStaleAfterCompact = false;
+            const _inputExcludesCache = providerInputExcludesCache(session.provider);
+            session.lastContextTokens = _inputExcludesCache
+                ? (contextInputTokens || 0) + (contextCachedReadTokens || 0) + (contextCacheWriteTokens || 0)
+                : (contextInputTokens || 0);
+            session.lastContextTokensUpdatedAt = ts || Date.now();
+            session.lastContextTokensStaleAfterCompact = false;
+        }
     }
     session.lastIterationIndex = iterationIndex;
     session.updatedAt = ts || Date.now();

package/src/runtime/agent/orchestrator/session/save-session-worker.mjs

@@ -10,8 +10,8 @@ import { _saveSessionSync } from './store.mjs';
 
 parentPort.on('message', ({ session, opts, reqId }) => {
     try {
-        _saveSessionSync(session, opts);
-        parentPort.postMessage({ ok: true, reqId });
+        const saved = _saveSessionSync(session, opts);
+        parentPort.postMessage({ ok: true, saved, reqId });
     } catch (err) {
         parentPort.postMessage({ ok: false, error: err?.message ?? String(err), reqId });
     }

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

@@ -13,9 +13,15 @@ import { isOutputLimitStopReason } from './loop/termination.mjs';
 
 function normalizedIncompleteUsage(raw) {
     if (!raw || typeof raw !== 'object') return undefined;
-    const inputTokens = Number(raw.promptTokenCount ?? raw.prompt_token_count ?? raw.input_tokens ?? raw.prompt_tokens ?? 0) || 0;
+    const directInputTokens = Number(raw.promptTokenCount ?? raw.prompt_token_count ?? raw.input_tokens ?? raw.prompt_tokens ?? 0) || 0;
     const candidateTokens = Number(raw.candidatesTokenCount ?? raw.candidates_token_count ?? 0) || 0;
     const thoughtTokens = Number(raw.thoughtsTokenCount ?? raw.thoughts_token_count ?? 0) || 0;
+    const totalTokens = Number(raw.totalTokenCount ?? raw.total_token_count ?? 0) || 0;
+    const hasExplicitGeminiPromptTokens = Object.prototype.hasOwnProperty.call(raw, 'promptTokenCount')
+        || Object.prototype.hasOwnProperty.call(raw, 'prompt_token_count');
+    const inputTokens = hasExplicitGeminiPromptTokens || directInputTokens > 0
+        ? directInputTokens
+        : Math.max(0, totalTokens - candidateTokens - thoughtTokens);
     const outputFallback = Number(raw.output_tokens ?? raw.completion_tokens ?? 0) || 0;
     const cachedTokens = Number(raw.cachedContentTokenCount ?? raw.cached_content_token_count ?? raw.cached_tokens ?? 0) || 0;
     return {

package/src/runtime/agent/orchestrator/session/store/paths-heartbeat.mjs

@@ -0,0 +1,52 @@
+import { existsSync, mkdirSync, unlinkSync } from 'fs';
+import * as fsp from 'fs/promises';
+import { join } from 'path';
+import { getPluginData } from '../../config.mjs';
+
+export function getStoreDir() {
+    const dir = join(getPluginData(), 'sessions');
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    return dir;
+}
+export function sessionPath(id) {
+    // Enforce minted session-id shape before using it in a path to prevent
+    // `../` traversal. session IDs are generated by createSession as
+    // `sess_<timestamp>_<hex>` — reject anything that doesn't match.
+    if (!id || typeof id !== 'string' || !/^[A-Za-z0-9_-]+$/.test(id)) {
+        throw new Error(`[session-store] invalid session id: ${JSON.stringify(id)}`);
+    }
+    return join(getStoreDir(), `${id}.json`);
+}
+
+// ── Heartbeat publish ─────────────────────────────────────
+// Lightweight per-session timestamp file (`<id>.hb`) consumed by the
+// status aggregator for fresh-session detection. Decoupled from the
+// full session JSON save so it can fire at a tight cadence (≤5s)
+// without serialising the whole payload. The .hb file holds a single
+// ASCII line: `<msTimestamp>\n`. Aggregator scans the same sessions/
+// directory and matches `<id>.hb` to `<id>.json`.
+const _HEARTBEAT_THROTTLE_MS = 5_000;
+const _hbLastAt = new Map();
+
+function _heartbeatPath(id) {
+    if (!id || typeof id !== 'string' || !/^[A-Za-z0-9_-]+$/.test(id)) {
+        throw new Error(`[session-store] invalid session id: ${JSON.stringify(id)}`);
+    }
+    return join(getStoreDir(), `${id}.hb`);
+}
+
+export function publishHeartbeat(id, ts) {
+    if (!id) return;
+    const now = ts || Date.now();
+    const last = _hbLastAt.get(id) || 0;
+    if (now - last < _HEARTBEAT_THROTTLE_MS) return;
+    const target = _heartbeatPath(id);
+    _hbLastAt.set(id, now);
+    void fsp.writeFile(target, `${now}\n`, 'utf8').catch(() => {});
+}
+
+export function deleteHeartbeat(id) {
+    try { unlinkSync(_heartbeatPath(id)); } catch { /* ignore */ }
+    _hbLastAt.delete(id);
+}

package/src/runtime/agent/orchestrator/session/store/write-guards.mjs

@@ -0,0 +1,62 @@
+/** Module-level map tracking per-session cancellation generations and commit locks. */
+const _writeControls = new Map();
+
+export function writeControl(id) {
+    let control = _writeControls.get(id);
+    if (!control) {
+        // [0] cancellation generation, [1] commit lock
+        control = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 2));
+        _writeControls.set(id, control);
+    }
+    return control;
+}
+
+export function guardedSaveOptions(id, opts) {
+    const control = writeControl(id);
+    return {
+        ...(opts || {}),
+        _sessionWriteGuard: { buffer: control.buffer, version: Atomics.load(control, 0) },
+    };
+}
+
+export function cancelSessionWrites(id) {
+    Atomics.add(writeControl(id), 0, 1);
+}
+
+export function isCancelledWrite(opts) {
+    const guard = opts?._sessionWriteGuard;
+    if (!guard?.buffer || !Number.isInteger(guard.version)) return false;
+    try {
+        return Atomics.load(new Int32Array(guard.buffer), 0) !== guard.version;
+    } catch {
+        return true;
+    }
+}
+
+export function acquireWriteCommit(opts) {
+    const guard = opts?._sessionWriteGuard;
+    if (!guard?.buffer) return null;
+    const control = new Int32Array(guard.buffer);
+    while (Atomics.compareExchange(control, 1, 0, 1) !== 0) {
+        Atomics.wait(control, 1, 1, 25);
+    }
+    if (isCancelledWrite(opts)) {
+        Atomics.store(control, 1, 0);
+        Atomics.notify(control, 1);
+        return false;
+    }
+    return control;
+}
+
+export function releaseWriteCommit(control) {
+    if (!control) return;
+    Atomics.store(control, 1, 0);
+    Atomics.notify(control, 1);
+}
+
+export function waitForWriteCommit(id) {
+    const control = writeControl(id);
+    while (Atomics.load(control, 1) !== 0) {
+        Atomics.wait(control, 1, 1, 25);
+    }
+}