mixdog 0.9.63 → 0.9.65

package/scripts/desktop-session-bridge-test.mjs

@@ -1,1013 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { execFileSync } from 'node:child_process';
-
-import {
-  SESSION_SUMMARY_INDEX_VERSION,
-  _normalizeSummaryIndex,
-  _sessionSummary,
-} from '../src/runtime/agent/orchestrator/session/store-summary-index.mjs';
-import {
-  listStoredSessionSummaries as listLightweightSessionSummaries,
-} from '../src/runtime/agent/orchestrator/session/store-summary-reader.mjs';
-import { createLifecycleApi, resolveResumeCwd } from '../src/session-runtime/lifecycle-api.mjs';
-import { createCwdPlugins } from '../src/session-runtime/cwd-plugins.mjs';
-import {
-  normalizeDesktopSessionMetadata,
-  resumeSession as resumeStoredSession,
-} from '../src/runtime/agent/orchestrator/session/manager/session-lifecycle.mjs';
-import {
-  drainSessionStore,
-  deleteSession,
-  loadSession,
-  listStoredSessionSummaries,
-  markSessionClosed,
-  saveSession,
-  saveSessionAsync,
-  saveSessionAsyncDeferred,
-  setLiveSession,
-} from '../src/runtime/agent/orchestrator/session/store.mjs';
-
-test('deferred terminal save is registered for immediate exit drain', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-deferred-terminal-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = root;
-  try {
-    const session = {
-      id: 'deferred_terminal_exit',
-      owner: 'user',
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-      messages: [{ role: 'assistant', content: 'terminal state' }],
-    };
-    const pending = saveSessionAsyncDeferred(session);
-    drainSessionStore();
-    await pending;
-    assert.equal(loadSession(session.id)?.messages?.[0]?.content, 'terminal state');
-  } finally {
-    drainSessionStore();
-    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('exit drain writes deferred terminal state after an older worker-pending save', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-deferred-order-'));
-  try {
-    const storeUrl = new URL('../src/runtime/agent/orchestrator/session/store.mjs', import.meta.url).href;
-    const output = execFileSync(process.execPath, ['--input-type=module', '-e', `
-      process.env.MIXDOG_DATA_DIR = ${JSON.stringify(root)};
-      const { saveSessionAsync, saveSessionAsyncDeferred, drainSessionStore, loadSession } = await import(${JSON.stringify(storeUrl)});
-      const base = { id: 'deferred_order_exit', owner: 'user', createdAt: Date.now(), updatedAt: Date.now() };
-      saveSessionAsync({ ...base, messages: [{ role: 'assistant', content: 'older worker snapshot' }], padding: 'x'.repeat(2_000_000) }).catch(() => {});
-      const terminal = saveSessionAsyncDeferred({ ...base, updatedAt: Date.now() + 1, messages: [{ role: 'assistant', content: 'newest terminal snapshot' }] });
-      drainSessionStore();
-      await Promise.allSettled([terminal]);
-      process.stdout.write(loadSession(base.id)?.messages?.[0]?.content || '');
-      process.exit(0);
-    `], { encoding: 'utf8' });
-    assert.equal(output, 'newest terminal snapshot');
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('desktop classification is optional and round-trips through the existing summary index', () => {
-  const task = _sessionSummary({
-    id: 'lead_task',
-    owner: 'cli',
-    agent: 'lead',
-    cwd: '/app/workspace',
-    desktopSession: { classification: 'task', projectPath: null },
-  });
-  const project = _normalizeSummaryIndex({
-    rows: [{
-      id: 'lead_project',
-      cwd: '/project',
-      desktopSession: { classification: 'project', projectPath: '/project' },
-    }],
-  }).rows[0];
-  const legacy = _normalizeSummaryIndex({ rows: [{ id: 'legacy', cwd: '/old' }] }).rows[0];
-  const malformed = _normalizeSummaryIndex({
-    rows: [{ id: 'malformed', desktopSession: { classification: 'worker' } }],
-  }).rows[0];
-
-  assert.deepEqual(task.desktopSession, { classification: 'task', projectPath: null });
-  assert.deepEqual(project.desktopSession, { classification: 'project', projectPath: '/project' });
-  assert.equal(legacy.desktopSession, null);
-  assert.equal(malformed.desktopSession, null);
-});
-
-test('cold summary reader loads the sidecar without importing the full store', () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-cold-summary-reader-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = root;
-  try {
-    writeFileSync(join(root, 'session-summaries.json'), JSON.stringify({
-      version: SESSION_SUMMARY_INDEX_VERSION,
-      rows: [{
-        id: 'cold_reader',
-        updatedAt: 10,
-        cwd: '/workspace',
-        preview: 'Cold reader session',
-        desktopSession: { classification: 'task', projectPath: null },
-      }],
-    }));
-    assert.deepEqual(listLightweightSessionSummaries().map((row) => row.id), ['cold_reader']);
-  } finally {
-    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('loadSession reuses a parsed session until the atomic file identity changes', () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-session-load-cache-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = root;
-  try {
-    const sessions = join(root, 'sessions');
-    mkdirSync(sessions, { recursive: true });
-    const target = join(sessions, 'cached_parse.json');
-    writeFileSync(target, JSON.stringify({
-      id: 'cached_parse',
-      messages: [{ role: 'user', content: 'first version' }],
-    }));
-    const first = loadSession('cached_parse');
-    const second = loadSession('cached_parse');
-    assert.equal(second, first);
-    writeFileSync(target, JSON.stringify({
-      id: 'cached_parse',
-      messages: [{ role: 'user', content: 'changed version with a different size' }],
-    }));
-    const changed = loadSession('cached_parse');
-    assert.notEqual(changed, first);
-    assert.equal(changed.messages[0].content, 'changed version with a different size');
-  } finally {
-    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('session summaries use the first real user request and remove injected display blocks', () => {
-  const summary = _sessionSummary({
-    id: 'clean_title_source',
-    owner: 'user',
-    messages: [
-      { role: 'user', content: '<system-reminder>runtime bootstrap</system-reminder>' },
-      {
-        role: 'user',
-        content: 'A previous model worked on this task and produced the compacted handoff summary below. Build on it.',
-      },
-      {
-        role: 'user',
-        content: 'Reference files: [Image #1] <mcp-instructions>internal tools</mcp-instructions> Align the project dropdown',
-      },
-      { role: 'user', content: 'The async agent task task_agent completed with internal output.' },
-      { role: 'user', content: 'A later follow-up must not replace the stable title source' },
-    ],
-  });
-
-  assert.equal(summary.preview, 'Align the project dropdown');
-});
-
-test('authoritative summary refresh repairs a stale index and skips malformed session files', () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-desktop-summary-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = root;
-  try {
-    const sessions = join(root, 'sessions');
-    mkdirSync(sessions, { recursive: true });
-    writeFileSync(join(root, 'session-summaries.json'), JSON.stringify({
-      version: 1,
-      rows: [{
-        id: 'desktop_old',
-        updatedAt: 1,
-        cwd: '/old',
-        desktopSession: { classification: 'task', projectPath: null },
-      }],
-    }));
-    writeFileSync(join(sessions, 'desktop_new.json'), JSON.stringify({
-      id: 'desktop_new',
-      owner: 'user',
-      agent: 'lead',
-      updatedAt: 20,
-      cwd: '/app/workspace',
-      desktopSession: { classification: 'task', projectPath: null },
-      messages: [{ role: 'user', content: 'Newly persisted desktop task' }],
-    }));
-    writeFileSync(join(sessions, 'cli_only.json'), JSON.stringify({
-      id: 'cli_only',
-      owner: 'user',
-      updatedAt: 10,
-      cwd: '/cli',
-      messages: [{ role: 'user', content: 'CLI only' }],
-    }));
-    writeFileSync(join(sessions, 'broken.json'), '{"id":');
-
-    const rows = listStoredSessionSummaries({ refreshFromStorage: true });
-    assert.deepEqual(rows.map((row) => row.id), ['desktop_new', 'cli_only']);
-    assert.deepEqual(
-      rows.find((row) => row.id === 'desktop_new').desktopSession,
-      { classification: 'task', projectPath: null },
-    );
-    assert.equal(rows.find((row) => row.id === 'cli_only').desktopSession, null);
-    const repaired = JSON.parse(readFileSync(join(root, 'session-summaries.json'), 'utf8'));
-    assert.deepEqual(repaired.rows.map((row) => row.id), ['desktop_new', 'cli_only']);
-  } finally {
-    drainSessionStore();
-    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    rmSync(root, { recursive: true, force: true, maxRetries: 8, retryDelay: 25 });
-  }
-});
-
-test('cached summaries reflect local lifecycle mutations and forced refresh reconciles disk', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-summary-cache-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = root;
-  try {
-    const sessions = join(root, 'sessions');
-    mkdirSync(sessions, { recursive: true });
-    writeFileSync(join(sessions, 'indexed.json'), JSON.stringify({
-      id: 'indexed', owner: 'user', updatedAt: 10, messages: [],
-    }));
-    writeFileSync(join(root, 'session-summaries.json'), JSON.stringify({
-      version: 1, rows: [{ id: 'indexed', owner: 'user', updatedAt: 10 }],
-    }));
-
-    assert.deepEqual(listStoredSessionSummaries().map((row) => row.id), ['indexed']);
-    assert.equal(
-      JSON.parse(readFileSync(join(root, 'session-summaries.json'), 'utf8')).version,
-      SESSION_SUMMARY_INDEX_VERSION,
-    );
-
-    saveSession({
-      id: 'cached_new', owner: 'user', updatedAt: 20,
-      messages: [{ role: 'user', content: 'Cached local session' }],
-    }, { sync: true });
-    assert.deepEqual(
-      listStoredSessionSummaries().map((row) => row.id),
-      ['cached_new', 'indexed'],
-    );
-
-    await saveSessionAsync({
-      id: 'cached_async', owner: 'user', updatedAt: 25,
-      messages: [{ role: 'user', content: 'Cached async session' }],
-    });
-    assert.equal(listStoredSessionSummaries().some((row) => row.id === 'cached_async'), true);
-    assert.equal(deleteSession('cached_async'), true);
-
-    assert.notEqual(markSessionClosed('cached_new', 'test'), null);
-    assert.equal(
-      listStoredSessionSummaries().find((row) => row.id === 'cached_new').closed,
-      true,
-    );
-    assert.equal(deleteSession('cached_new'), true);
-    assert.equal(listStoredSessionSummaries().some((row) => row.id === 'cached_new'), false);
-
-    writeFileSync(join(sessions, 'external.json'), JSON.stringify({
-      id: 'external', owner: 'user', updatedAt: 30, messages: [],
-    }));
-    assert.equal(listStoredSessionSummaries().some((row) => row.id === 'external'), false);
-    assert.deepEqual(
-      listStoredSessionSummaries({ refreshFromStorage: true }).map((row) => row.id),
-      ['external', 'indexed'],
-    );
-    unlinkSync(join(sessions, 'external.json'));
-    assert.deepEqual(
-      listStoredSessionSummaries({ refreshFromStorage: true }).map((row) => row.id),
-      ['indexed'],
-    );
-  } finally {
-    drainSessionStore();
-    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    rmSync(root, { recursive: true, force: true, maxRetries: 8, retryDelay: 25 });
-  }
-});
-
-test('authoritative refresh trusts disk over stale live state while preserving unsettled local writes', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-summary-races-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = root;
-  try {
-    const sessions = join(root, 'sessions');
-    mkdirSync(sessions, { recursive: true });
-    writeFileSync(join(sessions, 'authoritative.json'), JSON.stringify({
-      id: 'authoritative',
-      owner: 'user',
-      closed: true,
-      status: 'closed',
-      updatedAt: 40,
-      desktopSession: { classification: 'project', projectPath: '/disk-project' },
-      messages: [],
-    }));
-    setLiveSession({
-      id: 'authoritative',
-      owner: 'agent:stale',
-      closed: false,
-      updatedAt: 99,
-      desktopSession: { classification: 'task', projectPath: null },
-      messages: [],
-    });
-    let rows = listStoredSessionSummaries({ refreshFromStorage: true });
-    const authoritative = rows.find((row) => row.id === 'authoritative');
-    assert.equal(authoritative.closed, true);
-    assert.equal(authoritative.owner, 'user');
-    assert.deepEqual(authoritative.desktopSession, { classification: 'project', projectPath: '/disk-project' });
-
-    unlinkSync(join(sessions, 'authoritative.json'));
-    assert.equal(
-      listStoredSessionSummaries({ refreshFromStorage: true }).some((row) => row.id === 'authoritative'),
-      false,
-    );
-
-    saveSession({
-      id: 'pending_desktop',
-      owner: 'user',
-      updatedAt: 50,
-      desktopSession: { classification: 'task', projectPath: null },
-      messages: [{ role: 'user', content: 'Visible before debounce flush' }],
-    });
-    assert.equal(existsSync(join(sessions, 'pending_desktop.json')), false);
-    rows = listStoredSessionSummaries({ refreshFromStorage: true });
-    assert.equal(rows.some((row) => row.id === 'pending_desktop'), true);
-    assert.equal(listStoredSessionSummaries().some((row) => row.id === 'pending_desktop'), true);
-    assert.equal(deleteSession('pending_desktop'), false);
-    await new Promise((resolve) => setTimeout(resolve, 225));
-    assert.equal(existsSync(join(sessions, 'pending_desktop.json')), false);
-    assert.equal(
-      listStoredSessionSummaries({ refreshFromStorage: true }).some((row) => row.id === 'pending_desktop'),
-      false,
-    );
-
-    const first = saveSessionAsync({
-      id: 'worker_deleted',
-      owner: 'user',
-      updatedAt: 60,
-      messages: [{ role: 'user', content: 'First queued worker write' }],
-    });
-    const second = saveSessionAsync({
-      id: 'worker_deleted',
-      owner: 'user',
-      updatedAt: 61,
-      messages: [{ role: 'user', content: 'Latest queued worker write' }],
-    });
-    deleteSession('worker_deleted');
-    await Promise.all([first, second]);
-    await new Promise((resolve) => setTimeout(resolve, 25));
-    assert.equal(existsSync(join(sessions, 'worker_deleted.json')), false);
-    assert.equal(
-      listStoredSessionSummaries({ refreshFromStorage: true }).some((row) => row.id === 'worker_deleted'),
-      false,
-    );
-  } finally {
-    drainSessionStore();
-    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    rmSync(root, { recursive: true, force: true, maxRetries: 8, retryDelay: 25 });
-  }
-});
-
-test('authoritative refresh rejects filename and embedded session id mismatches', () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-desktop-identity-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = root;
-  try {
-    const sessions = join(root, 'sessions');
-    mkdirSync(sessions, { recursive: true });
-    writeFileSync(join(sessions, 'cli_transcript.json'), JSON.stringify({
-      id: 'cli_transcript',
-      owner: 'user',
-      updatedAt: 10,
-      messages: [{ role: 'user', content: 'Legitimate CLI transcript' }],
-    }));
-    // Without filename/id validation this duplicate row could lend desktop
-    // metadata to cli_transcript, then resume the legitimate CLI-owned file.
-    writeFileSync(join(sessions, 'desktop_spoof.json'), JSON.stringify({
-      id: 'cli_transcript',
-      owner: 'user',
-      updatedAt: 30,
-      desktopSession: { classification: 'task', projectPath: null },
-      messages: [{ role: 'user', content: 'Spoofed desktop authorization' }],
-    }));
-    writeFileSync(join(sessions, 'desktop_good.json'), JSON.stringify({
-      id: 'desktop_good',
-      owner: 'user',
-      updatedAt: 20,
-      desktopSession: { classification: 'task', projectPath: null },
-      messages: [{ role: 'user', content: 'Legitimate desktop task' }],
-    }));
-    writeFileSync(join(sessions, 'duplicate_copy.json'), JSON.stringify({
-      id: 'desktop_good',
-      owner: 'user',
-      updatedAt: 40,
-      desktopSession: { classification: 'task', projectPath: null },
-      messages: [{ role: 'user', content: 'Mismatched duplicate' }],
-    }));
-
-    const rows = listStoredSessionSummaries({ refreshFromStorage: true });
-    assert.deepEqual(rows.map((row) => row.id), ['desktop_good', 'cli_transcript']);
-    assert.equal(rows.find((row) => row.id === 'desktop_good').preview, 'Legitimate desktop task');
-    assert.equal(rows.find((row) => row.id === 'cli_transcript').desktopSession, null);
-    assert.equal(loadSession('cli_transcript').messages[0].content, 'Legitimate CLI transcript');
-    assert.equal(loadSession('desktop_spoof'), null);
-    assert.equal(loadSession('duplicate_copy'), null);
-  } finally {
-    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('authoritative refresh fails closed when the session directory is unreadable', () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-desktop-unreadable-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = root;
-  try {
-    writeFileSync(join(root, 'session-summaries.json'), JSON.stringify({
-      version: SESSION_SUMMARY_INDEX_VERSION,
-      rows: [{
-        id: 'stale_desktop',
-        updatedAt: 1,
-        desktopSession: { classification: 'task', projectPath: null },
-      }],
-    }));
-    // A non-directory at the authoritative storage path deterministically
-    // exercises readdir failure on Windows and POSIX.
-    writeFileSync(join(root, 'sessions'), 'not a directory');
-
-    assert.deepEqual(listStoredSessionSummaries({ refreshFromStorage: true }), []);
-    assert.deepEqual(
-      listStoredSessionSummaries({ rebuildIfMissing: false }).map((row) => row.id),
-      ['stale_desktop'],
-    );
-  } finally {
-    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('authoritative refresh includes a desktop session still in the debounce window', () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-desktop-pending-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = root;
-  try {
-    saveSession({
-      id: 'desktop_pending',
-      owner: 'user',
-      agent: 'lead',
-      updatedAt: 50,
-      cwd: '/app/workspace',
-      desktopSession: { classification: 'task', projectPath: null },
-      messages: [{ role: 'user', content: 'Immediate desktop task' }],
-    });
-
-    const rows = listStoredSessionSummaries({ refreshFromStorage: true });
-    assert.equal(rows.some((row) => row.id === 'desktop_pending'), true);
-    assert.equal(rows.find((row) => row.id === 'desktop_pending').preview, 'Immediate desktop task');
-  } finally {
-    drainSessionStore();
-    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('invalid existing disk identities block same-id pending and live state', () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-desktop-live-blocked-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = root;
-  try {
-    const sessions = join(root, 'sessions');
-    mkdirSync(sessions, { recursive: true });
-    writeFileSync(join(sessions, 'pending_mismatch.json'), JSON.stringify({
-      id: 'different_transcript',
-      owner: 'user',
-      messages: [{ role: 'user', content: 'Mismatched disk transcript' }],
-    }));
-    writeFileSync(join(sessions, 'pending_malformed.json'), '{"id":');
-
-    for (const id of ['pending_mismatch', 'pending_malformed']) {
-      saveSession({
-        id,
-        owner: 'user',
-        agent: 'lead',
-        updatedAt: 60,
-        cwd: '/app/workspace',
-        desktopSession: { classification: 'task', projectPath: null },
-        messages: [{ role: 'user', content: `Pending replacement ${id}` }],
-      });
-    }
-
-    const rows = listStoredSessionSummaries({ refreshFromStorage: true });
-    assert.equal(rows.some((row) => row.id === 'pending_mismatch'), false);
-    assert.equal(rows.some((row) => row.id === 'pending_malformed'), false);
-    assert.equal(loadSession('pending_mismatch'), null);
-    assert.equal(loadSession('pending_malformed'), null);
-  } finally {
-    drainSessionStore();
-    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('readFileSync failure blocks same-id pending and live state', () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-desktop-read-error-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = root;
-  const readErrorPath = join(root, 'sessions', 'pending_read_error.json');
-  try {
-    mkdirSync(join(root, 'sessions'), { recursive: true });
-    // A directory with a .json storage name is visible to readdirSync and
-    // existsSync, but readFileSync itself fails on supported desktop platforms.
-    // This deterministically exercises the I/O catch before JSON.parse.
-    mkdirSync(readErrorPath);
-    saveSession({
-      id: 'pending_read_error',
-      owner: 'user',
-      agent: 'lead',
-      updatedAt: 70,
-      cwd: '/app/workspace',
-      desktopSession: { classification: 'task', projectPath: null },
-      messages: [{ role: 'user', content: 'Pending replacement after read error' }],
-    });
-
-    const rows = listStoredSessionSummaries({ refreshFromStorage: true });
-    assert.equal(rows.some((row) => row.id === 'pending_read_error'), false);
-    assert.equal(loadSession('pending_read_error'), null);
-  } finally {
-    // Remove the deliberate directory collision so draining the pending test
-    // save can complete without changing production failure behavior.
-    rmSync(readErrorPath, { recursive: true, force: true });
-    drainSessionStore();
-    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('session creation accepts only explicit desktop classification metadata', () => {
-  assert.deepEqual(
-    normalizeDesktopSessionMetadata({ classification: 'task', projectPath: '/ignored' }, '/cwd'),
-    { classification: 'task', projectPath: null },
-  );
-  assert.deepEqual(
-    normalizeDesktopSessionMetadata({ classification: 'project' }, '/project'),
-    { classification: 'project', projectPath: '/project' },
-  );
-  assert.deepEqual(
-    normalizeDesktopSessionMetadata({ classification: 'project', projectPath: '  /project/trimmed  ' }, '/fallback'),
-    { classification: 'project', projectPath: '/project/trimmed' },
-  );
-  assert.equal(normalizeDesktopSessionMetadata({ classification: 'project', projectPath: {} }, null), null);
-  assert.equal(normalizeDesktopSessionMetadata({ classification: 'project', projectPath: '\0bad' }, null), null);
-  assert.equal(normalizeDesktopSessionMetadata({ classification: 'project' }, null), null);
-  assert.equal(normalizeDesktopSessionMetadata({ classification: 'worker' }, '/cwd'), null);
-  assert.equal(normalizeDesktopSessionMetadata({}, '/cwd'), null);
-  assert.equal(normalizeDesktopSessionMetadata(null, '/cwd'), null);
-});
-
-test('desktop resume pins projects and unclassified tasks to their host-managed scope', () => {
-  assert.equal(resolveResumeCwd({
-    cwd: '/stale',
-    desktopSession: { classification: 'project', projectPath: '/project' },
-  }, '/app/workspace'), '/project');
-  assert.equal(resolveResumeCwd({
-    cwd: '/transient',
-    desktopSession: { classification: 'task', projectPath: null },
-  }, '/app/workspace'), '/app/workspace');
-  assert.equal(resolveResumeCwd({ cwd: '/cli' }, '/current'), '/cli');
-});
-
-test('new desktop sessions immediately repoint remote transcript forwarding', async () => {
-  let current = null;
-  const events = [];
-  const runtime = createLifecycleApi({
-    getSession: () => current,
-    setSession: (value) => { current = value; },
-    mgr: { closeSession: () => true },
-    invalidateContextStatusCache: () => events.push('invalidate'),
-    createCurrentSession: async () => {
-      events.push('create');
-      current = { id: 'desktop_new', messages: [] };
-    },
-    pushTranscriptRebind: () => events.push('rebind'),
-  });
-
-  assert.equal(await runtime.newSession(), 'desktop_new');
-  assert.deepEqual(events, ['invalidate', 'create', 'rebind']);
-});
-
-test('session deletion hard-deletes inactive rows and safely replaces the active row', async () => {
-  let current = {
-    id: 'desktop_active',
-    owner: 'user',
-    sourceType: 'cli',
-    messages: [{ role: 'user', content: 'Active session' }],
-  };
-  const rows = [
-    current,
-    {
-      id: 'desktop_inactive',
-      owner: 'user',
-      sourceType: 'cli',
-      messages: [{ role: 'user', content: 'Inactive session' }],
-    },
-  ];
-  const events = [];
-  const runtime = createLifecycleApi({
-    getSession: () => current,
-    setSession: (value) => { current = value; },
-    mgr: {
-      listSessions: () => rows,
-      deleteSession: (id) => { events.push(['delete', id]); return true; },
-      closeSession: (...args) => { events.push(['close', ...args]); return true; },
-    },
-    cancelBackgroundTasks: (options) => events.push(['background', options]),
-    agentTool: { closeAll: (reason) => events.push(['agents', reason]) },
-    statusRoutes: { clearGatewaySessionRoute: (id) => events.push(['route', id]) },
-    invalidateContextStatusCache: () => events.push(['context']),
-    invalidatePreSessionToolSurface: () => events.push(['surface']),
-    createCurrentSession: async () => {
-      current = { id: 'desktop_replacement', messages: [] };
-      events.push(['create', current.id]);
-    },
-    pushTranscriptRebind: () => events.push(['rebind']),
-  });
-
-  assert.equal(await runtime.deleteSession('desktop_inactive'), true);
-  assert.deepEqual(events.shift(), ['delete', 'desktop_inactive']);
-  assert.equal(await runtime.deleteSession('desktop_active'), true);
-  assert.equal(current.id, 'desktop_replacement');
-  assert.deepEqual(events, [
-    ['background', {
-      reason: 'desktop-session-delete',
-      notify: false,
-      callerSessionId: 'desktop_active',
-    }],
-    ['agents', 'desktop-session-delete'],
-    ['route', 'desktop_active'],
-    ['close', 'desktop_active', 'desktop-session-delete', { tombstone: true }],
-    ['context'],
-    ['surface'],
-    ['create', 'desktop_replacement'],
-    ['rebind'],
-  ]);
-});
-
-test('runtime resume returns the persisted transcript and restores desktop task scope', async () => {
-  let current = null;
-  let cwd = '/app/workspace';
-  let route = { provider: 'test', model: 'model' };
-  let transcriptRebinds = 0;
-  const messages = [
-    { role: 'user', content: 'Persisted question' },
-    { role: 'assistant', content: 'Persisted answer' },
-  ];
-  const runtime = createLifecycleApi({
-    getSession: () => current,
-    setSession: (value) => { current = value; },
-    getRoute: () => route,
-    setRoute: (value) => { route = value; },
-    getConfig: () => ({}),
-    getMode: () => 'full',
-    getCurrentCwd: () => cwd,
-    desktopSession: { classification: 'task', projectPath: null },
-    setSessionNeedsCwdRefresh: () => {},
-    mgr: {
-      resumeSession: async (id, _preset, options) => {
-        assert.deepEqual(options, {
-          desktopSession: { classification: 'task', projectPath: null },
-        });
-        return {
-          id,
-          provider: 'test',
-          model: 'model',
-          cwd: '/stale-task-cwd',
-          desktopSession: { classification: 'task', projectPath: null },
-          messages,
-        };
-      },
-    },
-    statusRoutes: {},
-    createCurrentSession: async () => {},
-    refreshRouteEffort: async () => {},
-    invalidateContextStatusCache: () => {},
-    invalidatePreSessionToolSurface: () => {},
-    applyResolvedCwd: (value) => { cwd = value; },
-    resolveRoute: (_config, value) => value,
-    applyDeferredToolSurface: () => {},
-    getStandaloneTools: () => [],
-    pushTranscriptRebind: () => { transcriptRebinds += 1; },
-  });
-
-  const resumed = await runtime.resume('desktop_task');
-  assert.deepEqual(resumed.messages, messages);
-  assert.equal(resumed.cwd, '/app/workspace');
-  assert.equal(current.cwd, '/app/workspace');
-  assert.equal(transcriptRebinds, 1);
-});
-
-test('runtime session prefetch warms the manager without changing the active session', () => {
-  const calls = [];
-  const current = { id: 'active', messages: [] };
-  const runtime = createLifecycleApi({
-    getSession: () => current,
-    getMode: () => 'full',
-    mgr: {
-      prefetchSession: (...args) => {
-        calls.push(args);
-        return true;
-      },
-    },
-  });
-
-  assert.equal(runtime.prefetchSession('next'), true);
-  assert.deepEqual(calls, [['next', 'full']]);
-  assert.equal(current.id, 'active');
-});
-
-test('desktop context switches retain runtime resources while durably closing the old session', async () => {
-  let current = {
-    id: 'old',
-    messages: [{ role: 'user', content: 'keep me' }],
-    liveTurnMessages: [],
-  };
-  let cwd = '/old';
-  let desktopSession = { classification: 'task', projectPath: null };
-  let route = { provider: 'resumed-provider', model: 'resumed-model' };
-  const closed = [];
-  const cleanup = [];
-  let releaseMcp;
-  const mcpReset = new Promise((resolve) => { releaseMcp = resolve; });
-  const runtime = createLifecycleApi({
-    getSession: () => current,
-    setSession: (value) => { current = value; },
-    getDesktopSession: () => desktopSession,
-    setDesktopSession: (value) => { desktopSession = value; },
-    getRoute: () => route,
-    setRoute: (value) => { route = value; },
-    getConfig: () => ({ default: 'workflow-lead' }),
-    getCurrentCwd: () => cwd,
-    mgr: { closeSession: (...args) => { closed.push(args); return true; } },
-    cancelBackgroundTasks: (options) => cleanup.push(['background', options]),
-    agentTool: { closeAll: (reason) => cleanup.push(['agents', reason]) },
-    statusRoutes: { clearGatewaySessionRoute: (id) => cleanup.push(['route', id]) },
-    applyResolvedCwd: (value, options) => {
-      // Mirror the real contract: the cwd applies in place immediately while
-      // the project MCP reset continues in the background; the switch must not
-      // block on it.
-      cleanup.push(['cwd:start', value, options]);
-      cwd = value;
-      void mcpReset.then(() => cleanup.push(['mcp:ready', value]));
-      return value;
-    },
-    invalidateContextStatusCache: () => {},
-    invalidatePreSessionToolSurface: () => {},
-    refreshRouteEffort: async () => {},
-    resolveRoute: (_config, value) => Object.keys(value).length > 0
-      ? value
-      : { provider: 'configured-provider', model: 'configured-model' },
-  });
-
-  let settled = false;
-  const switching = runtime.switchContext({
-    cwd: '/project',
-    desktopSession: { classification: 'project', projectPath: '/project' },
-  });
-  switching.then(() => { settled = true; });
-  // Non-blocking switch: it settles WITHOUT the MCP reset resolving. The
-  // reconnect gate moved to the ask path (bounded awaitInitialMcpConnect).
-  await switching;
-  assert.equal(settled, true);
-  assert.deepEqual(cleanup.slice(0, 4), [
-    ['background', {
-      reason: 'desktop-context-switch',
-      notify: false,
-      callerSessionId: 'old',
-    }],
-    ['agents', 'desktop-context-switch'],
-    ['route', 'old'],
-    ['cwd:start', '/project', { markRefresh: false }],
-  ]);
-  releaseMcp();
-  await mcpReset;
-
-  assert.deepEqual(closed, [['old', 'desktop-context-switch', { tombstone: false }]]);
-  assert.equal(current, null);
-  assert.equal(cwd, '/project');
-  assert.deepEqual(route, { provider: 'configured-provider', model: 'configured-model' });
-  assert.deepEqual(desktopSession, { classification: 'project', projectPath: '/project' });
-});
-
-test('cleared desktop context resumes legacy rows without reviving the creation marker', async () => {
-  const taskDesktopSession = { classification: 'task', projectPath: null };
-  let current = null;
-  let cwd = '/task';
-  let desktopSession = taskDesktopSession;
-  const resumeOptions = [];
-  const stored = {
-    legacy: {
-      id: 'legacy',
-      provider: 'test',
-      model: 'model',
-      cwd: '/legacy',
-      desktopSession: null,
-      messages: [],
-    },
-    project: {
-      id: 'project',
-      provider: 'test',
-      model: 'model',
-      cwd: '/project',
-      desktopSession: { classification: 'project', projectPath: '/project' },
-      messages: [],
-    },
-  };
-  const runtime = createLifecycleApi({
-    getSession: () => current,
-    setSession: (value) => { current = value; },
-    getDesktopSession: () => desktopSession,
-    setDesktopSession: (value) => { desktopSession = value; },
-    getRoute: () => ({ provider: 'test', model: 'model' }),
-    setRoute: () => {},
-    getConfig: () => ({}),
-    getMode: () => 'full',
-    getCurrentCwd: () => cwd,
-    setSessionNeedsCwdRefresh: () => {},
-    desktopSession: taskDesktopSession,
-    mgr: {
-      closeSession: () => true,
-      resumeSession: async (id, _preset, options) => {
-        resumeOptions.push(options);
-        const session = stored[id];
-        const expected = options?.desktopSession;
-        if (expected && (!session.desktopSession
-          || expected.classification !== session.desktopSession.classification)) return null;
-        return session;
-      },
-    },
-    statusRoutes: {},
-    createCurrentSession: async () => {},
-    refreshRouteEffort: async () => {},
-    invalidateContextStatusCache: () => {},
-    invalidatePreSessionToolSurface: () => {},
-    applyResolvedCwd: async (value) => { cwd = value; },
-    resolveRoute: (_config, value) => value,
-    applyDeferredToolSurface: () => {},
-    getStandaloneTools: () => [],
-  });
-
-  await runtime.switchContext({ cwd: '/legacy', desktopSession: null });
-  assert.equal(desktopSession, null);
-  assert.equal((await runtime.resume('legacy')).id, 'legacy');
-  assert.equal(resumeOptions[0], undefined);
-
-  await runtime.switchContext({ cwd: '/task', desktopSession: taskDesktopSession });
-  assert.equal(await runtime.resume('project'), null);
-  assert.deepEqual(resumeOptions[1], { desktopSession: taskDesktopSession });
-});
-
-test('desktop cwd application awaits project MCP reset before becoming ready', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-cwd-mcp-order-'));
-  const oldCwd = join(root, 'old');
-  const nextCwd = join(root, 'next');
-  mkdirSync(oldCwd);
-  mkdirSync(nextCwd);
-  let currentCwd = oldCwd;
-  let projectKey = '';
-  let releaseReset;
-  const resetGate = new Promise((resolve) => { releaseReset = resolve; });
-  const events = [];
-  const cwdPlugins = createCwdPlugins({
-    getCurrentCwd: () => currentCwd,
-    setCurrentCwd: (value) => { currentCwd = value; },
-    getSession: () => null,
-    getLastProjectMcpKey: () => projectKey,
-    setLastProjectMcpKey: (value) => { projectKey = value; },
-    isCodeGraphPrewarmLazy: () => true,
-    isCodeGraphFirstTurnPrewarmDone: () => false,
-    getCodeGraphPrewarmDelayMs: () => 0,
-    connectConfiguredMcp: async (options) => {
-      events.push(['reset:start', options]);
-      await resetGate;
-      events.push(['reset:done']);
-    },
-    invalidatePreSessionToolSurface: () => events.push(['surface:invalidated']),
-    scheduleCodeGraphPrewarm: () => {},
-    hooks: { dispatch: () => {} },
-    hookCommonPayload: (value) => value,
-    bootProfile: () => {},
-    readProjectMcpServers: () => ({}),
-    writeLastSessionCwd: () => {},
-    clean: (value) => String(value || '').trim(),
-    resolve,
-    statSync,
-  });
-  try {
-    let ready = false;
-    const applying = cwdPlugins.applyResolvedCwd(nextCwd, { waitForMcpReset: true });
-    applying.then(() => { ready = true; });
-    await Promise.resolve();
-    assert.equal(ready, false);
-    assert.deepEqual(events, [['reset:start', { reset: true }]]);
-    releaseReset();
-    assert.equal(await applying, resolve(nextCwd));
-    assert.deepEqual(events, [
-      ['reset:start', { reset: true }],
-      ['reset:done'],
-      ['surface:invalidated'],
-    ]);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('production runtime composition supplies mutable desktop session bindings', () => {
-  const source = readFileSync(
-    fileURLToPath(new URL('../src/session-runtime/runtime-core.mjs', import.meta.url)),
-    'utf8',
-  );
-  const composition = source.slice(
-    source.indexOf('const lifecycleApi = createLifecycleApi({'),
-    source.indexOf('const resourceApi = createResourceApi({'),
-  );
-  assert.match(composition, /getDesktopSession:\s*\(\)\s*=>\s*desktopSession/);
-  assert.match(composition, /setDesktopSession:\s*\(v\)\s*=>\s*\{\s*desktopSession = v;\s*\}/);
-});
-
-test('summary metadata rejects non-string project paths instead of leaking objects', () => {
-  const withoutFallback = _sessionSummary({
-    id: 'bad_project_path',
-    desktopSession: { classification: 'project', projectPath: { untrusted: true } },
-  });
-  const withFallback = _normalizeSummaryIndex({
-    rows: [{
-      id: 'legacy_project_path',
-      cwd: '  /legacy/project  ',
-      desktopSession: { classification: 'project', projectPath: null },
-    }],
-  }).rows[0];
-
-  assert.equal(withoutFallback.desktopSession, null);
-  assert.deepEqual(withFallback.desktopSession, {
-    classification: 'project',
-    projectPath: '/legacy/project',
-  });
-});
-
-test('desktop-guarded resume refuses legacy/cross-class rows while the historical path still accepts legacy', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-desktop-resume-guard-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = root;
-  try {
-    const sessions = join(root, 'sessions');
-    mkdirSync(sessions, { recursive: true });
-    const project = {
-      id: 'desktop_project_guard',
-      cwd: '/project',
-      desktopSession: { classification: 'project', projectPath: '/project' },
-      messages: [{ role: 'user', content: 'Project transcript' }],
-      tools: [],
-    };
-    const legacy = {
-      id: 'legacy_cli_guard',
-      cwd: '/cli',
-      messages: [{ role: 'user', content: 'CLI transcript' }],
-      tools: [],
-    };
-    writeFileSync(join(sessions, `${project.id}.json`), JSON.stringify(project));
-    writeFileSync(join(sessions, `${legacy.id}.json`), JSON.stringify(legacy));
-
-    const expectedTask = { desktopSession: { classification: 'task', projectPath: null } };
-    assert.equal(await resumeStoredSession(project.id, 'full', expectedTask), null);
-    assert.equal(await resumeStoredSession(legacy.id, 'full', expectedTask), null);
-    assert.deepEqual(JSON.parse(readFileSync(join(sessions, `${project.id}.json`), 'utf8')), project);
-    assert.deepEqual(JSON.parse(readFileSync(join(sessions, `${legacy.id}.json`), 'utf8')), legacy);
-    const resumedLegacy = await resumeStoredSession(legacy.id, 'full');
-    assert.equal(resumedLegacy.id, legacy.id);
-    assert.equal(resumedLegacy.desktopSession, undefined);
-  } finally {
-    drainSessionStore();
-    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    try {
-      rmSync(root, { recursive: true, force: true, maxRetries: 8, retryDelay: 25 });
-    } catch {
-      // The save worker acknowledges the session write before its best-effort
-      // summary-index flush has fully released Windows filesystem handles.
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      rmSync(root, { recursive: true, force: true, maxRetries: 8, retryDelay: 25 });
-    }
-  }
-});