mixdog 0.8.0 → 0.9.0

package/src/runtime/agent/orchestrator/session/manager.reactive-persist.test.mjs

@@ -0,0 +1,107 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+    _applyCompactFailurePersistToSession,
+    _sessionMessagesAdvancedBeyondCompactedOutgoing,
+} from './manager.mjs';
+
+const compacted = [
+    { role: 'user', content: 'summary turn' },
+    { role: 'user', content: 'current task' },
+];
+
+test('sessionMessagesAdvancedBeyondCompactedOutgoing: true for compacted prefix plus final assistant', () => {
+    const current = [
+        ...compacted,
+        { role: 'assistant', content: 'done' },
+    ];
+    assert.equal(_sessionMessagesAdvancedBeyondCompactedOutgoing(current, compacted), true);
+});
+
+test('sessionMessagesAdvancedBeyondCompactedOutgoing: true for compacted prefix plus empty-final assistant', () => {
+    const current = [
+        ...compacted,
+        { role: 'assistant', content: '', emptyFinal: true },
+    ];
+    assert.equal(_sessionMessagesAdvancedBeyondCompactedOutgoing(current, compacted), true);
+});
+
+test('sessionMessagesAdvancedBeyondCompactedOutgoing: false when transcript has not advanced', () => {
+    assert.equal(_sessionMessagesAdvancedBeyondCompactedOutgoing(compacted, compacted), false);
+});
+
+test('sessionMessagesAdvancedBeyondCompactedOutgoing: false when extra message is not a final assistant', () => {
+    const current = [
+        ...compacted,
+        { role: 'user', content: 'steering follow-up' },
+    ];
+    assert.equal(_sessionMessagesAdvancedBeyondCompactedOutgoing(current, compacted), false);
+});
+
+test('sessionMessagesAdvancedBeyondCompactedOutgoing: false when prefix diverges from compacted outgoing', () => {
+    const current = [
+        { role: 'user', content: 'different summary' },
+        { role: 'user', content: 'current task' },
+        { role: 'assistant', content: 'done' },
+    ];
+    assert.equal(_sessionMessagesAdvancedBeyondCompactedOutgoing(current, compacted), false);
+});
+
+test('applyCompactFailurePersistToSession: preserves providerState when transcript already advanced', () => {
+    const priorSanitized = [
+        ...compacted,
+        { role: 'assistant', content: 'done' },
+    ];
+    const session = {
+        messages: priorSanitized,
+        providerState: { continuation: 'fresh' },
+        compaction: { lastStage: 'compacting' },
+    };
+    const applied = _applyCompactFailurePersistToSession(session, {
+        priorSanitized,
+        sanitized: compacted,
+        messagesAdvanced: true,
+        error: new Error('ask failed'),
+    });
+    assert.equal(applied, true);
+    assert.deepEqual(session.messages, priorSanitized);
+    assert.deepEqual(session.providerState, { continuation: 'fresh' });
+    assert.equal(session.compaction.lastStage, 'failed');
+});
+
+test('applyCompactFailurePersistToSession: clears providerState when replacing messages with compacted outgoing', () => {
+    const priorSanitized = [
+        { role: 'user', content: 'old long history' },
+    ];
+    const session = {
+        messages: priorSanitized,
+        providerState: { stale: true },
+        compaction: { lastStage: 'compacting' },
+    };
+    const applied = _applyCompactFailurePersistToSession(session, {
+        priorSanitized,
+        sanitized: compacted,
+        messagesAdvanced: false,
+        error: { code: 'AGENT_CONTEXT_OVERFLOW' },
+    });
+    assert.equal(applied, true);
+    assert.deepEqual(session.messages, compacted);
+    assert.equal(session.providerState, undefined);
+    assert.equal(session.compaction.lastStage, 'overflow_failed');
+});
+
+test('applyCompactFailurePersistToSession: no-op when messages unchanged and not advanced', () => {
+    const session = {
+        messages: compacted,
+        providerState: { keep: true },
+    };
+    const applied = _applyCompactFailurePersistToSession(session, {
+        priorSanitized: compacted,
+        sanitized: compacted,
+        messagesAdvanced: false,
+    });
+    assert.equal(applied, false);
+    assert.deepEqual(session.providerState, { keep: true });
+});
+

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

@@ -9,9 +9,48 @@ 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 { isAgentOwner } from '../agent-owner.mjs';
+import { renameWithRetrySync, updateJsonAtomicSync, writeJsonAtomicSync } from '../../../shared/atomic-file.mjs';
+import { sanitizeContentForStoredHistory } from '../providers/media-normalization.mjs';
 
 const _lastSaveError = new Map(); // id -> { message, at }
+const SESSION_SUMMARY_INDEX_VERSION = 1;
+
+// The live in-memory session (and every model request)
+// retains attached image bytes across turns so multi-turn recognition works.
+// The persisted session JSON, however, replaces image content with a short
+// text placeholder at serialization time — keeping session files small without
+// starving the model of the image mid-conversation. Returns the same object
+// reference when nothing changed (no-image sessions pay only a shallow scan).
+function _sessionForDisk(session) {
+    // Strip the in-flight live-turn alias (askSession sets session.liveTurnMessages
+    // for the turn duration so contextStatus() can estimate live context growth).
+    // It is a transient duplicate of the working transcript and must never be
+    // serialized: mid-turn saves (persistIterationMetrics) would otherwise bloat
+    // the session file and persist a non-canonical message array.
+    const hasLiveTurn = session && typeof session === 'object'
+        && Object.prototype.hasOwnProperty.call(session, 'liveTurnMessages');
+    const messages = Array.isArray(session?.messages) ? session.messages : null;
+    if (!messages || messages.length === 0) {
+        if (!hasLiveTurn) return session;
+        const { liveTurnMessages: _drop, ...rest } = session;
+        return rest;
+    }
+    let changed = false;
+    const out = messages.map((m) => {
+        if (!m || typeof m !== 'object') return m;
+        const content = sanitizeContentForStoredHistory(m.content);
+        if (content !== m.content) { changed = true; return { ...m, content }; }
+        return m;
+    });
+    if (!changed) {
+        if (!hasLiveTurn) return session;
+        const { liveTurnMessages: _drop, ...rest } = session;
+        return rest;
+    }
+    const { liveTurnMessages: _drop, ...rest } = session;
+    return { ...rest, messages: out };
+}
 
 function _renameWithRetrySync(tmp, target) {
     return renameWithRetrySync(tmp, target);
@@ -32,6 +71,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 +88,176 @@ 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;
+    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,
+        agentTag: session.agentTag || 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,
+        agentTag: row.agentTag || 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();
 
@@ -101,19 +315,6 @@ function _clearDebounce(id) {
     if (t) { clearTimeout(t); _debounceTimers.delete(id); }
 }
 
-// Flush all debounced sessions synchronously on process exit / SIGTERM.
-// This prevents losing the last turn's tool-result writes.
-function _drainAllDebounced() {
-    for (const [id, t] of _debounceTimers) {
-        clearTimeout(t);
-        _debounceTimers.delete(id);
-        const cur = _savePending.get(id);
-        if (cur && cur.debouncing && cur.payload) {
-            try { _doSaveSync(cur.payload); } catch { /* best-effort */ }
-            _savePending.delete(id);
-        }
-    }
-}
 // Self-registered exit drain; bare 'exit' hook stays as idempotent backup. Use the more comprehensive
 // drainSessionStore so debounce + scheduled + writing payloads all flush.
 process.on('exit', drainSessionStore);
@@ -291,12 +492,13 @@ function _doSaveSync(payload) {
     const target = sessionPath(id);
     const tmp = target + '.' + randomBytes(6).toString('hex') + '.tmp';
     try {
-        writeFileSync(tmp, JSON.stringify(session), 'utf-8');
+        writeFileSync(tmp, JSON.stringify(_sessionForDisk(session)), 'utf-8');
         if (_shouldDrop(id, opts)) {
             try { unlinkSync(tmp); } catch { /* ignore cleanup failure */ }
             return;
         }
         _renameWithRetrySync(tmp, target);
+        _upsertSessionSummary(session);
     } catch (err) {
         try { unlinkSync(tmp); } catch { /* ignore cleanup failure */ }
         throw err;
@@ -312,7 +514,21 @@ function _shouldDrop(id, opts) {
     const target = sessionPath(id);
     if (!existsSync(target)) return false;
     try {
-        const onDisk = JSON.parse(readFileSync(target, 'utf-8'));
+        const raw = readFileSync(target, 'utf-8');
+        // Tombstone check only needs `closed` and `generation`. Avoid a full
+        // JSON.parse of the entire session (which can be MBs on long chats and
+        // ran on every save). Fast-path a regex scan; only fall back to a full
+        // parse if the lightweight scan is inconclusive.
+        const closedMatch = /"closed"\s*:\s*(true|false)/.exec(raw);
+        if (closedMatch && closedMatch[1] === 'false') return false;
+        if (closedMatch && closedMatch[1] === 'true') {
+            const genMatch = /"generation"\s*:\s*(-?\d+)/.exec(raw);
+            const diskGen = genMatch ? Number(genMatch[1]) : 0;
+            return diskGen >= expected;
+        }
+        // No `closed` key found by scan — not a tombstone, so nothing to drop.
+        if (!closedMatch && !/"closed"/.test(raw)) return false;
+        const onDisk = JSON.parse(raw);
         const diskGen = typeof onDisk.generation === 'number' ? onDisk.generation : 0;
         return onDisk.closed === true && diskGen >= expected;
     } catch {
@@ -379,7 +595,7 @@ async function _doSave(payload) {
     const target = sessionPath(id);
     const tmp = target + '.' + randomBytes(6).toString('hex') + '.tmp';
     try {
-        await fsp.writeFile(tmp, JSON.stringify(session), 'utf-8');
+        await fsp.writeFile(tmp, JSON.stringify(_sessionForDisk(session)), 'utf-8');
         // Second check: between the temp write and the rename, closeSession()
         // may have planted a tombstone. Re-check on disk; if a newer tombstone
         // now exists, discard our temp file rather than let rename clobber it.
@@ -390,6 +606,7 @@ async function _doSave(payload) {
             return;
         }
         _renameWithRetrySync(tmp, target);
+        _upsertSessionSummary(session);
     } catch (err) {
         try { unlinkSync(tmp); } catch { /* ignore cleanup failure */ }
         _savePending.delete(id);
@@ -417,7 +634,7 @@ export function markSessionClosed(id, reason = 'manual') {
     const target = sessionPath(id);
     const tmp = target + '.' + randomBytes(6).toString('hex') + '.tmp';
     try {
-        writeFileSync(tmp, JSON.stringify(tombstone), 'utf-8');
+        writeFileSync(tmp, JSON.stringify(_sessionForDisk(tombstone)), 'utf-8');
         _renameWithRetrySync(tmp, target);
     } catch {
         try { unlinkSync(tmp); } catch { /* ignore */ }
@@ -426,6 +643,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,14 +706,15 @@ 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
-// Completed bridge agents (idle/done/error) live until terminal reap — must
+// Completed agents (idle/done/error) live until terminal reap - must
 // match TERMINAL_REAP_MS / _scheduleBridgeReap (3_600_000) in index.mjs and
-// bridge-stall-watchdog.mjs so the store sweep is the durable 1h reaper.
-const BRIDGE_TERMINAL_TTL_MS = 60 * 60 * 1000;
-const BRIDGE_TERMINAL_STATUSES = new Set(['idle', 'done', 'error']);
+// agent stall watchdog, so the store sweep is the durable 1h reaper.
+const AGENT_TERMINAL_TTL_MS = 60 * 60 * 1000;
+const AGENT_TERMINAL_STATUSES = new Set(['idle', 'done', 'error']);
 // Hard wall-clock ceiling for sessions stuck in status='running'. The
 // stream-watchdog should abort stalled streams within ~120s, but if it misses
 // one (process crash, watchdog not started, provider never returned), this
@@ -518,6 +737,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 +793,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 +801,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;
                         }
@@ -600,9 +845,9 @@ export function sweepStaleSessions(ttlMs, options = {}) {
                 remaining++;
                 continue;
             }
-            // Sweep bridge-owned and ownerless (legacy) sessions; skip explicit
+            // Sweep agent-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 && !isAgentOwner(row)) {
                 remaining++;
                 continue;
             }
@@ -613,30 +858,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 sessionMaxAge = isCompletedBridge ? BRIDGE_TERMINAL_TTL_MS : maxAge;
+            const isCompletedAgent = isAgentOwner(row)
+                && AGENT_TERMINAL_STATUSES.has(row.status);
+            const sessionMaxAge = isCompletedAgent ? AGENT_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/session/tool-result-offload.mjs

@@ -12,7 +12,7 @@ const TOOL_RESULT_SEARCH_THRESHOLD_CHARS = 50_000;
 const TOOL_RESULT_GREP_THRESHOLD_CHARS = 20_000;
 export const TOOL_RESULT_OFFLOAD_PREFIX = '[tool output offloaded:';
 
-// Per-tool persistence limits mirror Claude Code's per-tool maxResultSizeChars
+// Per-tool persistence limits mirror reference per-tool maxResultSizeChars
 // rather than a single global value: Grep persists at 20k (CC GrepTool), Glob
 // and list/find_* at the 50k system default (CC DEFAULT_MAX_RESULT_SIZE_CHARS;
 // tighter than CC Glob's 100k by design), and shell/bash_session/task at 30k
@@ -127,7 +127,7 @@ export async function maybeOffloadToolResult(sessionId, toolCallId, toolName, re
 // tool-results/<sessionId>/*.txt entry, rmdirs the directory, and drops
 // the sessionId entry from the module-level counter Map so a long-running
 // mcp-server process doesn't accumulate per-session state across the
-// lifetime of the bridge.
+// lifetime of the agent runtime.
 export async function clearOffloadSession(sessionId) {
     if (!sessionId) return;
     _offloadCounters.delete(sessionId);