mixdog 1.1.1 → 1.2.0

package/src/standalone/session-client.mjs

@@ -18,9 +18,13 @@ import { readSingletonOwner } from '../runtime/shared/singleton-owner.mjs';
 import { isPidAlive } from '../runtime/shared/pid-liveness.mjs';
 import { resolveRuntimeRoot } from '../runtime/shared/runtime-root.mjs';
 import { withHeapCap } from '../runtime/shared/heap-cap.mjs';
-import { daemonDataDir } from '../session-runtime/services/daemon-crash-capture.mjs';
+import { daemonCrashCaptureDir, daemonDataDir } from '../session-runtime/services/daemon-crash-capture.mjs';
 import { forkDaemonCandidate } from '../session-runtime/services/daemon-candidate.mjs';
+import { daemonOwnerIsStale, proveDaemonOwnerRecord } from './daemon-owner.mjs';
 import { createAttachmentCalls } from './session-client/attachment-calls.mjs';
+import { daemonUnavailableError } from './session-client/daemon-unavailable.mjs';
+import { createLeaseHeartbeat } from './session-client/lease-heartbeat.mjs';
+import { clampLeaseMs } from './session-transport/client-registry/client-grace.mjs';
 import {
   EVENT_STREAM_LIVENESS_TIMEOUT_MS,
   EVENT_STREAM_RECONNECT_BASE_MS,
@@ -90,8 +94,20 @@ function request({
   timeoutMs = 120_000,
   control = false,
   urgent = false,
+  // Total-duration bound (timeoutMs only measures socket inactivity, which a
+  // trickling response keeps resetting). Probes set it; calls do not.
+  deadlineMs = 0,
 }) {
-  return new Promise((resolve, reject) => {
+  return new Promise((settleResolve, settleReject) => {
+    let deadlineTimer = null;
+    const resolve = (value) => {
+      clearTimeout(deadlineTimer);
+      settleResolve(value);
+    };
+    const reject = (error) => {
+      clearTimeout(deadlineTimer);
+      settleReject(error);
+    };
     const payload = body ? JSON.stringify(body) : null;
     const req = http.request(
       {
@@ -112,6 +128,7 @@ function request({
         res.on('data', (chunk) => {
           data += chunk;
         });
+        res.on('error', reject);
         res.on('end', () => {
           let parsed = null;
           try {
@@ -133,20 +150,43 @@ function request({
       req.destroy(new Error(`session timeout: ${method} ${urlPath}`));
     });
     req.on('error', reject);
+    if (deadlineMs > 0) {
+      deadlineTimer = setTimeout(() => {
+        const error = new Error(`session timeout: ${method} ${urlPath}`);
+        reject(error);
+        req.destroy(error);
+      }, deadlineMs);
+    }
     if (payload) req.write(payload);
     req.end();
   });
 }
 
+/** /health within `timeoutMs` of total duration; null when it does not answer. */
 export async function probeSessionHealth({ port, token, timeoutMs = 800 } = {}) {
   try {
-    const health = await request({ port, token, path: '/health', timeoutMs, control: true });
+    const health = await request({
+      port,
+      token,
+      path: '/health',
+      timeoutMs,
+      deadlineMs: Math.max(1, timeoutMs),
+      control: true,
+    });
     return health?.status === 'ok' ? health : null;
   } catch {
     return null;
   }
 }
 
+/** Health probe + protocol compatibility against an explicit discovery,
+ *  without reading daemon.json or spawning anything. `health` is null when
+ *  the daemon does not answer (then `compatibility` is null too). */
+export async function probeSessionCompatibility(discovery, { timeoutMs = 800, probeHealth = probeSessionHealth } = {}) {
+  const health = await probeHealth({ port: discovery?.port, token: discovery?.token, timeoutMs });
+  return { health, compatibility: health ? sessionDaemonCompatibility(health) : null };
+}
+
 export function readSessionDiscovery(discoveryPath = sessionDiscoveryPath()) {
   try {
     const parsed = JSON.parse(readFileSync(discoveryPath, 'utf8'));
@@ -319,13 +359,15 @@ export function spawnDaemonCandidate({ cwd, log, timeoutMs = 30_000, entry = dae
   });
 }
 
-/** Spawn-or-attach discovery for the machine-global daemon. */
+/** Spawn-or-attach discovery for the machine-global daemon.
+ *  `entry` is a test seam; production always forks the real daemon. */
 export async function ensureDaemon({
   cwd = process.cwd(),
   log = () => {},
   attempts = 5,
   readyTimeoutMs = null,
   onUpgradeWait = null,
+  entry = daemonEntry(),
 } = {}) {
   const configuredTimeoutMs = Number(process.env.MIXDOG_DAEMON_READY_TIMEOUT_MS);
   let requestedTimeoutMs = DEFAULT_DAEMON_READY_TIMEOUT_MS;
@@ -338,6 +380,11 @@ export async function ensureDaemon({
   let spawnAttempts = 0;
   let waitingOwnerPid = 0;
   let waitingDrainPid = 0;
+  let staleOwnerPid = 0;
+  // What the passes observed, for the error when no endpoint ever appears.
+  let unansweredDiscovery = null;
+  let waitedOwner = null;
+  let lastCandidate = null;
   const startedAt = Date.now();
   const elapsed = () => Date.now() - startedAt;
   while (Date.now() < deadline) {
@@ -352,7 +399,7 @@ export async function ensureDaemon({
       const health = await probeSessionHealth({
         port: discovery.port,
         token: discovery.token,
-        timeoutMs: DAEMON_BOOT_PROBE_TIMEOUT_MS,
+        timeoutMs: Math.max(1, Math.min(DAEMON_BOOT_PROBE_TIMEOUT_MS, deadline - Date.now())),
       });
       log(
         `discovery pid=${discovery.pid} port=${discovery.port}` +
@@ -385,13 +432,35 @@ export async function ensureDaemon({
         err.sessionProtocolMismatch = true;
         throw err;
       }
+      unansweredDiscovery = { pid: discovery.pid, port: discovery.port };
     }
     // A concurrent launcher can win the owner lock before it publishes
     // daemon.json. That is a healthy singleton boot, not a reason to spawn five
-    // doomed contenders and report "endpoint unavailable" after ~500 ms.
-    const ownerState = readSingletonOwner(daemonOwnerPath());
+    // doomed contenders and report "endpoint unavailable" after ~500 ms. A
+    // live pid whose heartbeat stopped is a reused pid (daemon-owner.mjs):
+    // spawn, and the candidate reclaims it.
+    // A live-pid record whose heartbeat looks stale (or that has none: v1.1.2
+    // and older) is reclaimable only when its holder's endpoint does not
+    // answer with its pid — a crashed daemon leaves its files behind, naming a
+    // pid the OS may have reused. A probe cut short by this deadline proves
+    // nothing either way.
+    const proof = await proveDaemonOwnerRecord(daemonOwnerPath(), {
+      discoveryPath: sessionDiscoveryPath(),
+      budgetMs: Math.max(1, deadline - Date.now()),
+    });
+    const ownerState = readSingletonOwner(daemonOwnerPath(), {
+      isStale: (owner) => daemonOwnerIsStale(owner, { proof }),
+    });
+    if (ownerState.stale && Number(ownerState.owner?.pid) !== staleOwnerPid) {
+      staleOwnerPid = Number(ownerState.owner?.pid) || 0;
+      log(
+        `daemon owner record pid=${staleOwnerPid} heartbeatAt=${ownerState.owner?.heartbeatAt ?? '-'}` +
+          ` probe=${proof?.verdict ?? '-'} is stale; spawning a daemon to reclaim it`
+      );
+    }
     const ownerPid = ownerState.alive ? Number(ownerState.owner?.pid) || 0 : 0;
     if (ownerPid) {
+      waitedOwner = { pid: ownerPid, claimedAt: ownerState.owner?.claimedAt ?? null };
       if (ownerPid !== waitingOwnerPid) {
         waitingOwnerPid = ownerPid;
         log(`waiting for daemon owner pid=${ownerPid} to publish its session endpoint`);
@@ -400,16 +469,25 @@ export async function ensureDaemon({
       continue;
     }
     waitingOwnerPid = 0;
+    waitedOwner = null;
     if (spawnAttempts >= maxSpawnAttempts) break;
     spawnAttempts += 1;
     log(`spawning daemon candidate attempt=${spawnAttempts} at=${elapsed()}ms`);
-    await spawnDaemonCandidate({
+    lastCandidate = await spawnDaemonCandidate({
       cwd,
       log,
       timeoutMs: Math.max(1, deadline - Date.now()),
+      entry,
     });
   }
-  throw new Error('daemon session endpoint is unavailable');
+  throw daemonUnavailableError({
+    discovery: unansweredDiscovery,
+    owner: waitedOwner,
+    candidate: lastCandidate?.summary?.() ?? null,
+    spawnAttempts,
+    maxSpawnAttempts,
+    captureDir: daemonCrashCaptureDir(),
+  });
 }
 
 /** Registers this client with the daemon. Transport failures are retried
@@ -454,6 +532,12 @@ export async function attachSession({
   streamReconnectMaxMs = EVENT_STREAM_RECONNECT_MAX_MS,
   streamLivenessTimeoutMs = EVENT_STREAM_LIVENESS_TIMEOUT_MS,
   streamReconnectBudgetMs = EVENT_STREAM_RECONNECT_BUDGET_MS,
+  remote = false,
+  leaseMs = 30_000,
+  heartbeatMs = 10_000,
+  readDiscovery = remote ? () => discovery : () => readSessionDiscovery(),
+  pidAlive = remote ? () => true : isPidAlive,
+  probeHealth = probeSessionHealth,
   log = () => {},
 } = {}) {
   if (!discovery?.port || !discovery?.token) throw new Error('daemon discovery {port, token} required');
@@ -462,13 +546,15 @@ export async function attachSession({
     port,
     serverToken,
     body: {
-      leadPid,
+      // A remote client's process lives on another machine: no local pid.
+      leadPid: remote ? 0 : leadPid,
       cwd,
       lifecycle: lifecycle !== false,
       clientKind: clientKind === 'desktop' ? 'desktop' : 'session',
       registrationId: String(registrationId || randomUUID()),
       protocol: SESSION_PROTOCOL,
       revision: SESSION_REVISION,
+      ...(remote ? { remote: true, leaseMs: clampLeaseMs(leaseMs) } : {}),
     },
   });
   const clientToken = reg?.token;
@@ -487,18 +573,23 @@ export async function attachSession({
     reconnectMaxMs: streamReconnectMaxMs,
     reconnectBudgetMs: streamReconnectBudgetMs,
     livenessTimeoutMs: streamLivenessTimeoutMs,
-    readDiscovery: () => readSessionDiscovery(),
-    probeHealth: probeSessionHealth,
-    pidAlive: isPidAlive,
+    readDiscovery,
+    probeHealth,
+    pidAlive,
     log,
   });
   link.open();
+  const heartbeat = remote
+    ? createLeaseHeartbeat({ request, port, serverToken, clientToken, heartbeatMs, leaseMs, log })
+    : null;
+  heartbeat?.start();
   const { call, close } = createAttachmentCalls({
     request,
     port,
     serverToken,
     clientToken,
     stopStream: link.stop,
+    stopHeartbeat: heartbeat?.stop,
     log,
   });
 

package/src/standalone/session-protocol.mjs

@@ -40,6 +40,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getLocalProviderModelDetails',
   'getSessionReviewDiff',
   'getSessionUsage',
+  'getTurnChanges',
   'getTurnReviewDiff',
   'getTurnLiveness',
   'getUpdateSettings',
@@ -49,6 +50,10 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getVoiceStatus',
   'isSetupRequestActive',
   'getWorkflowPack',
+  'getWorktreeSettings',
+  'getBranchMenu',
+  'getProjectBranchMenu',
+  'listWorktrees',
   'hooksStatus',
   'inheritancePreflight',
   'listAgents',
@@ -132,6 +137,8 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'restoreQueued',
   'revertTurnReview',
   'revertTurnReviewFile',
+  'revertTurnChanges',
+  'reapplyTurnChanges',
   'rewindToItem',
   'runDoctor',
   'runScheduleNow',
@@ -189,8 +196,10 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setWebhookEnabled',
   'setWorkflow',
   'setOrchestrationMode',
+  'saveStarterGuideState',
   'skipOnboarding',
   'startMediaJob',
+  'stopShellJob',
   'switchContext',
   'taskControl',
   'testWebhook',
@@ -201,6 +210,14 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'transcribeAudio',
   'prepareTranscription',
   'updatePlugin',
+  'setWorktreeSettings',
+  'selectBranch',
+  'selectProjectBranch',
+  'mergeProjectBranch',
+  'requestWorktree',
+  'mergeWorkspace',
+  'removeWorktree',
+  'pruneWorktrees',
 ]);
 
 export const SESSION_READ_ACTION_SET = new Set(SESSION_READ_ACTIONS);

package/src/standalone/session-proxy.mjs

@@ -35,6 +35,9 @@ export function createSessionProxyFactory({ attachSession, ensureDaemon, closeId
       toolMode: options.toolMode || 'full',
       remote: options.remote === true,
       desktopSession: options.desktopSession ?? null,
+      // Worktree intent: `--worktree [name]` / `--no-worktree`, or `{ mode: 'default' }`
+      // (the TUI's interactive Lead follows the settings default); absent: none.
+      ...(options.worktree ? { worktree: options.worktree } : {}),
     };
     const attachment = await pool.ensure({ cwd, log });
     const created = await attachment.client.create(openParams, {

package/src/standalone/session-service/agent-tree/agent-child.mjs

@@ -36,8 +36,11 @@ export function createAgentChildFactory({ registry, rehydrateAgentSessions, crea
       model,
       effort: preset.effort,
       fast: preset.fast === true,
+      // Explicit, so Main's modelSettings bucket cannot decide the agent's Auto effort.
+      autoEffort: preset.autoEffort !== false,
       modelParameters: preset.modelParameters,
       contextPercent: spec.contextPercent,
+      contextTokens: spec.contextTokens,
       selectedContextWindow: spec.selectedContextWindow,
       toolMode: 'full',
       sessionProfile,
@@ -51,6 +54,7 @@ export function createAgentChildFactory({ registry, rehydrateAgentSessions, crea
       presetName: preset.id || preset.name || null,
       effort: preset.effort || null,
       fast: preset.fast === true,
+      ...(preset.autoEffort === false ? { autoEffort: false } : {}),
       createdAt: Date.now(),
       updatedAt: Date.now(),
       status: 'idle',

package/src/standalone/session-service/agent-tree/agent-rehydrate.mjs

@@ -79,6 +79,7 @@ function rehydratedDescriptor(candidate, ownerSessionId) {
     presetName: row.presetName || row.preset || row.profileId || null,
     effort: row.effort || null,
     fast: row.fast === true,
+    ...(row.autoEffort === false ? { autoEffort: false } : {}),
     modelParameters: row.modelParameters || null,
     taskType: row.taskType || null,
     permission: row.permission || null,

package/src/standalone/session-service/entries/lifecycle.mjs

@@ -1,6 +1,7 @@
 // Creation of one daemon-owned execution entry around an injected runtime;
 // disposal lives in ./disposal.mjs. Entries are never addressed by clients;
 // sessionId is the only identity outside the service.
+import { syncEntryWorkspace } from '../projection/workspace.mjs';
 import { createEntryDisposal } from './disposal.mjs';
 
 export function createEntryLifecycle({
@@ -46,17 +47,21 @@ export function createEntryLifecycle({
       model: params.model,
       effort: params.effort,
       fast: params.fast,
+      autoEffort: params.autoEffort,
       modelParameters: params.modelParameters,
       contextPercent: params.contextPercent,
+      contextTokens: params.contextTokens,
       selectedContextWindow: params.selectedContextWindow,
       toolMode: params.toolMode || 'full',
       remote: params.remote === true,
       desktopSession: params.desktopSession ?? null,
       sessionProfile: params.sessionProfile ?? null,
+      worktree: params.worktree ?? null,
     });
     const entry = {
       runtime,
       cwd: params.cwd || process.cwd(),
+      workspaceRevision: null,
       timer: null,
       disposed: false,
       unsubscribe: null,
@@ -79,6 +84,7 @@ export function createEntryLifecycle({
       } catch {
         initialState = { busy: true };
       }
+      syncEntryWorkspace(entry, initialState);
       indexSessionEntry(entry, initialState.sessionId);
       updateEntryBusy(entry, initialState);
       addSubscriber(entry, ctx);

package/src/standalone/session-service/projection/revisions.mjs

@@ -5,6 +5,7 @@
 import { diffSessionState } from '../../session-state-patch.mjs';
 import { projectSessionState } from '../../session-state-projection.mjs';
 import { windowTranscriptSnapshot } from './transcript-window.mjs';
+import { syncEntryWorkspace } from './workspace.mjs';
 
 function snapshotOf(entry) {
   const raw = entry.runtime.getState?.() ?? null;
@@ -127,6 +128,7 @@ export function createRevisionSteps({ revisionEpoch, index, updateEntryBusy, log
       };
     }
     const snapshot = current;
+    syncEntryWorkspace(entry, snapshot);
     if (!addressedSessionId && projectedSessionId) {
       entry.addressedSessionId = projectedSessionId;
     }

package/src/standalone/session-service/projection/transcript-window.mjs

@@ -97,10 +97,7 @@ function budgetedStart(items, end, maxItems, byteBudget, minItems) {
  *  goes below TRANSCRIPT_WINDOW_MIN_ITEMS. */
 function tailWindowStart(items, { limit, byteBudget = null, pageBase = 0 }) {
   const held = Math.min(pageBase || 0, limit, items.length);
-  if (held > 0) {
-    return budgetedStart(items, items.length - held, limit - held, byteBudget, TRANSCRIPT_WINDOW_MIN_ITEMS);
-  }
-  return budgetedStart(items, items.length, limit, byteBudget, TRANSCRIPT_WINDOW_MIN_ITEMS);
+  return budgetedStart(items, items.length - held, limit - held, byteBudget, TRANSCRIPT_WINDOW_MIN_ITEMS);
 }
 
 /** A stored projection already holds at most `window.limit` items; the byte
@@ -122,6 +119,22 @@ function restoredAfterFirstMessage(item) {
   return Boolean(match) && Number(match[1]) > 0;
 }
 
+/** The compaction-archive segments (`{ after, before }`) a resumed runtime
+ *  holds none of, or null. */
+function runtimeArchiveRange(state) {
+  const range = state?.transcriptArchive;
+  const after = Number(range?.after);
+  const before = Number(range?.before);
+  return Number.isInteger(after) && Number.isInteger(before) && before - 1 > after ? { after, before } : null;
+}
+
+function resetLoadedHead(view) {
+  view.head = [];
+  view.headOlder = null;
+  view.headSource = null;
+  view.archiveHeld = 0;
+}
+
 /** Fold a read/subscribe request into a live entry's window. */
 export function requestLiveTranscriptWindow(entry, request) {
   const view = entry.transcriptView;
@@ -143,6 +156,10 @@ export function requestLiveTranscriptWindow(entry, request) {
       paged: false,
       head: [],
       headOlder: null,
+      // Where the loaded head came from: 'stored' (durable history aligned by
+      // restore ids) or 'archive' (compaction-archive pages).
+      headSource: null,
+      archiveHeld: 0,
       cache: null,
     };
     return;
@@ -183,14 +200,12 @@ export function windowTranscriptSnapshot(entry, wire) {
     // rewind, clear): follow the anchor, or restart from the tail.
     const moved = items.findIndex((item) => item?.id === view.anchorId);
     start = moved < 0 ? null : moved;
-    view.head = [];
-    view.headOlder = null;
+    resetLoadedHead(view);
   }
   if (start !== null && start > items.length) start = null;
   if (start === null) {
     start = tailWindowStart(items, view);
-    view.head = [];
-    view.headOlder = null;
+    resetLoadedHead(view);
   }
   // The sticky start lets appends travel as suffix patches, so an unpaged
   // tail grows past its byte budget while views stay attached (a worker
@@ -210,7 +225,8 @@ export function windowTranscriptSnapshot(entry, wire) {
   }
   view.start = start;
   view.anchorId = items[start]?.id;
-  const older = start > 0 || (view.headOlder ?? restoredAfterFirstMessage(view.head[0] ?? items[0]));
+  const older =
+    start > 0 || (view.headOlder ?? headSourceFor(view.head[0] ?? items[0], runtimeArchiveRange(wire)) !== null);
   const cache = view.cache;
   if (cache && cache.wire === wire && cache.start === start && cache.head === view.head && cache.older === older) {
     return cache.value;
@@ -223,10 +239,96 @@ export function windowTranscriptSnapshot(entry, wire) {
   return value;
 }
 
-/** Load durable history OLDER than the runtime's first item when a grown
- *  window reaches past what the runtime holds (a resumed runtime restores
- *  only a bounded tail). Items align by their deterministic restore ids.
- *  Returns whether durable history was read. */
+/** Where older rows above `first` come from: durable history aligned by
+ *  restore ids (which continues into the compaction archive), or — once the
+ *  runtime's rows are not restored ones (a live compaction archived them, or
+ *  nothing was restored) — compaction-archive pages alone. */
+function headSourceFor(first, archive) {
+  const restoredId = RESTORED_ITEM_ID.test(String(first?.id ?? ''));
+  if (restoredId && first?.archived !== true) return restoredAfterFirstMessage(first) || archive ? 'stored' : null;
+  if (archive) return 'archive';
+  // A compaction archived the first loaded restored row, but the runtime holds
+  // no archive range: older rows still align through durable history.
+  return restoredId && restoredAfterFirstMessage(first) ? 'stored' : null;
+}
+
+/** Whether a live row shows that a compaction rewrote this runtime's rows. */
+function isCompactionMark(item) {
+  return item?.archived === true || (item?.kind === 'statusdone' && item.status === 'compacted');
+}
+
+/** The runtime's compaction generation: it only grows, because every
+ *  compaction adds a divider and archives rows. A loaded head is valid only
+ *  for the generation it was loaded in. */
+function compactionGeneration(items) {
+  return items.reduce((count, item) => count + (isCompactionMark(item) ? 1 : 0), 0);
+}
+
+/** Where `first` sits in durable history, or -1. Restore ids are positional
+ *  and only comparable while no compaction touched the live rows (or when
+ *  `first` itself came from this durable history). Across a compaction the
+ *  live `hist_…` ids and the durable `arch…`/renumbered ids describe
+ *  different positions, so nothing but one verified stable identity aligns. */
+function alignedHistoryIndex(history, first, live, fromHistory) {
+  if (!first) return -1;
+  if (fromHistory || !live.some(isCompactionMark)) return history.findIndex((item) => item?.id === first.id);
+  const index = verifiedIdentityIndex(history, first, live);
+  return index >= 0 && !prefixRepeatsLiveRow(history.slice(0, index), live) ? index : -1;
+}
+
+/** Whether a proposed older prefix holds a row whose stable identity (kind +
+ *  `messageId`, or a tool call id) the live window already shows: joining it
+ *  would show that row twice. */
+function prefixRepeatsLiveRow(prefix, live) {
+  const messages = new Set();
+  const calls = new Set();
+  for (const item of live) {
+    if (item?.messageId) messages.add(`${item.kind}\0${item.messageId}`);
+    for (const callId of toolCallIds(item)) calls.add(callId);
+  }
+  return prefix.some(
+    (item) =>
+      (item?.messageId && messages.has(`${item.kind}\0${item.messageId}`)) ||
+      toolCallIds(item).some((callId) => calls.has(callId))
+  );
+}
+
+/** The tool call ids a tool row carries (single card or aggregate). */
+function toolCallIds(item) {
+  const ids = Array.isArray(item?.callIds) ? item.callIds : [];
+  return item?.callId ? [item.callId, ...ids] : ids;
+}
+
+/** The one durable row that is the copy of live row `first`, by stable
+ *  identity only: same kind and `messageId` for message rows; for tool rows
+ *  every call id of `first` is in the durable row, which holds no call the
+ *  live window lacks (an archive aggregate merging a call that is not live
+ *  would otherwise drop it). No identity, no match, or more than one match:
+ *  -1 — nothing is guessed. */
+function verifiedIdentityIndex(history, first, live) {
+  const calls = toolCallIds(first);
+  const liveCalls = new Set(live.flatMap(toolCallIds));
+  const matches = [];
+  history.forEach((item, index) => {
+    if (item?.kind !== first.kind) return;
+    if (calls.length) {
+      const own = toolCallIds(item);
+      if (calls.every((callId) => own.includes(callId)) && own.every((callId) => liveCalls.has(callId))) {
+        matches.push(index);
+      }
+    } else if (first.kind !== 'tool' && first.messageId && item.messageId === first.messageId) {
+      matches.push(index);
+    }
+  });
+  return matches.length === 1 ? matches[0] : -1;
+}
+
+/** Load history OLDER than the runtime's first item when a grown window
+ *  reaches past what the runtime holds (a resumed runtime restores only a
+ *  bounded tail; a compaction moved earlier rows to the display-only
+ *  archive). Durable items align by their deterministic restore ids; archive
+ *  pages continue below the archived rows already held. Returns whether
+ *  durable history was read. */
 export async function loadLiveTranscriptHead(entry, sessionId, readStoredSession) {
   const view = entry.transcriptView;
   if (!view || view.full || !view.paged || typeof readStoredSession !== 'function' || view.headOlder === false) {
@@ -235,24 +337,52 @@ export async function loadLiveTranscriptHead(entry, sessionId, readStoredSession
   // Durable history continues the window only once it shows the runtime's
   // first item; a budgeted page may still be revealing runtime rows.
   if (view.start !== 0) return false;
-  const items = entry.runtime?.getState?.()?.items;
-  const runtimeItems = Array.isArray(items) ? items : [];
+  const state = entry.runtime?.getState?.();
+  const runtimeItems = Array.isArray(state?.items) ? state.items : [];
   const missing = view.limit - runtimeItems.length - view.head.length;
   const first = view.head[0] ?? runtimeItems[0];
-  if (missing <= 0 || !restoredAfterFirstMessage(first)) return false;
+  const archive = runtimeArchiveRange(state);
+  const source = view.headSource || headSourceFor(first, archive);
+  if (missing <= 0 || !source) return false;
+  const generation = compactionGeneration(runtimeItems);
+  if (view.head.length && view.headGeneration !== generation) {
+    // A compaction since the head was loaded: keep the rows as they are, and
+    // never join older rows across the generation.
+    view.headOlder = false;
+    return true;
+  }
   const pageBudget = view.grow ? view.grow.byteBudget : null;
-  const stored = await readStoredSession(sessionId, { transcriptItemLimit: view.limit + runtimeItems.length });
-  if (entry.transcriptView !== view || (view.head[0] ?? entry.runtime?.getState?.()?.items?.[0]) !== first) {
+  const currentItems = () => entry.runtime?.getState?.()?.items;
+  const stillCurrent = () =>
+    entry.transcriptView === view &&
+    (view.head[0] ?? currentItems()?.[0]) === first &&
+    compactionGeneration(Array.isArray(currentItems()) ? currentItems() : []) === generation;
+  if (source === 'archive') {
+    const page = await readStoredSession(sessionId, {
+      compactionArchive: { ...archive, skip: view.archiveHeld || 0, limit: missing },
+    });
+    if (!stillCurrent()) return true;
+    const rows = Array.isArray(page?.items) ? page.items : [];
+    const from = budgetedStart(rows, rows.length, missing, pageBudget, TRANSCRIPT_WINDOW_MIN_ITEMS);
+    view.head = sanitizeForWire(rows.slice(from)).concat(view.head);
+    view.archiveHeld = (view.archiveHeld || 0) + rows.length - from;
+    view.headSource = 'archive';
+    view.headGeneration = generation;
+    view.headOlder = from > 0 || page?.hasOlder === true;
     return true;
   }
+  const stored = await readStoredSession(sessionId, { transcriptItemLimit: view.limit + runtimeItems.length });
+  if (!stillCurrent()) return true;
   const history = Array.isArray(stored?.items) ? stored.items : [];
-  const overlap = history.findIndex((item) => item?.id === first.id);
+  const overlap = alignedHistoryIndex(history, first, view.head.concat(runtimeItems), view.head.length > 0);
   if (overlap < 0) {
     view.headOlder = false;
     return true;
   }
   const from = budgetedStart(history, overlap, missing, pageBudget, TRANSCRIPT_WINDOW_MIN_ITEMS);
   view.head = sanitizeForWire(history.slice(from, overlap)).concat(view.head);
+  view.headSource = 'stored';
+  view.headGeneration = generation;
   view.headOlder = from > 0 || stored.transcriptHasOlder === true;
   return true;
 }

package/src/standalone/session-service/projection/workspace.mjs

@@ -0,0 +1,14 @@
+// Live execution root of a daemon entry. `entry.cwd` is captured at creation;
+// a workspace transition moves the session's cwd without recreating the entry,
+// so the projected `state.workspace` (cwd + revision) is the authority and the
+// entry mirrors it every time a state is projected.
+
+/** Mirror `state.workspace` onto the entry; states without one change nothing. */
+export function syncEntryWorkspace(entry, state) {
+  const workspace = state?.workspace;
+  if (!entry || !workspace || typeof workspace !== 'object') return;
+  if (typeof workspace.cwd === 'string' && workspace.cwd) entry.cwd = workspace.cwd;
+  if (Number.isSafeInteger(workspace.revision) && workspace.revision >= 0) {
+    entry.workspaceRevision = workspace.revision;
+  }
+}

package/src/standalone/session-service/session-calls/session-action.mjs

@@ -5,7 +5,7 @@ import { SESSION_CONFIGURE_ACTION_SET, SESSION_READ_ACTION_SET } from '../../ses
 import { sanitizeForWire } from '../../session-wire-values.mjs';
 
 /** Reads a session without a live runtime answers from disk (readStoredReview). */
-const STORED_REVIEW_ACTIONS = new Set(['getTurnReviewDiff', 'getSessionReviewDiff']);
+const STORED_REVIEW_ACTIONS = new Set(['getTurnReviewDiff', 'getSessionReviewDiff', 'getTurnChanges']);
 
 /** One compact description of an action result for the daemon log, never the payload itself. */
 function resultSummary(value) {
@@ -22,8 +22,16 @@ function requireSessionAction(action, allowed) {
 }
 
 export function createSessionActionCalls(ctx) {
-  const { isClosed, log, listSessions, getRemoteSessionState, loadProjectStore, advanceForCaller, readStoredReview, responseSessionId } =
-    ctx;
+  const {
+    isClosed,
+    log,
+    listSessions,
+    getRemoteSessionState,
+    loadProjectStore,
+    advanceForCaller,
+    readStoredReview,
+    responseSessionId,
+  } = ctx;
   const { bodyForClient } = ctx.projection;
   const { retainUnwatched } = ctx.retention;
   const { assertAvailable, hostedEntryForSession, entryForSession } = ctx.entries;