mixdog 0.9.151 → 0.9.153

package/src/tui/session/completion-card-restore.test.mjs

@@ -7,6 +7,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { restoreTranscriptItems } from './session-api-ext.mjs';
+import { preserveGoalStateAfterTurn, transcriptToolCallDisplayMode } from './turn.mjs';
 
 const wrapper = (taskId, body) => [
   `Async shell task ${taskId} (completed, exit 0) finished.`,
@@ -109,3 +110,52 @@ test('task wait calls stay hidden when a session transcript is restored', () =>
   assert.equal(items.some((item) => item?.kind === 'tool' && item?.args?.action === 'wait'), false);
   assert.equal(items.some((item) => item?.kind === 'tool' && item?.args?.action === 'read'), true);
 });
+
+test('Goal and load control calls never enter restored tool aggregates', () => {
+  const hiddenNames = [
+    'goal',
+    'create_goal',
+    'get_goal',
+    'set_goal_tasks',
+    'update_goal',
+    'load_tool',
+    'tool_search',
+    'Skill',
+  ];
+  const toolCalls = hiddenNames.map((name, index) => ({
+    id: `call_hidden_${index}`,
+    name,
+    arguments: { action: 'status' },
+  }));
+  toolCalls.push({ id: 'call_read', name: 'read', arguments: { file_path: 'visible.txt' } });
+  const messages = [
+    { role: 'assistant', toolCalls },
+    ...toolCalls.map((call) => ({
+      role: 'tool',
+      toolCallId: call.id,
+      content: 'ok',
+    })),
+  ];
+
+  const items = restoreTranscriptItems(messages, { sessionId: 'sess_hidden_controls_restore' });
+  const toolItems = items.filter((item) => item?.kind === 'tool');
+  assert.equal(toolItems.length, 1);
+  assert.equal(toolItems[0].name, 'read');
+  assert.equal(toolItems.some((item) =>
+    (item.toolMembers || []).some((member) => hiddenNames.includes(member?.name))), false);
+});
+
+test('live turn display policy suppresses Goal/load controls without hiding ordinary tools', () => {
+  assert.equal(transcriptToolCallDisplayMode('goal', { action: 'create' }), 'hidden-control');
+  assert.equal(transcriptToolCallDisplayMode('functions.load_tool', { name: 'browser' }), 'hidden-control');
+  assert.equal(transcriptToolCallDisplayMode('task', { action: 'wait' }), 'task-wait');
+  assert.equal(transcriptToolCallDisplayMode('read', { file_path: 'visible.txt' }), 'visible');
+});
+
+test('surface replacement preserves Goal state while an explicit user cancellation still pauses', () => {
+  assert.equal(preserveGoalStateAfterTurn({ cancelled: true, stale: true }), true);
+  assert.equal(preserveGoalStateAfterTurn({ cancelled: true, pendingSessionReset: true }), true);
+  assert.equal(preserveGoalStateAfterTurn({ cancelled: true, disposed: true }), true);
+  assert.equal(preserveGoalStateAfterTurn({ cancelled: true }), false);
+  assert.equal(preserveGoalStateAfterTurn({ cancelled: false, stale: true }), false);
+});

package/src/tui/session/context-state.mjs

@@ -48,6 +48,7 @@ export function createContextState({ runtime, getState, updateState, getPendingS
     webSearchRoute: runtime.getWebSearchRoute?.() || runtime.webSearchRoute || null,
     autoClear: autoClearState(),
     workflow: runtime.workflow || null,
+    goal: runtime.goalStatus?.() || null,
   });
 
   const routeState = () => {
@@ -93,7 +94,6 @@ export function createContextState({ runtime, getState, updateState, getPendingS
   const syncContextStats = ({
     allowEstimated = false,
     invalidateExact = false,
-    compactedEstimateTokens = null,
   } = {}) => {
     if (getPendingSessionReset()) return null;
     const ctx = runtime.contextStatus?.() || null;
@@ -117,24 +117,14 @@ export function createContextState({ runtime, getState, updateState, getPendingS
       updateState({ stats });
       return ctx;
     }
-    // A compact completion already carries the estimate measured from the
-    // replacement transcript. Prefer it for this publication instead of
-    // letting a lagging contextStatus/provider snapshot repaint the deleted
-    // pre-compact prefix until the next request lands.
-    const compactedEstimate = Number(compactedEstimateTokens);
-    const hasCompactedEstimate = compactedEstimateTokens != null
-      && Number.isFinite(compactedEstimate)
-      && compactedEstimate > 0;
-    const estimatedTokens = hasCompactedEstimate
-      ? compactedEstimate
-      : Math.max(0, Number(ctx.currentEstimatedTokens ?? ctx.usedTokens ?? 0));
+    const estimatedTokens = Math.max(0, Number(ctx.currentEstimatedTokens ?? ctx.usedTokens ?? 0));
     const usedTokens = Math.max(0, Number(ctx.usedTokens ?? estimatedTokens ?? 0));
     const usedSource = String(ctx.usedSource || '').toLowerCase();
     // A successful pre-send auto-compact rewrites the transcript before the
     // next provider request can publish fresh usage. Never keep painting the
     // exact token count measured against the deleted pre-compact prefix during
     // that gap; publish the compacted transcript estimate immediately.
-    const forceEstimated = hasCompactedEstimate || (invalidateExact && estimatedTokens > 0);
+    const forceEstimated = invalidateExact && estimatedTokens > 0;
     const shouldPublishEstimate = allowEstimated && (
       usedSource === 'estimated'
       || Number(ctx.currentEstimatedTokens) > 0

package/src/tui/session/goal-continuation.mjs

@@ -0,0 +1,141 @@
+function clean(value) {
+  return String(value ?? '').trim();
+}
+
+function isGoalContinuation(entry) {
+  return entry?.mode === 'goal-continuation';
+}
+
+export function createGoalContinuation({
+  runtime,
+  flags,
+  getState,
+  set,
+  getPending,
+  enqueue,
+} = {}) {
+  let scheduled = null;
+  let disposed = false;
+  let suppressedCompletedGoalId = '';
+
+  const cancelQueuedGoalContinuations = () => {
+    const pending = getPending();
+    let removed = 0;
+    for (let index = pending.length - 1; index >= 0; index -= 1) {
+      if (!isGoalContinuation(pending[index])) continue;
+      pending.splice(index, 1);
+      removed += 1;
+    }
+    return removed;
+  };
+
+  const visibleGoal = (goal) => (
+    goal?.status === 'complete' && clean(goal.id) === suppressedCompletedGoalId
+      ? null
+      : goal || null
+  );
+
+  const refreshGoalState = () => {
+    const goal = visibleGoal(runtime.goalStatus?.() || null);
+    if (getState().goal !== goal) set({ goal });
+    return goal;
+  };
+
+  const continuationDecision = () => {
+    const decision = runtime.goalContinuation?.() || { run: false, reason: 'unavailable', goal: null };
+    if (getState().goal !== decision.goal) set({ goal: decision.goal || null });
+    return decision;
+  };
+
+  const shouldRunGoalContinuation = (entry) => {
+    if (disposed || flags.disposed || flags.pendingSessionReset) return false;
+    if (getState().sessionRemoteAttached) return false;
+    const decision = continuationDecision();
+    if (!decision.run) return false;
+    const queuedGoalId = clean(entry?.goalId);
+    return !queuedGoalId || queuedGoalId === clean(decision.goal?.id);
+  };
+
+  const scheduleGoalContinuation = () => {
+    if (disposed || scheduled) return false;
+    scheduled = setImmediate(() => {
+      scheduled = null;
+      if (disposed || flags.disposed || flags.pendingSessionReset) return;
+      const state = getState();
+      if (state.busy || state.commandBusy || state.sessionRemoteAttached) return;
+      const pending = getPending();
+      if (pending.some((entry) => !isGoalContinuation(entry))) return;
+      if (pending.some(isGoalContinuation)) return;
+      const decision = continuationDecision();
+      if (!decision.run || !clean(decision.prompt)) return;
+      enqueue(decision.prompt, {
+        mode: 'goal-continuation',
+        priority: 'later',
+        isMeta: true,
+        suppressDisplay: true,
+        skipSlashCommands: true,
+        restorable: false,
+        goalId: clean(decision.goal?.id),
+        displayText: '',
+      });
+    });
+    scheduled.unref?.();
+    return true;
+  };
+
+  const onGoalChanged = (event = {}) => {
+    const currentSessionId = clean(getState().sessionId || runtime.id);
+    if (clean(event.sessionId) && clean(event.sessionId) !== currentSessionId) return;
+    cancelQueuedGoalContinuations();
+    const goal = visibleGoal(event.goal || runtime.goalStatus?.() || null);
+    set({ goal });
+    if (goal?.status === 'active') scheduleGoalContinuation();
+  };
+
+  const unsubscribe = runtime.onGoalStatusChange?.(onGoalChanged) || (() => {});
+
+  return {
+    cancelQueuedGoalContinuations,
+    refreshGoalState,
+    scheduleGoalContinuation,
+    shouldRunGoalContinuation,
+    async onGoalTurnStarted() {
+      const goal = await Promise.resolve(runtime.goalTurnStarted?.());
+      if (goal !== undefined && getState().goal !== goal) set({ goal: goal || null });
+      return goal;
+    },
+    async onGoalTurnSettled(detail = {}) {
+      const status = clean(typeof detail === 'string' ? detail : detail.status).toLowerCase();
+      const goal = await Promise.resolve(runtime.goalTurnSettled?.(
+        typeof detail === 'string' ? { status } : detail,
+      ));
+      if (goal !== undefined && getState().goal !== goal) set({ goal: goal || null });
+      if (status === 'done' && goal?.status === 'active') scheduleGoalContinuation();
+      return goal;
+    },
+    archiveCompletedGoalOnUserInput() {
+      cancelQueuedGoalContinuations();
+      const currentGoal = getState().goal || runtime.goalStatus?.() || null;
+      const archivedGoalId = currentGoal?.status === 'complete' ? clean(currentGoal.id) : '';
+      if (archivedGoalId) {
+        suppressedCompletedGoalId = archivedGoalId;
+        set({ goal: null });
+      }
+      void Promise.resolve(runtime.archiveCompletedGoalOnUserInput?.())
+        .then(() => {
+          if (suppressedCompletedGoalId === archivedGoalId) suppressedCompletedGoalId = '';
+          refreshGoalState();
+        })
+        .catch(() => {
+          if (suppressedCompletedGoalId === archivedGoalId) suppressedCompletedGoalId = '';
+          refreshGoalState();
+        });
+    },
+    disposeGoalContinuation() {
+      disposed = true;
+      if (scheduled) clearImmediate(scheduled);
+      scheduled = null;
+      try { unsubscribe(); } catch {}
+    },
+  };
+}

package/src/tui/session/goal-continuation.test.mjs

@@ -0,0 +1,203 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createGoalContinuation } from './goal-continuation.mjs';
+
+const settleImmediate = () => new Promise((resolve) => setImmediate(resolve));
+
+test('completed Goal stays hidden while its user-input archive is in flight', async () => {
+  const goal = { id: 'goal-complete', status: 'complete', objective: 'Finished work' };
+  const state = {
+    busy: false,
+    commandBusy: false,
+    sessionId: 'sess_goal_complete',
+    goal,
+  };
+  let runtimeGoal = goal;
+  let listener = null;
+  let resolveArchive;
+  const archive = new Promise((resolve) => { resolveArchive = resolve; });
+  const controller = createGoalContinuation({
+    runtime: {
+      id: state.sessionId,
+      goalStatus: () => runtimeGoal,
+      archiveCompletedGoalOnUserInput: () => archive,
+      onGoalStatusChange: (next) => {
+        listener = next;
+        return () => { listener = null; };
+      },
+    },
+    flags: { disposed: false, pendingSessionReset: false },
+    getState: () => state,
+    set: (patch) => Object.assign(state, patch),
+    getPending: () => [],
+    enqueue: () => true,
+  });
+  try {
+    controller.archiveCompletedGoalOnUserInput();
+    assert.equal(state.goal, null);
+
+    listener?.({ sessionId: state.sessionId, goal });
+    assert.equal(state.goal, null);
+
+    runtimeGoal = null;
+    resolveArchive(null);
+    await archive;
+    await Promise.resolve();
+    assert.equal(state.goal, null);
+  } finally {
+    controller.disposeGoalContinuation();
+  }
+});
+
+test('failed completed Goal archive restores the persisted Goal snapshot', async () => {
+  const goal = { id: 'goal-restore', status: 'complete', objective: 'Restore me' };
+  const state = {
+    busy: false,
+    commandBusy: false,
+    sessionId: 'sess_goal_restore',
+    goal,
+  };
+  let rejectArchive;
+  const archive = new Promise((_resolve, reject) => { rejectArchive = reject; });
+  const controller = createGoalContinuation({
+    runtime: {
+      id: state.sessionId,
+      goalStatus: () => goal,
+      archiveCompletedGoalOnUserInput: () => archive,
+      onGoalStatusChange: () => () => {},
+    },
+    flags: { disposed: false, pendingSessionReset: false },
+    getState: () => state,
+    set: (patch) => Object.assign(state, patch),
+    getPending: () => [],
+    enqueue: () => true,
+  });
+  try {
+    controller.archiveCompletedGoalOnUserInput();
+    assert.equal(state.goal, null);
+
+    rejectArchive(new Error('disk write failed'));
+    await archive.catch(() => {});
+    await Promise.resolve();
+    assert.equal(state.goal, goal);
+  } finally {
+    controller.disposeGoalContinuation();
+  }
+});
+
+test('idle Goal schedules one hidden continuation and user input cancels it', async () => {
+  const goal = { id: 'goal-1', status: 'active', objective: 'Finish it' };
+  const state = { busy: false, commandBusy: false, sessionId: 'sess_goal', goal };
+  const pending = [];
+  let listener = null;
+  const controller = createGoalContinuation({
+    runtime: {
+      id: 'sess_goal',
+      goalStatus: () => goal,
+      goalContinuation: () => ({ run: true, reason: 'idle', goal, prompt: 'hidden continuation' }),
+      goalTurnStarted: async () => goal,
+      goalTurnSettled: async () => goal,
+      onGoalStatusChange: (next) => {
+        listener = next;
+        return () => { listener = null; };
+      },
+    },
+    flags: { disposed: false, pendingSessionReset: false },
+    getState: () => state,
+    set: (patch) => Object.assign(state, patch),
+    getPending: () => pending,
+    enqueue: (text, options) => {
+      pending.push({ content: text, ...options });
+      return true;
+    },
+  });
+  try {
+    assert.equal(controller.scheduleGoalContinuation(), true);
+    controller.scheduleGoalContinuation();
+    await settleImmediate();
+    assert.equal(pending.length, 1);
+    assert.equal(pending[0].mode, 'goal-continuation');
+    assert.equal(pending[0].priority, 'later');
+    assert.equal(controller.shouldRunGoalContinuation(pending[0]), true);
+
+    controller.cancelQueuedGoalContinuations();
+    assert.equal(pending.length, 0);
+
+    listener?.({ sessionId: 'sess_goal', goal: { ...goal, status: 'paused' } });
+    await settleImmediate();
+    assert.equal(pending.length, 0);
+  } finally {
+    controller.disposeGoalContinuation();
+  }
+});
+
+test('busy or agent-parked Goal does not enqueue a continuation', async () => {
+  const goal = { id: 'goal-2', status: 'active' };
+  const state = { busy: true, commandBusy: false, sessionId: 'sess_goal_busy', goal };
+  const pending = [];
+  const controller = createGoalContinuation({
+    runtime: {
+      id: 'sess_goal_busy',
+      goalStatus: () => goal,
+      goalContinuation: () => ({ run: false, reason: 'agent-running', goal }),
+      onGoalStatusChange: () => () => {},
+    },
+    flags: { disposed: false, pendingSessionReset: false },
+    getState: () => state,
+    set: (patch) => Object.assign(state, patch),
+    getPending: () => pending,
+    enqueue: (text, options) => pending.push({ content: text, ...options }),
+  });
+  try {
+    controller.scheduleGoalContinuation();
+    await settleImmediate();
+    assert.equal(pending.length, 0);
+    state.busy = false;
+    await controller.onGoalTurnSettled({ status: 'done' });
+    await settleImmediate();
+    assert.equal(pending.length, 0);
+  } finally {
+    controller.disposeGoalContinuation();
+  }
+});
+
+test('restart hydration preserves every non-active Goal snapshot without scheduling work', async () => {
+  for (const status of ['paused', 'blocked', 'complete']) {
+    const goal = {
+      id: `goal-${status}`,
+      status,
+      objective: `Keep ${status}`,
+      tasks: [{ id: 'task_1', text: 'Keep progress', status: 'completed', kind: 'work' }],
+    };
+    const state = {
+      busy: false,
+      commandBusy: false,
+      sessionId: `sess_goal_${status}`,
+      goal: null,
+    };
+    const pending = [];
+    const controller = createGoalContinuation({
+      runtime: {
+        id: state.sessionId,
+        goalStatus: () => goal,
+        goalContinuation: () => ({ run: false, reason: status, goal }),
+        onGoalStatusChange: () => () => {},
+      },
+      flags: { disposed: false, pendingSessionReset: false },
+      getState: () => state,
+      set: (patch) => Object.assign(state, patch),
+      getPending: () => pending,
+      enqueue: (text, options) => pending.push({ content: text, ...options }),
+    });
+    try {
+      assert.equal(controller.refreshGoalState(), goal);
+      assert.equal(state.goal, goal);
+      controller.scheduleGoalContinuation();
+      await settleImmediate();
+      assert.equal(pending.length, 0);
+    } finally {
+      controller.disposeGoalContinuation();
+    }
+  }
+});

package/src/tui/session/queue-helpers.mjs

@@ -36,7 +36,10 @@ export function defaultQueuePriority(mode) {
 
 export function isQueuedEntryEditable(entry) {
   const mode = entry?.mode || 'prompt';
-  return mode !== 'task-notification' && mode !== 'pending-resume' && entry?.isMeta !== true;
+  return mode !== 'task-notification'
+    && mode !== 'pending-resume'
+    && mode !== 'goal-continuation'
+    && entry?.isMeta !== true;
 }
 
 export function isQueuedEntryVisible(entry) {
@@ -44,7 +47,7 @@ export function isQueuedEntryVisible(entry) {
   // task completions stay in the internal pending queue, but should never look
   // like commands typed by the user while they wait to be drained.
   const mode = entry?.mode || 'prompt';
-  if (mode === 'pending-resume') return false;
+  if (mode === 'pending-resume' || mode === 'goal-continuation') return false;
   return isQueuedEntryEditable(entry);
 }
 

package/src/tui/session/session-action-surface.test.mjs

@@ -0,0 +1,190 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createSessionApi } from './session-api.mjs';
+import {
+  SESSION_CONFIGURE_ACTIONS,
+  SESSION_READ_ACTIONS,
+} from '../../standalone/session-protocol.mjs';
+
+// The daemon resolves every session action by NAME on the object
+// createLocalSessionRuntime returns — this surface. An action that only exists
+// on the runtime beneath it passes the protocol allowlist and then dies in the
+// session runtime worker as "session action <name> is unavailable" (desktop
+// /inherit shipped exactly that way).
+function stubBag(overrides = {}) {
+  const defaults = {
+    flags: {},
+    autoClearState: {},
+    pending: [],
+    listeners: new Set(),
+  };
+  return new Proxy({}, {
+    get: (_target, key) => {
+      if (key in overrides) return overrides[key];
+      if (key in defaults) return defaults[key];
+      return () => ({});
+    },
+    has: () => true,
+  });
+}
+
+test('every advertised session action exists on the session surface', () => {
+  const api = createSessionApi(stubBag());
+  const missing = [...SESSION_READ_ACTIONS, ...SESSION_CONFIGURE_ACTIONS]
+    .filter((action) => typeof api[action] !== 'function');
+  assert.deepEqual(missing, []);
+});
+
+test('accepted user input archives completed Goal UI before the next turn', () => {
+  const calls = [];
+  const api = createSessionApi(stubBag({
+    nextId: () => 'submission-goal-archive',
+    getState: () => ({ commandBusy: false, busy: true }),
+    enqueue: () => {
+      calls.push('enqueue');
+      return true;
+    },
+    cancelQueuedGoalContinuations: () => calls.push('cancel-goal-continuation'),
+    archiveCompletedGoalOnUserInput: () => calls.push('archive-completed-goal'),
+    runtime: { interruptTaskWait() {} },
+  }));
+
+  assert.equal(api.submit('next request'), true);
+  assert.deepEqual(calls, [
+    'enqueue',
+    'cancel-goal-continuation',
+    'archive-completed-goal',
+  ]);
+});
+
+test('submitAndWait resolves with the main turn settlement', async () => {
+  let state = { commandBusy: false, busy: false };
+  const api = createSessionApi(stubBag({
+    nextId: () => 'submission-1',
+    getState: () => state,
+    set: (patch) => { state = { ...state, ...patch }; },
+    autoClearBeforeSubmit: async () => {},
+    enqueue: (_text, options) => {
+      queueMicrotask(() => options.onSettled({
+        status: 'done',
+        result: { content: 'answer' },
+        session: { id: 'sess_agent' },
+      }));
+      return true;
+    },
+  }));
+
+  const settled = await api.submitAndWait('question');
+  assert.equal(settled.status, 'done');
+  assert.equal(settled.result.content, 'answer');
+  assert.equal(settled.session.id, 'sess_agent');
+});
+
+test('canonical child close is exposed on the session surface', () => {
+  const calls = [];
+  const api = createSessionApi(stubBag({
+    runtime: {
+      closeCanonicalSession(reason) {
+        calls.push(reason);
+        return true;
+      },
+    },
+  }));
+
+  assert.equal(typeof api.closeCanonicalSession, 'function');
+  assert.equal(api.closeCanonicalSession('cli-agent-close'), true);
+  assert.deepEqual(calls, ['cli-agent-close']);
+});
+
+test('canonical Agent completion is delivered through the session surface', () => {
+  const calls = [];
+  const api = createSessionApi(stubBag({
+    runtime: {
+      deliverToolCompletion(sessionId, text, meta) {
+        calls.push({ sessionId, text, meta });
+        return true;
+      },
+    },
+  }));
+  const meta = { type: 'agent_task_result', execution_id: 'task-agent-1' };
+
+  assert.equal(typeof api.deliverToolCompletion, 'function');
+  assert.equal(api.deliverToolCompletion('sess_lead', 'Agent handoff', meta), true);
+  assert.deepEqual(calls, [{
+    sessionId: 'sess_lead',
+    text: 'Agent handoff',
+    meta,
+  }]);
+});
+
+test('extension editor actions are advertised and forwarded', async () => {
+  const calls = [];
+  let state = { commandBusy: false, stats: {} };
+  const api = createSessionApi(stubBag({
+    runtime: {
+      getMcpServerConfig: (name) => {
+        calls.push(['getMcpServerConfig', name]);
+        return { name };
+      },
+      saveMcpServer: async (input) => {
+        calls.push(['saveMcpServer', input]);
+        return { name: input.name };
+      },
+      saveSkill: async (input) => {
+        calls.push(['saveSkill', input]);
+        return { skill: { name: input.name } };
+      },
+    },
+    getState: () => state,
+    set: (patch) => { state = { ...state, ...patch }; },
+    routeState: () => ({}),
+  }));
+
+  assert.ok(SESSION_READ_ACTIONS.includes('getMcpServerConfig'));
+  assert.ok(SESSION_CONFIGURE_ACTIONS.includes('saveMcpServer'));
+  assert.ok(SESSION_CONFIGURE_ACTIONS.includes('saveSkill'));
+  assert.deepEqual(api.getMcpServerConfig('UnityMCP'), { name: 'UnityMCP' });
+  await api.saveMcpServer({ name: 'UnityMCP' });
+  await api.saveSkill({ name: 'unity-helper' });
+  assert.deepEqual(calls, [
+    ['getMcpServerConfig', 'UnityMCP'],
+    ['saveMcpServer', { name: 'UnityMCP' }],
+    ['saveSkill', { name: 'unity-helper' }],
+  ]);
+});
+
+test('inheritFrom carries the conversation and rebuilds the heir transcript', async () => {
+  const carried = [
+    { role: 'system', content: 'target system prompt' },
+    { role: 'user', content: 'first question' },
+    { role: 'assistant', content: 'first answer' },
+  ];
+  let state = { sessionId: 'sess_heir', stats: {}, items: [] };
+  const calls = [];
+  const api = createSessionApi(stubBag({
+    runtime: {
+      inheritFrom: (sourceSessionId) => {
+        calls.push(sourceSessionId);
+        return { sessionId: 'sess_heir', sourceSessionId, messages: 2 };
+      },
+      readModelMessages: () => ({ messageCount: carried.length, messages: carried }),
+    },
+    getState: () => state,
+    set: (patch) => { state = { ...state, ...patch }; },
+    replaceItems: (items) => items,
+    routeState: () => ({}),
+  }));
+
+  const result = await api.inheritFrom('sess_source');
+
+  assert.deepEqual(calls, ['sess_source']);
+  assert.equal(result.messages, 2);
+  assert.equal(state.sessionId, 'sess_heir');
+  // Only the conversation travels: the target's own system block never becomes
+  // a transcript item.
+  assert.deepEqual(
+    state.items.map((item) => [item.kind, item.text]),
+    [['user', 'first question'], ['assistant', 'first answer']],
+  );
+});