mixdog 0.9.55 → 0.9.58

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

@@ -7,9 +7,13 @@ 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 {
@@ -99,6 +103,80 @@ test('desktop classification is optional and round-trips through the existing su
   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;
@@ -165,6 +243,10 @@ test('cached summaries reflect local lifecycle mutations and forced refresh reco
     }));
 
     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,
@@ -351,7 +433,7 @@ test('authoritative refresh fails closed when the session directory is unreadabl
   process.env.MIXDOG_DATA_DIR = root;
   try {
     writeFileSync(join(root, 'session-summaries.json'), JSON.stringify({
-      version: 1,
+      version: SESSION_SUMMARY_INDEX_VERSION,
       rows: [{
         id: 'stale_desktop',
         updatedAt: 1,
@@ -507,10 +589,87 @@ test('desktop resume pins projects and unclassified tasks to their host-managed
   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' },
@@ -548,13 +707,34 @@ test('runtime resume returns the persisted transcript and restores desktop task
     applyResolvedCwd: (value) => { cwd = value; },
     resolveRoute: (_config, value) => value,
     applyDeferredToolSurface: () => {},
-    standaloneTools: [],
+    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 () => {
@@ -565,6 +745,7 @@ test('desktop context switches retain runtime resources while durably closing th
   };
   let cwd = '/old';
   let desktopSession = { classification: 'task', projectPath: null };
+  let route = { provider: 'resumed-provider', model: 'resumed-model' };
   const closed = [];
   const cleanup = [];
   let releaseMcp;
@@ -574,19 +755,29 @@ test('desktop context switches retain runtime resources while durably closing th
     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: async (value, options) => {
+    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]);
-      await mcpReset;
       cwd = value;
-      cleanup.push(['cwd:ready', 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;
@@ -595,8 +786,10 @@ test('desktop context switches retain runtime resources while durably closing th
     desktopSession: { classification: 'project', projectPath: '/project' },
   });
   switching.then(() => { settled = true; });
-  await Promise.resolve();
-  assert.equal(settled, false);
+  // 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',
@@ -605,17 +798,86 @@ test('desktop context switches retain runtime resources while durably closing th
     }],
     ['agents', 'desktop-context-switch'],
     ['route', 'old'],
-    ['cwd:start', '/project', { markRefresh: false, waitForMcpReset: true }],
+    ['cwd:start', '/project', { markRefresh: false }],
   ]);
   releaseMcp();
-  await switching;
+  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');

package/scripts/generate-oc-icons.mjs

@@ -0,0 +1,11 @@
+import { readFileSync, writeFileSync } from "node:fs";
+const src = readFileSync("C:/Project/refs/opencode/packages/ui/src/components/icon.tsx", "utf8");
+const re = /^\s*"?([a-z0-9-]+)"?:\s*`([^`]+)`,?\s*$/gm;
+const entries = [];
+let m;
+while ((m = re.exec(src))) entries.push([m[1], m[2].replace(/\s+/g, " ").trim()]);
+if (entries.length < 80) throw new Error(`only ${entries.length} icons parsed`);
+const body = entries.map(([name, svg]) => `  ${JSON.stringify(name)}: ${JSON.stringify(svg)},`).join("\n");
+const out = `// GENERATED from refs/opencode packages/ui/src/components/icon.tsx (MIT).\n// Regenerate with scripts/generate-oc-icons.mjs — do not hand-edit path data.\n// All glyphs draw on a 20x20 viewBox with currentColor strokes/fills.\nexport const OC_ICON_MARKUP: Record<string, string> = {\n${body}\n};\n`;
+writeFileSync("apps/desktop/src/renderer/oc-icon-markup.ts", out);
+console.log("icons:", entries.length);

package/scripts/live-share-test.mjs

@@ -0,0 +1,148 @@
+// Integration test for src/tui/engine/live-share.mjs: a real owner pipe
+// server and viewer client exchange full/delta/tail frames and submits over
+// the platform transport (named pipe / unix socket).
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createLiveShare } from '../src/tui/engine/live-share.mjs';
+
+const PIPE_ID = `livetest_${process.pid}_${Date.now()}`;
+const pipePath = process.platform === 'win32'
+  ? `\\\\.\\pipe\\mixdog-live-${PIPE_ID}`
+  : join(tmpdir(), `mixdog-live-${PIPE_ID}.sock`);
+
+function waitFor(check, label, timeoutMs = 4000) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const startedAt = Date.now();
+    const tick = () => {
+      let result = false;
+      try { result = check(); } catch { result = false; }
+      if (result) return resolvePromise(result);
+      if (Date.now() - startedAt > timeoutMs) {
+        return rejectPromise(new Error(`timeout waiting for ${label}`));
+      }
+      setTimeout(tick, 20);
+    };
+    tick();
+  });
+}
+
+function createViewerStore() {
+  const store = {
+    items: [{ id: 'disk-only', kind: 'user', text: 'persisted last user message' }],
+    streamingTail: null,
+    spinner: null,
+  };
+  return {
+    store,
+    apply: {
+      getState: () => store,
+      set: (patch) => Object.assign(store, patch),
+      replaceItems: (items) => { store.items = [...items]; },
+      patchItem: (id, patch) => {
+        const index = store.items.findIndex((item) => item?.id === id);
+        if (index < 0) return false;
+        store.items[index] = { ...store.items[index], ...patch };
+        return true;
+      },
+      appendItems: (items) => { store.items = [...store.items, ...items]; },
+      updateStreamingTail: (id, patch) => {
+        const current = store.streamingTail?.id === id ? store.streamingTail : { id, text: '' };
+        store.streamingTail = { ...current, ...patch, id };
+      },
+      clearStreamingTail: () => { store.streamingTail = null; },
+    },
+  };
+}
+
+test('live-share mirrors owner deltas and routes viewer submits', async () => {
+  const listeners = new Set();
+  let ownerState = {
+    items: [{ id: 'a1', kind: 'assistant', text: 'hello' }],
+    streamingTail: null,
+    spinner: null,
+  };
+  const receivedSubmits = [];
+  const owner = createLiveShare({
+    ownerSessionId: () => PIPE_ID,
+    viewerSessionId: () => '',
+    socketPathFor: () => pipePath,
+    getPublishedState: () => ownerState,
+    listeners,
+    onRemoteSubmit: (text) => receivedSubmits.push(text),
+    onOwnerClosed: () => {},
+    viewerApply: null,
+  });
+  const publish = (next) => {
+    ownerState = next;
+    for (const listener of listeners) listener();
+  };
+
+  const viewer = createViewerStore();
+  let ownerClosedCount = 0;
+  const viewerShare = createLiveShare({
+    ownerSessionId: () => '',
+    viewerSessionId: () => PIPE_ID,
+    socketPathFor: () => pipePath,
+    getPublishedState: () => ({ items: [], streamingTail: null, spinner: null }),
+    listeners: new Set(),
+    onRemoteSubmit: () => {},
+    onOwnerClosed: () => { ownerClosedCount += 1; },
+    viewerApply: viewer.apply,
+  });
+
+  try {
+    owner.ensure();
+    const initialSync = viewerShare.waitForViewerSync(PIPE_ID, 1_000);
+    await waitFor(() => {
+      viewerShare.ensure();
+      return viewerShare.viewerConnected();
+    }, 'viewer connect');
+    // Initial full frame mirrors the owner transcript.
+    assert.equal(await initialSync, true);
+    await waitFor(() => viewer.store.items.length === 1
+      && viewer.store.items[0].id === 'a1', 'initial full frame');
+    assert.equal(viewer.store.items.some((item) => item.id === 'disk-only'), false,
+      'the initial sync barrier must replace the incomplete persisted transcript');
+
+    // Appended item + streaming tail start.
+    publish({
+      ...ownerState,
+      items: [...ownerState.items, { id: 'u1', kind: 'user', text: 'hi from owner side' }],
+      streamingTail: { kind: 'assistant', id: 't1', text: 'stream', streaming: true },
+      spinner: { active: true, mode: 'responding' },
+    });
+    await waitFor(() => viewer.store.items.length === 2
+      && viewer.store.streamingTail?.text === 'stream'
+      && viewer.store.spinner?.active === true, 'append + tail frame');
+
+    // Append-only tail growth rides the suffix protocol.
+    publish({
+      ...ownerState,
+      streamingTail: { kind: 'assistant', id: 't1', text: 'streaming more', streaming: true },
+    });
+    await waitFor(() => viewer.store.streamingTail?.text === 'streaming more', 'tail suffix frame');
+
+    // Patched item (owner edited an existing row) arrives as a change.
+    publish({
+      ...ownerState,
+      items: [{ ...ownerState.items[0], text: 'hello edited' }, ownerState.items[1]],
+      streamingTail: null,
+    });
+    await waitFor(() => viewer.store.items[0].text === 'hello edited'
+      && viewer.store.streamingTail === null, 'patch + tail clear frame');
+
+    // Viewer submit reaches the owner queue.
+    assert.equal(viewerShare.sendSubmit('typed on viewer'), true);
+    await waitFor(() => receivedSubmits.length === 1, 'viewer submit');
+    assert.equal(receivedSubmits[0], 'typed on viewer');
+
+    // Owner shutdown notifies the viewer promotion path.
+    owner.dispose();
+    await waitFor(() => ownerClosedCount === 1, 'owner close notification');
+  } finally {
+    owner.dispose();
+    viewerShare.dispose();
+  }
+});

package/scripts/live-worker-smoke.mjs

@@ -107,7 +107,7 @@ async function main() {
   const skipsReview = reviewSkipViolation(workflow);
   assert(hasAll(lead, 'write-role agents self-verify', 'cross-scope verification', 'benches', 'all git', 'current project/workspace'), 'lead tool rules must preserve verification, git, and workspace ownership');
   assert(hasAll(workflow, 'before the user explicitly approves the latest plan', 'no edits, no state mutation, no delegation'), 'default workflow must require latest-plan approval before work');
-  assert(hasAll(workflow, 'on approval, fan out at maximum width', 'one agent per independent scope', 'all spawned in one turn'), 'default workflow must fan out independent scopes at maximum width');
+  assert(hasAll(workflow, 'on approval, fan out at maximum width', 'one agent per independent scope', 'all spawned in one turn', 'split the plan into as many scopes as possible', 'disjoint file/module sets are independent', 'merge only on a true output dependency', 'prefer parallel scopes over sequential slices in one agent'), 'default workflow must fan out independent scopes at maximum width');
   assert(hasAll(workflow, 'simple, well-understood implementation goes to worker', 'complex or investigative implementation goes to heavy worker', 'lead itself edits only a local, one-turn configuration/git change', 'debugger only on a defect needing deep root-cause analysis or a bug surviving 2+ review/fix cycles'), 'default workflow must enforce role routing and Lead/Debugger limits');
   assert(hasAll(workflow, 'every implementation gets its own reviewer, attached per scope', 'only the local lead-direct edits above are exempt', 'lead itself edits only a local, one-turn configuration/git change', 'keep the same reviewer through the fix loop', 'fix -> re-verify until clean', 'lead cross-verifies'), 'default workflow must require a Reviewer for every implementation except local Lead-direct one-turn config/git edits');
   assert(hasAll(workflow, 'build, deploy, commit, and push happen only on an explicit user request', 'on direction change, pause and re-consult the user'), 'default workflow must require user authorization and re-consultation');

package/scripts/max-output-recovery-test.mjs

@@ -36,6 +36,7 @@ function queuedProvider(responses, streamed = []) {
 async function run(provider, messages = [{ role: 'user', content: 'answer fully' }], options = {}) {
     return agentLoop(provider, messages, 'fake-model', [], options.onToolCall, process.cwd(), {
         onTextDelta: options.onTextDelta,
+        takeAssistantTranscriptMetadata: options.takeAssistantTranscriptMetadata,
         session: options.session,
         providerState: options.providerState,
     });
@@ -56,8 +57,17 @@ test('one max-output continuation resumes from preserved partial and returns one
         { content: 'omega', stopReason: 'end_turn' },
     ], streamed);
     const messages = [{ role: 'user', content: 'answer fully' }];
+    const recoveryTranscriptMeta = {
+        at: 1_735_689_600_000,
+        model: 'Fake Model',
+        provider: 'fake-provider',
+        agent: 'Test Workflow',
+    };
 
-    const result = await run(provider, messages, { onTextDelta: () => {} });
+    const result = await run(provider, messages, {
+        onTextDelta: () => {},
+        takeAssistantTranscriptMetadata: () => recoveryTranscriptMeta,
+    });
 
     assert.equal(provider.sent.length, 2);
     assert.equal(result.content, 'alpha omega');
@@ -67,6 +77,7 @@ test('one max-output continuation resumes from preserved partial and returns one
     assert.equal(result.terminationReason, undefined);
     assert.deepEqual(provider.sent[1].map((message) => message.role), ['user', 'assistant', 'user']);
     assert.equal(provider.sent[1][1].content, 'alpha ');
+    assert.deepEqual(provider.sent[1][1].meta?.transcript, recoveryTranscriptMeta);
     assert.match(provider.sent[1][2].content, /Resume directly/);
     assert.match(provider.sent[1][2].content, /no apology, no recap/i);
     assert.equal(persistedAssistantText(messages, result), result.content);