mixdog 0.9.151 → 0.9.153

package/src/runtime/agent/orchestrator/session/store-summary-reader.mjs

@@ -14,6 +14,11 @@ import { join } from 'path';
 // authoritative store uses, so the cold catalog cannot disagree with it.
 import { probePath, readTextFile, PROBE_PRESENT, PROBE_ABSENT } from './store/fs-probe.mjs';
 import { readTopLevelLifecycleRecord, isLifecycleUnreadable } from './lifecycle-scan.mjs';
+import {
+    isAgentOnlySession,
+    isRootLeadSession,
+    sessionVisibility,
+} from './store-summary-visibility.mjs';
 
 const SESSION_SUMMARY_INDEX_VERSION = 2;
 const DEAD_AGENT_STATUS =
@@ -45,7 +50,8 @@ const LEAD_OWNERS = new Set(['cli', 'user', 'mixdog']);
 
 function isLeadVisibleRow(row) {
     const owner = String(row.owner || 'user').trim().toLowerCase();
-    if (owner && !LEAD_OWNERS.has(owner)) return false;
+    if (isAgentOnlySession(row)) return false;
+    if (!isRootLeadSession(row) && owner && !LEAD_OWNERS.has(owner)) return false;
     // Mirror listLeadSessions: a previewless zero-message row is an unusable
     // scratch (desktop boot leftovers, crashed first turns) — resuming it
     // shows an empty conversation, so the catalog hides it.
@@ -72,10 +78,35 @@ function positiveNumber(value, fallback = 0) {
     return Number.isFinite(number) && number > 0 ? number : fallback;
 }
 
+function runtimeAlive(pid) {
+    const id = positiveNumber(pid, 0);
+    if (id <= 0 || id === process.pid) return true;
+    try {
+        process.kill(id, 0);
+        return true;
+    } catch (error) {
+        return error?.code === 'EPERM';
+    }
+}
+
 function cleanValue(value) {
     return String(value || '').trim();
 }
 
+function workerOwnerSessionId(row, session) {
+    return cleanValue(
+        row?.ownerSessionId || session?.ownerSessionId
+        || row?.parentSessionId || session?.parentSessionId,
+    ) || null;
+}
+
+function workerParentSessionId(row, session) {
+    return cleanValue(
+        row?.parentSessionId || session?.parentSessionId
+        || row?.ownerSessionId || session?.ownerSessionId,
+    ) || null;
+}
+
 function archivedAgentNotification(content, sessionId) {
     const text = typeof content === 'string' ? content : '';
     const marker = '\n\nResult:\n';
@@ -265,23 +296,52 @@ export function storedLeadWorkerIndexPath() {
     return join(dataDir(), 'lead-workers.json');
 }
 
-/** Process-global active agent pool. Fresh child heartbeat sidecars are the
- * cross-process running source even when their durable session is detached
- * (`closed`) and a terminal reaper has already removed the worker-index row.
- * The child and Lead indexes remain additive for living rows (running or idle)
- * published before the heartbeat or by runtimes without a sidecar. No runtime
- * starts and durable session history is never projected into either pool. */
-export function listStoredAgentWorkers() {
+function storedAgentWorkerIndexRows() {
     let parsed = null;
     try {
         parsed = JSON.parse(readFileSync(storedAgentWorkerIndexPath(), 'utf8'));
-    } catch { /* heartbeat-backed rows remain authoritative without the index */ }
-    const source = Array.isArray(parsed?.workers)
+    } catch {
+        return [];
+    }
+    return Array.isArray(parsed?.workers)
         ? parsed.workers
         : parsed?.workers && typeof parsed.workers === 'object'
             ? Object.values(parsed.workers)
             : [];
+}
+
+/** Lightweight ancestry seam used to migrate pre-parentSessionId summary
+ * rows. It reads only agent-workers.json and never opens session transcripts. */
+export function listStoredAgentWorkerLinks() {
+    return storedAgentWorkerIndexRows()
+        .map((row) => {
+            if (!row || typeof row !== 'object') return null;
+            const sessionId = cleanValue(row.sessionId);
+            const parentSessionId = cleanValue(row.parentSessionId);
+            const ownerSessionId = cleanValue(row.ownerSessionId || row.parentSessionId);
+            if (!/^[A-Za-z0-9_-]+$/.test(sessionId) || (!parentSessionId && !ownerSessionId)) {
+                return null;
+            }
+            return {
+                sessionId,
+                parentSessionId: parentSessionId || ownerSessionId,
+                ownerSessionId: ownerSessionId || parentSessionId,
+            };
+        })
+        .filter(Boolean);
+}
+
+/** Process-global active agent pool. Fresh child heartbeat sidecars are the
+ * cross-process running source even when their durable session is detached
+ * (`closed`) and a terminal reaper has already removed the worker-index row.
+ * The child and Lead indexes remain additive for living rows (running or idle)
+ * published before the heartbeat or by runtimes without a sidecar. No runtime
+ * starts and durable session history is never projected into either pool. */
+export function listStoredAgentWorkers() {
+    const source = storedAgentWorkerIndexRows();
     const bySessionId = new Map();
+    const now = Date.now();
+    const heartbeatMtimes = sessionHeartbeatMtimes();
     for (const row of source) {
         if (!row || typeof row !== 'object') continue;
         // Cancelled rows stay visible so the 2-minute heartbeat lease cannot
@@ -300,28 +360,45 @@ export function listStoredAgentWorkers() {
                 'utf8',
             ));
         } catch { /* a new row may precede its first session save */ }
+        const declaredStatus = cleanValue(row.status) || 'running';
+        const declaredStage = cleanValue(row.stage || row.status) || 'running';
+        const declaredWorking = WORKING_AGENT_STATUS.test(declaredStatus)
+            || WORKING_AGENT_STATUS.test(declaredStage);
+        const heartbeatAt = heartbeatMtimes.get(sessionId) || 0;
+        const heartbeatFresh = heartbeatAt > 0
+            && now - heartbeatAt <= AGENT_POOL_HEARTBEAT_FRESH_MS;
+        const updatedAt = Date.parse(cleanValue(row.updatedAt)) || 0;
+        const recentlyUpdated = updatedAt > 0
+            && now - updatedAt <= AGENT_POOL_HEARTBEAT_FRESH_MS;
+        const runtimePid = positiveNumber(row.runtimePid, 0);
+        const working = declaredWorking
+            && (!runtimePid || runtimeAlive(runtimePid))
+            && (heartbeatFresh || recentlyUpdated);
+        const projectedStatus = declaredWorking && !working ? 'idle' : declaredStatus;
+        const projectedStage = declaredWorking && !working ? 'idle' : declaredStage;
         bySessionId.set(sessionId, {
             tag,
             sessionId,
-            ownerSessionId: cleanValue(
-                row.ownerSessionId || row.parentSessionId
-                || session?.ownerSessionId || session?.parentSessionId,
-            ) || null,
+            // Root ownership and immediate ancestry are independent. Nested
+            // descendants keep the Lead/root owner while pointing at the Agent
+            // session that directly spawned them.
+            ownerSessionId: workerOwnerSessionId(row, session),
+            parentSessionId: workerParentSessionId(row, session),
             title: cleanValue(row.title || session?.title) || null,
             agent: cleanValue(row.agent || session?.agent) || null,
             provider: cleanValue(row.provider || session?.provider) || null,
             model: cleanValue(row.model || session?.model) || null,
             effort: cleanValue(row.effort || session?.effort) || null,
             fast: row.fast === true || session?.fast === true,
-            status: cleanValue(row.status) || 'running',
-            stage: cleanValue(row.stage || row.status) || 'running',
+            status: projectedStatus,
+            stage: projectedStage,
             startedAt: row.startedAt || row.createdAt || session?.createdAt || null,
-            turnStartedAt: row.turnStartedAt || null,
+            turnStartedAt: working ? (row.turnStartedAt || null) : null,
             createdAt: row.createdAt || session?.createdAt || null,
             updatedAt: row.updatedAt || session?.updatedAt || null,
             idleSince: frozenIdleSince(
                 sessionId,
-                WORKING_AGENT_STATUS.test(cleanValue(row.stage || row.status)),
+                working,
                 row.finishedAt || row.updatedAt || session?.updatedAt || null,
             ),
             reapAt: row.reapAt || null,
@@ -330,8 +407,6 @@ export function listStoredAgentWorkers() {
             taskId: cleanValue(row.task_id || row.taskId) || null,
         });
     }
-    const now = Date.now();
-    const heartbeatMtimes = sessionHeartbeatMtimes();
     for (const [sessionId, heartbeatAt] of heartbeatMtimes) {
         if (now - heartbeatAt > AGENT_POOL_HEARTBEAT_FRESH_MS) continue;
         let session;
@@ -343,13 +418,12 @@ export function listStoredAgentWorkers() {
         } catch {
             continue;
         }
-        const ownerSessionId = cleanValue(
-            session?.ownerSessionId || session?.parentSessionId,
-        );
+        const current = bySessionId.get(sessionId) || {};
+        const ownerSessionId = workerOwnerSessionId(current, session);
+        const parentSessionId = workerParentSessionId(current, session);
         const owner = cleanValue(session?.owner).toLowerCase();
         const agent = cleanValue(session?.agent);
         if (!ownerSessionId || (owner !== 'agent' && (!agent || agent === 'lead'))) continue;
-        const current = bySessionId.get(sessionId) || {};
         // The durable index row is authoritative for FINISHED work: a worker's
         // runtime unloads at turn end but its heartbeat sidecar stays fresh for
         // up to the 2-minute window, and overwriting an idle row to `running`
@@ -381,6 +455,7 @@ export function listStoredAgentWorkers() {
                     || `${agent || 'agent'}:${sessionId}`,
                 sessionId,
                 ownerSessionId,
+                parentSessionId,
                 title: cleanValue(session?.title) || current.title || null,
                 agent: agent || current.agent || null,
                 provider: cleanValue(session?.provider) || current.provider || null,
@@ -409,6 +484,7 @@ export function listStoredAgentWorkers() {
                 || `${agent || 'agent'}:${sessionId}`,
             sessionId,
             ownerSessionId,
+            parentSessionId,
             title: cleanValue(session?.title) || current.title || null,
             agent: agent || current.agent || null,
             provider: cleanValue(session?.provider) || current.provider || null,
@@ -467,6 +543,7 @@ export function listStoredAgentWorkers() {
             tag: `lead:${sessionId}`,
             sessionId,
             ownerSessionId: sessionId,
+            parentSessionId: null,
             agent: 'lead',
             provider: cleanValue(row.provider) || null,
             model: cleanValue(row.model) || null,
@@ -548,7 +625,8 @@ function normalizedRow(row, heartbeatAt = 0) {
         sourceName: row.sourceName || null,
         sourceDelivery: row.sourceDelivery || null,
         scopeKey: row.scopeKey || null,
-        ownerSessionId: row.ownerSessionId || null,
+        ownerSessionId: row.ownerSessionId || row.parentSessionId || null,
+        visibility: sessionVisibility(row),
         clientHostPid: positiveNumber(row.clientHostPid, 0) || null,
         cwd: row.cwd || '',
         desktopSession: desktopSession(row.desktopSession, row.cwd),
@@ -761,11 +839,47 @@ export async function readStoredSessionTranscript(id, options = {}) {
     // Same strict authority as the store, and the same fail-closed rule: an
     // absent, unreadable, ambiguous or foreign record yields no transcript.
     const read = readTextFile(join(dataDir(), 'sessions', `${sessionId}.json`));
-    if (read.state === PROBE_ABSENT) return readArchivedAgentResult(sessionId);
+    if (read.state === PROBE_ABSENT) {
+        return options.metadataOnly === true ? null : readArchivedAgentResult(sessionId);
+    }
     if (read.state !== PROBE_PRESENT) return null;
     const record = readTopLevelLifecycleRecord(read.text);
     if (isLifecycleUnreadable(record) || record.id !== sessionId) return null;
     let session = record.doc;
+    if (options.metadataOnly === true) {
+        return {
+            id: sessionId,
+            sessionId,
+            owner: session.owner || null,
+            agent: session.agent || null,
+            parentSessionId: session.parentSessionId || null,
+            ownerSessionId: session.ownerSessionId || session.parentSessionId || null,
+            visibility: sessionVisibility(session),
+            agentTag: session.agentTag || null,
+            cwd: session.cwd || '',
+            provider: session.provider || null,
+            model: session.model || null,
+            presetName: session.presetName || session.profileId || null,
+            effort: session.effort || null,
+            fast: session.fast === true,
+            modelParameters: session.modelParameters || null,
+            taskType: session.taskType || null,
+            maxLoopIterations: session.maxLoopIterations ?? null,
+            permission: session.permission || null,
+            permissionMode: session.permissionMode || null,
+            toolPermission: session.toolPermission || null,
+            schemaAllowedTools: Array.isArray(session.schemaAllowedTools)
+                ? session.schemaAllowedTools
+                : null,
+            sourceType: session.sourceType || null,
+            sourceName: session.sourceName || null,
+            clientHostPid: session.clientHostPid || null,
+            createdAt: session.createdAt || null,
+            updatedAt: session.updatedAt || session.lastUsedAt || null,
+            status: session.status || (session.closed === true ? 'closed' : 'idle'),
+            closed: session.closed === true,
+        };
+    }
     const owner = cleanValue(session.owner).toLowerCase();
     const agent = cleanValue(session.agent).toLowerCase();
     const liveDetachedAgent = session.closed === true
@@ -774,11 +888,11 @@ export async function readStoredSessionTranscript(id, options = {}) {
     // Only a PROVABLY absent checkpoint skips recovery: an unreadable probe
     // must not silently downgrade an interrupted turn to a plain cold read.
     if (probePath(join(dataDir(), 'turn-checkpoints', `${sessionId}.json`)).state !== PROBE_ABSENT) {
+        const {
+            projectTurnCheckpointMessages,
+            readTurnCheckpoint,
+        } = await import('./manager/turn-checkpoint.mjs');
         if (liveDetachedAgent) {
-            const {
-                projectTurnCheckpointMessages,
-                readTurnCheckpoint,
-            } = await import('./manager/turn-checkpoint.mjs');
             const checkpoint = readTurnCheckpoint(sessionId);
             if (checkpoint) {
                 session = {
@@ -789,6 +903,19 @@ export async function readStoredSessionTranscript(id, options = {}) {
         } else {
             const { recoverSessionAfterProcessRestart } = await import('./manager.mjs');
             session = recoverSessionAfterProcessRestart(sessionId) || session;
+            // A live foreign owner is intentionally not recovered/mutated.
+            // Project its durable working checkpoint read-only so the cold pane
+            // never repaints the stale pre-compaction session.messages while it
+            // waits for the owner's live-share frame.
+            if (session?.activeTurnCheckpoint) {
+                const checkpoint = readTurnCheckpoint(sessionId);
+                if (checkpoint) {
+                    session = {
+                        ...session,
+                        messages: projectTurnCheckpointMessages(session, checkpoint),
+                    };
+                }
+            }
         }
     }
     const {

package/src/runtime/agent/orchestrator/session/store-summary-reader.test.mjs

@@ -581,3 +581,67 @@ test('cancel-unconfirmed stays distinguishable from a confirmed cancel under a f
     assert.notEqual(row?.status, 'cancelled');
   });
 });
+
+test('stored Agent pool preserves root ownership and immediate nested parent links', () => {
+  withAgentPoolRoot('mixdog-agent-pool-nested-', (root) => {
+    writeAgentChild(root, 'child-direct', {
+      ownerSessionId: 'root-lead',
+      parentSessionId: 'root-lead',
+      tag: 'direct',
+    });
+    writeAgentChild(root, 'grandchild', {
+      ownerSessionId: 'root-lead',
+      parentSessionId: 'child-direct',
+      tag: 'nested',
+      closed: true,
+      status: 'closed',
+      stage: 'closed',
+    });
+    writeFileSync(join(root, 'sessions', 'root-lead.json'), JSON.stringify({
+      id: 'root-lead',
+      owner: 'user',
+      ownerSessionId: 'root-lead',
+      agent: 'lead',
+      status: 'idle',
+      messages: [{ role: 'user', content: 'root task' }],
+    }));
+    writeAgentWorkerIndex(root, {
+      direct: {
+        tag: 'direct',
+        sessionId: 'child-direct',
+        ownerSessionId: 'root-lead',
+        parentSessionId: 'root-lead',
+        agent: 'reviewer',
+        status: 'idle',
+        stage: 'idle',
+      },
+    });
+    writeFileSync(join(root, 'lead-workers.json'), JSON.stringify({
+      workers: {
+        root: {
+          sessionId: 'root-lead',
+          ownerSessionId: 'root-lead',
+          agent: 'lead',
+          status: 'idle',
+          stage: 'idle',
+          updatedAt: new Date().toISOString(),
+          reapAt: new Date(Date.now() + 60_000).toISOString(),
+        },
+      },
+    }));
+    // No worker-index row: the heartbeat/session fallback must carry the same
+    // production ancestry shape for a live nested descendant.
+    writeFreshHeartbeat(root, 'grandchild');
+
+    const rows = listStoredAgentWorkers();
+    const rootLead = rows.find((row) => row.sessionId === 'root-lead');
+    const direct = rows.find((row) => row.sessionId === 'child-direct');
+    const nested = rows.find((row) => row.sessionId === 'grandchild');
+    assert.equal(rootLead?.ownerSessionId, 'root-lead');
+    assert.equal(rootLead?.parentSessionId, null);
+    assert.equal(direct?.ownerSessionId, 'root-lead');
+    assert.equal(direct?.parentSessionId, 'root-lead');
+    assert.equal(nested?.ownerSessionId, 'root-lead');
+    assert.equal(nested?.parentSessionId, 'child-direct');
+  });
+});

package/src/runtime/agent/orchestrator/session/store-summary-visibility.mjs

@@ -0,0 +1,57 @@
+export const SESSION_VISIBILITY_ORDINARY = 'ordinary';
+export const SESSION_VISIBILITY_AGENT_ONLY = 'agent-only';
+
+const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+
+function clean(value) {
+    return String(value || '').trim();
+}
+
+export function linkedParentSessionId(value) {
+    if (!value || typeof value !== 'object') return '';
+    for (const candidate of [value.ownerSessionId, value.parentSessionId]) {
+        const id = clean(candidate);
+        if (SESSION_ID_PATTERN.test(id)) return id;
+    }
+    return '';
+}
+
+/** A root Lead may carry a self owner link, but it is not a child session. */
+export function isRootLeadSession(value) {
+    if (!value || typeof value !== 'object') return false;
+    if (clean(value.agent).toLowerCase() !== 'lead') return false;
+    const id = clean(value.id);
+    const parentId = linkedParentSessionId(value);
+    return !parentId || parentId === id;
+}
+
+/** Backward-compatible classification for child records written before the
+ * durable visibility field existed. Both Agent ownership and an external,
+ * valid parent link are required so ownerless/root sessions remain ordinary. */
+export function isCanonicalAgentChildSession(value) {
+    if (!value || typeof value !== 'object') return false;
+    const id = clean(value.id);
+    const parentId = linkedParentSessionId(value);
+    return clean(value.owner).toLowerCase() === 'agent'
+        && Boolean(parentId)
+        && parentId !== id;
+}
+
+export function sessionVisibility(value) {
+    // Root Lead sessions are ordinary catalog entries even if stale metadata
+    // accidentally retained an agent-only declaration.
+    if (isRootLeadSession(value)) return SESSION_VISIBILITY_ORDINARY;
+    const declared = clean(value?.visibility || value?.sessionVisibility).toLowerCase();
+    if (declared === SESSION_VISIBILITY_AGENT_ONLY || isCanonicalAgentChildSession(value)) {
+        return SESSION_VISIBILITY_AGENT_ONLY;
+    }
+    return SESSION_VISIBILITY_ORDINARY;
+}
+
+export function isAgentOnlySession(value) {
+    return sessionVisibility(value) === SESSION_VISIBILITY_AGENT_ONLY;
+}
+
+export function isOrdinarySession(value) {
+    return !isAgentOnlySession(value);
+}

package/src/runtime/agent/orchestrator/session/store-summary-visibility.test.mjs

@@ -0,0 +1,219 @@
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import {
+    _normalizeSummaryIndex,
+    _sessionSummary,
+} from './store-summary-index.mjs';
+import {
+    listStoredAgentWorkerLinks,
+    listStoredAgentWorkers,
+    listStoredSessionSummaries as listOrdinarySummaries,
+    readStoredSessionTranscript,
+    storedSessionExists,
+} from './store-summary-reader.mjs';
+import {
+    listStoredSessions,
+    listStoredSessionSummaries as listInternalSummaries,
+} from './store/listing.mjs';
+
+function session(id, extra = {}) {
+    return {
+        id,
+        createdAt: 1_000,
+        updatedAt: 2_000,
+        lastUsedAt: 2_000,
+        status: 'idle',
+        owner: 'user',
+        messages: [{ role: 'user', content: `prompt for ${id}` }],
+        ...extra,
+    };
+}
+
+test('summary visibility is durable and classifies legacy Agent-owned children', () => {
+    const legacy = session('legacy-child', {
+        owner: 'agent',
+        parentSessionId: 'root-lead',
+        agent: 'reviewer',
+    });
+    const summary = _sessionSummary(legacy);
+    assert.equal(summary.ownerSessionId, 'root-lead');
+    assert.equal(summary.visibility, 'agent-only');
+
+    const [normalized] = _normalizeSummaryIndex({
+        version: 2,
+        rows: [{
+            ...summary,
+            visibility: undefined,
+            ownerSessionId: 'root-lead',
+        }],
+    }).rows;
+    assert.equal(normalized.visibility, 'agent-only');
+
+    const nested = _sessionSummary(session('nested-child', {
+        owner: 'agent',
+        parentSessionId: 'parent-child',
+        ownerSessionId: 'root-lead',
+        agent: 'reviewer',
+        visibility: 'agent-only',
+        provider: 'test-provider',
+        model: 'test-model',
+        presetName: 'Test route',
+        effort: 'high',
+        fast: true,
+        modelParameters: { temperature: 0.2 },
+        permissionMode: 'strict',
+        schemaAllowedTools: ['read', 'grep'],
+        taskType: 'review',
+        maxLoopIterations: 7,
+    }));
+    const [normalizedNested] = _normalizeSummaryIndex({
+        version: 2,
+        rows: [nested],
+    }).rows;
+    assert.equal(normalizedNested.parentSessionId, 'parent-child');
+    assert.equal(normalizedNested.ownerSessionId, 'root-lead');
+    assert.equal(normalizedNested.presetName, 'Test route');
+    assert.equal(normalizedNested.effort, 'high');
+    assert.equal(normalizedNested.fast, true);
+    assert.deepEqual(normalizedNested.modelParameters, { temperature: 0.2 });
+    assert.equal(normalizedNested.permissionMode, 'strict');
+    assert.deepEqual(normalizedNested.schemaAllowedTools, ['read', 'grep']);
+    assert.equal(normalizedNested.taskType, 'review');
+    assert.equal(normalizedNested.maxLoopIterations, 7);
+
+    const rootLead = _sessionSummary(session('root-lead', {
+        owner: 'agent',
+        ownerSessionId: 'root-lead',
+        agent: 'lead',
+        visibility: 'agent-only',
+    }));
+    assert.equal(rootLead.visibility, 'ordinary');
+});
+
+test('ordinary catalogs hide durable and legacy children while Agent and exact-ID discovery remain available', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'mixdog-agent-only-catalog-'));
+    const previous = process.env.MIXDOG_DATA_DIR;
+    process.env.MIXDOG_DATA_DIR = root;
+    try {
+        const sessionsDir = join(root, 'sessions');
+        mkdirSync(sessionsDir);
+        const records = [
+            session('root-lead', {
+                owner: 'agent',
+                ownerSessionId: 'root-lead',
+                agent: 'lead',
+                sourceType: 'lead',
+            }),
+            session('ordinary-user'),
+            session('declared-child', {
+                ownerSessionId: 'root-lead',
+                agent: 'reviewer',
+                visibility: 'agent-only',
+            }),
+            session('legacy-child', {
+                owner: 'agent',
+                parentSessionId: 'root-lead',
+                agent: 'reviewer',
+                agentTag: 'review',
+                closed: true,
+                status: 'closed',
+            }),
+        ];
+        for (const record of records) {
+            writeFileSync(
+                join(sessionsDir, `${record.id}.json`),
+                JSON.stringify(record),
+            );
+        }
+
+        const indexRows = records.map((record) => _sessionSummary(record));
+        delete indexRows.find((row) => row.id === 'legacy-child').visibility;
+        writeFileSync(join(root, 'session-summaries.json'), JSON.stringify({
+            version: 2,
+            updatedAt: Date.now(),
+            rows: indexRows,
+        }));
+        writeFileSync(join(root, 'agent-workers.json'), JSON.stringify({
+            workers: {
+                review: {
+                    tag: 'review',
+                    sessionId: 'legacy-child',
+                    parentSessionId: 'root-lead',
+                    ownerSessionId: 'root-lead',
+                    agent: 'reviewer',
+                    status: 'idle',
+                    stage: 'idle',
+                },
+            },
+        }));
+
+        const expectedOrdinaryIds = ['ordinary-user', 'root-lead'];
+        assert.deepEqual(
+            listOrdinarySummaries({ rebuildIfMissing: false })
+                .map((row) => row.id)
+                .sort(),
+            expectedOrdinaryIds,
+        );
+        assert.deepEqual(
+            listOrdinarySummaries({ refreshFromStorage: true })
+                .map((row) => row.id)
+                .sort(),
+            expectedOrdinaryIds,
+        );
+        assert.deepEqual(
+            listStoredSessions().map((row) => row.id).sort(),
+            expectedOrdinaryIds,
+        );
+        assert.deepEqual(
+            listStoredSessions({ includeAgentOnly: true }).map((row) => row.id).sort(),
+            records.map((row) => row.id).sort(),
+        );
+
+        const internal = listInternalSummaries({ refreshFromStorage: true });
+        assert.deepEqual(
+            internal.map((row) => row.id).sort(),
+            records.map((row) => row.id).sort(),
+        );
+        assert.equal(
+            internal.find((row) => row.id === 'declared-child')?.visibility,
+            'agent-only',
+        );
+        assert.equal(
+            internal.find((row) => row.id === 'legacy-child')?.visibility,
+            'agent-only',
+        );
+        const durableIndex = JSON.parse(readFileSync(
+            join(root, 'session-summaries.json'),
+            'utf8',
+        ));
+        assert.equal(
+            durableIndex.rows.find((row) => row.id === 'legacy-child')?.visibility,
+            'agent-only',
+        );
+
+        assert.equal(
+            listStoredAgentWorkers().some((row) => row.sessionId === 'legacy-child'),
+            true,
+        );
+        assert.deepEqual(listStoredAgentWorkerLinks(), [{
+            sessionId: 'legacy-child',
+            parentSessionId: 'root-lead',
+            ownerSessionId: 'root-lead',
+        }]);
+        assert.equal(storedSessionExists('legacy-child'), true);
+        const metadata = await readStoredSessionTranscript('legacy-child', { metadataOnly: true });
+        assert.equal(metadata?.parentSessionId, 'root-lead');
+        assert.equal(Object.hasOwn(metadata || {}, 'items'), false);
+        const exact = await readStoredSessionTranscript('legacy-child');
+        assert.equal(exact?.sessionId, 'legacy-child');
+        assert.equal(exact?.readOnlyDetachedAgent, true);
+    } finally {
+        if (previous === undefined) delete process.env.MIXDOG_DATA_DIR;
+        else process.env.MIXDOG_DATA_DIR = previous;
+        rmSync(root, { recursive: true, force: true });
+    }
+});