mixdog 1.1.2 → 1.2.0

package/src/runtime/agent/orchestrator/session/manager/session-record.mjs

@@ -92,7 +92,18 @@ export function sessionOriginFields(opts, { profile, presetObj, providerCacheOpt
 
 // The persisted session record.
 export function buildSessionRecord({ opts, route, presetObj, surface, prompt, messages, contextMeta, origin }) {
-  const { providerName, modelName, toolPreset, effort, fast, modelParameters, contextPercent, id } = route;
+  const {
+    providerName,
+    modelName,
+    toolPreset,
+    effort,
+    fast,
+    autoEffort,
+    modelParameters,
+    contextPercent,
+    contextTokens,
+    id,
+  } = route;
   return {
     id,
     codexWireSessionId: providerName === 'openai-oauth' ? mintUuidV7() : null,
@@ -115,8 +126,11 @@ export function buildSessionRecord({ opts, route, presetObj, surface, prompt, me
     presetName: presetObj?.name || null,
     effort,
     fast,
+    // Absent means Auto effort is on; only the off state is persisted.
+    ...(autoEffort === false ? { autoEffort: false } : {}),
     modelParameters,
     contextPercent,
+    ...(contextTokens ? { contextTokens } : {}),
     selectedContextWindow: opts.selectedContextWindow || null,
     agent: opts.agent,
     owner: opts.owner || 'user',
@@ -144,6 +158,7 @@ export function buildSessionRecord({ opts, route, presetObj, surface, prompt, me
     lastHeartbeatAt: null,
     totalInputTokens: 0,
     totalOutputTokens: 0,
+    totalToolCalls: 0,
     // Refreshed on each completed ask() — surfaced by agent type=list for
     // debugging + consumed by store.mjs's idle-sweep to reclaim stalled
     // agent sessions past RUNNING_STALL_MS.

package/src/runtime/agent/orchestrator/session/manager/status-telemetry.mjs

@@ -35,6 +35,7 @@ function standaloneStatusRouteInfo(session) {
     modelDisplay: session.modelDisplay || session.displayName || session.model,
     effort: session.effort || '',
     fast: session.fast === true,
+    ...(session.autoEffort === false ? { autoEffort: false } : {}),
     modelParameters: session.modelParameters || {},
     contextWindow: session.contextWindow || null,
     rawContextWindow: session.rawContextWindow || session.contextWindow || null,

package/src/runtime/agent/orchestrator/session/manager/usage-metrics.mjs

@@ -390,6 +390,7 @@ export function applyAskTerminalUsageTotals(session, result, options = {}) {
     accumulateSessionUsage(session, {
       deltaInput: result.usage.inputTokens || 0,
       deltaOutput: result.usage.outputTokens || 0,
+      deltaToolCalls: result.toolCallsTotal || 0,
       ...reasoningUsage(result.usage),
       deltaCachedRead: result.usage.cachedTokens || 0,
       deltaCacheWrite: result.usage.cacheWriteTokens || 0,
@@ -465,6 +466,7 @@ function accumulateSessionUsage(session, delta) {
       : uncachedInputTokensForProvider(session.provider, deltaInput, deltaCachedRead, deltaCacheWrite);
   session.totalInputTokens = (session.totalInputTokens || 0) + (deltaInput || 0);
   session.totalOutputTokens = (session.totalOutputTokens || 0) + (deltaOutput || 0);
+  session.totalToolCalls = (session.totalToolCalls || 0) + (delta.deltaToolCalls || 0);
   session.tokensCumulative = (session.tokensCumulative || 0) + (deltaInput || 0) + (deltaOutput || 0);
   session.totalCachedReadTokens = (session.totalCachedReadTokens || 0) + (deltaCachedRead || 0);
   session.totalCacheWriteTokens = (session.totalCacheWriteTokens || 0) + (deltaCacheWrite || 0);

package/src/runtime/agent/orchestrator/session/message-ids.mjs

@@ -0,0 +1,123 @@
+/**
+ * Stable per-message identity: `meta.transcript.messageId`.
+ *
+ * Prompts and replies get theirs at creation (shared/transcript-metadata.mjs).
+ * Every other message — tool calls and results, injected rows, legacy
+ * transcripts — is stamped before a compaction runs or a stored session is
+ * resumed (stampMessageIds), and every compaction rewrite carries the id of
+ * the message it rewrites to its copy (spread copies keep `meta`;
+ * constructed copies use carryMessageId). A compaction's dropped messages
+ * are then exactly the ids its result no longer holds.
+ *
+ * A message whose `meta` is a string marker ('skill', 'hook': injected
+ * model context that is never displayed) cannot carry an id without changing
+ * what that marker means; it stays unstamped and has no display identity.
+ *
+ * Leaf module: no store, no config.
+ */
+import { createHash } from 'node:crypto';
+
+/** The message's stable id, or ''. */
+export function messageIdOf(message) {
+  const meta = message?.meta;
+  if (!meta || typeof meta !== 'object') return '';
+  const id = meta.transcript?.messageId;
+  return typeof id === 'string' ? id : '';
+}
+
+/** Whether `meta` can hold a transcript id (absent or a plain object). */
+export function canCarryMessageId(message) {
+  if (!message || typeof message !== 'object') return false;
+  const meta = message.meta;
+  return meta === undefined || meta === null || (typeof meta === 'object' && !Array.isArray(meta));
+}
+
+function withMessageId(meta, messageId) {
+  const base = meta && typeof meta === 'object' ? meta : {};
+  const transcript = base.transcript && typeof base.transcript === 'object' ? base.transcript : {};
+  return { ...base, transcript: { ...transcript, messageId } };
+}
+
+// A deterministic seed: the same unstamped transcript gets the same ids on
+// every stamping (a legacy session reopened twice before its stamps are
+// saved keeps them; two compactions of one transcript agree). The content
+// part is bounded — its length and edges, media by kind and size — so
+// stamping never serializes whole images or documents. The position keeps
+// equal messages apart.
+const SEED_EDGE_CHARS = 512;
+function boundedText(value) {
+  const text = String(value);
+  if (text.length <= SEED_EDGE_CHARS * 2) return text;
+  return `${text.slice(0, SEED_EDGE_CHARS)}\u0000${text.length}\u0000${text.slice(-SEED_EDGE_CHARS)}`;
+}
+function boundedContent(content) {
+  if (typeof content === 'string') return boundedText(content);
+  if (!Array.isArray(content)) return content == null ? '' : typeof content;
+  return content
+    .map((part) => {
+      if (!part || typeof part !== 'object') return String(part);
+      if (typeof part.text === 'string') return `t:${boundedText(part.text)}`;
+      const data = part.data ?? part.source?.data ?? part.image_url?.url ?? part.url ?? part.ref ?? '';
+      return `${part.type || 'part'}:${typeof data === 'string' ? data.length : 0}`;
+    })
+    .join('\u0001');
+}
+function seededMessageId(sessionId, index, message) {
+  const calls = Array.isArray(message.toolCalls) ? message.toolCalls : message.tool_calls;
+  const callIds = Array.isArray(calls) ? calls.map((call) => call?.id || '').join(',') : '';
+  const seed = [
+    sessionId,
+    index,
+    message.role,
+    message.toolCallId || message.tool_call_id || '',
+    callIds,
+    boundedContent(message.content),
+  ].join('\u0002');
+  return `msg_${createHash('sha1').update(seed).digest('hex').slice(0, 32)}`;
+}
+
+/** Stamp a stable id on every message that can carry one and has none, in
+ *  place. Returns how many were stamped (the caller persists them). */
+export function stampMessageIds(messages, { sessionId = '' } = {}) {
+  if (!Array.isArray(messages)) return 0;
+  let stamped = 0;
+  const seen = new Set();
+  messages.forEach((message, index) => {
+    const existing = messageIdOf(message);
+    if (existing) {
+      seen.add(existing);
+      return;
+    }
+    if (!canCarryMessageId(message)) return;
+    let id = seededMessageId(String(sessionId || ''), index, message);
+    // Never two messages with one id within a transcript.
+    for (let salt = 1; seen.has(id); salt += 1) id = seededMessageId(`${sessionId}#${salt}`, index, message);
+    seen.add(id);
+    message.meta = withMessageId(message.meta, id);
+    stamped += 1;
+  });
+  return stamped;
+}
+
+/** JSON.stringify replacer that leaves stable ids out: hashes and archives
+ *  the compactor derives from message JSON describe the conversation, not
+ *  its display bookkeeping (a meta that only held the id is left out too). */
+export function withoutMessageIdsReplacer(key, value) {
+  if (key !== 'meta' || !value || typeof value !== 'object' || typeof value.transcript?.messageId !== 'string') {
+    return value;
+  }
+  const { messageId: _id, ...transcript } = value.transcript;
+  const meta = { ...value };
+  if (Object.keys(transcript).length) meta.transcript = transcript;
+  else delete meta.transcript;
+  return Object.keys(meta).length ? meta : undefined;
+}
+
+/** `copy` carrying the stable id of `original` (a compaction rewrite that
+ *  builds a new message instead of spreading the original). Only the id
+ *  travels; the copy's own meta is kept. */
+export function carryMessageId(copy, original) {
+  const id = messageIdOf(original);
+  if (!id || !canCarryMessageId(copy) || messageIdOf(copy) === id) return copy;
+  return { ...copy, meta: withMessageId(copy.meta, id) };
+}

package/src/runtime/agent/orchestrator/session/message-ids.test-support.mjs

@@ -0,0 +1,29 @@
+// Tests that compare a transcript before and after a compaction: compaction
+// stamps stable ids (message-ids.mjs) on messages that had none, which is
+// bookkeeping, not a change of the conversation.
+
+/** `messages` without the stable ids stamped on them (and without the meta a
+ *  stamp alone created). */
+export function withoutStampedIds(messages) {
+  return messages.map((message) => {
+    const transcript = message?.meta?.transcript;
+    if (!transcript?.messageId) return message;
+    const { messageId: _id, ...rest } = transcript;
+    const meta = { ...message.meta };
+    if (Object.keys(rest).length) meta.transcript = rest;
+    else delete meta.transcript;
+    const out = { ...message };
+    if (Object.keys(meta).length) out.meta = meta;
+    else delete out.meta;
+    return out;
+  });
+}
+
+/** Whether every message that can carry an id has one. */
+export function everyMessageStamped(messages) {
+  return messages.every(
+    (message) =>
+      (message?.meta !== undefined && (typeof message.meta !== 'object' || message.meta === null)) ||
+      typeof message?.meta?.transcript?.messageId === 'string'
+  );
+}

package/src/runtime/agent/orchestrator/session/pre-send-compact.mjs

@@ -29,20 +29,14 @@ import { traceAgentCompact, messagePrefixHash } from '../agent-trace.mjs';
 import { invalidateProviderRequestToolsScope } from '../runtime-core/provider-request-tools.mjs';
 import { bumpUsageMetricsEpoch } from './manager/usage-metrics.mjs';
 import { resetReadStateAfterCompaction } from './read-dedup.mjs';
+import { scheduleCompactionArchive, stampCompactionMessageIds } from './compaction-archive-capture.mjs';
+import { writeStderrBestEffort } from '../../../shared/best-effort-stderr.mjs';
 import {
   acknowledgePendingGoalReminder,
   markPendingGoalReminder,
   snapshotPendingGoalReminder,
 } from '../runtime-core/goal-reminder.mjs';
 
-function writeStderr(line) {
-  try {
-    process.stderr.write(line);
-  } catch {
-    /* best-effort */
-  }
-}
-
 async function setStage(opts, stage) {
   try {
     await opts.onStageChange?.(stage);
@@ -126,20 +120,23 @@ function preSendCompactDecision(state, compactPolicy) {
       activeTurn: true,
     }).reducesTokens;
   }
+  let compactTrigger = 'auto';
+  if (reactivePending) compactTrigger = 'reactive';
+  else if (cacheExpired) compactTrigger = 'cache_expired';
   return {
     messageTokensEst,
     pressureTokens,
     shouldCompact,
     requireReduction,
-    compactTrigger: reactivePending ? 'reactive' : cacheExpired ? 'cache_expired' : 'auto',
+    compactTrigger,
     compactBudgetTokens,
   };
 }
 
-// Gauge sync (user: 컴팩트될 때 컨텍스트 표기량이 달랐다). The host refreshes
-// its context readout on provider usage deltas and turn end, so a tool batch
-// that pushed the transcript over the trigger fired compaction while the
-// screen still showed headroom. Publish the decision's OWN numerator here —
+// Gauge sync. The host refreshes its context readout only on provider usage
+// deltas and turn end, so a tool batch that pushed the transcript over the
+// trigger would compact while the screen still showed headroom. Publish the
+// decision's OWN numerator here —
 // before compaction mutates the transcript — so the readout and the trigger
 // describe one moment.
 function publishContextPressure(opts, sessionId, compactPolicy, { pressureTokens, shouldCompact }) {
@@ -158,15 +155,14 @@ function publishContextPressure(opts, sessionId, compactPolicy, { pressureTokens
 }
 
 // Pre/PostCompact bridge to the standard hook bus: a session-property hook
-// (manager/loop have no bus access), { trigger } normalized to
-// 'auto'|'manual'. Best-effort — a hook must never break compaction or the
-// loop.
+// (manager/loop have no bus access); a pre-send pass is always trigger
+// 'auto'. Best-effort — a hook must never break compaction or the loop.
 async function runCompactHook(ctx, name) {
   const { opts, sessionRef, sessionId, cwd } = ctx.state;
   const hook = typeof opts[name] === 'function' ? opts[name] : sessionRef?.[name];
   if (typeof hook !== 'function') return;
   try {
-    await hook({ sessionId, cwd, trigger: ctx.decision.compactTrigger === 'manual' ? 'manual' : 'auto' });
+    await hook({ sessionId, cwd, trigger: 'auto' });
   } catch {
     /* best-effort */
   }
@@ -342,7 +338,7 @@ function throwCompactFailure(ctx, run, compactErr) {
   const { sessionRef, sessionId, signal, model } = state;
   acknowledgeGoalReminder(sessionRef, run);
   if (isCompactAbort(signal, compactErr)) {
-    writeStderr(
+    writeStderrBestEffort(
       `[loop] pre-send compact cancelled (sess=${sessionId || 'unknown'}): ${compactErr?.message || compactErr}\n`
     );
     throw compactErr;
@@ -381,8 +377,16 @@ function throwCompactFailure(ctx, run, compactErr) {
 function adoptCompactedTranscript(ctx, run) {
   const { state } = ctx;
   const { messages, sessionRef, sessionId, opts } = state;
+  const replaced = messages.slice();
   messages.length = 0;
   messages.push(...run.compacted);
+  // Display-only archive of the dropped conversation; the projection and the
+  // write run off this synchronous adoption.
+  const archived = sessionRef
+    ? scheduleCompactionArchive({ session: sessionRef, sessionId, before: replaced, after: messages })
+    : null;
+  ctx.droppedMessages = archived?.dropped ?? 0;
+  ctx.droppedIdentities = archived?.identities ?? null;
   acknowledgeGoalReminder(sessionRef, run);
   resetReadStateAfterCompaction(sessionId);
   // Cross-turn receipts reference tool results that compaction just removed
@@ -451,6 +455,8 @@ function reportCompactOutcome(ctx, run) {
     status: changed ? 'compacted' : 'no_change',
     afterTokens,
     changed,
+    droppedMessages: ctx.droppedMessages || 0,
+    droppedIdentities: ctx.droppedIdentities || null,
     freshContext: freshContextResult?.freshContext === true,
     handoffSource: freshContextResult?.handoffSource || null,
     durationMs,
@@ -460,6 +466,10 @@ function reportCompactOutcome(ctx, run) {
 async function compactBeforeSend(ctx) {
   const { state, decision } = ctx;
   const { messages, sessionRef, sessionId, opts } = state;
+  // Every message enters the compaction with a stable id (legacy ones are
+  // stamped now; the turn's saves persist them): the result's rewrites carry
+  // it, so what was dropped is exactly the ids the result no longer holds.
+  stampCompactionMessageIds(messages, sessionId || sessionRef?.id || '');
   // Snapshot BEFORE mutating the live array below, so compact_meta reports
   // real savings and the true input prefix rather than the replacement
   // transcript.
@@ -489,7 +499,7 @@ async function compactBeforeSend(ctx) {
       await compactTranscript(ctx, run);
     } catch (freshErr) {
       run.freshContextError = freshErr;
-      writeStderr(
+      writeStderrBestEffort(
         `[loop] fresh-context compact failed (sess=${sessionId || 'unknown'}): ${freshErr?.message || freshErr}\n`
       );
       throw freshErr;

package/src/runtime/agent/orchestrator/session/store/session-delete.mjs

@@ -31,6 +31,7 @@ import { _uncacheSessionSummary, _queueSessionSummaryRemoval } from './summary-c
 import { _savePending, _clearDebounce, _releasePendingSlot } from './pending-saves.mjs';
 import { _runtimeLivenessVeto, _heartbeatLivenessVeto, _deleteHeartbeatUnlessNewer } from './liveness-veto.mjs';
 import { _runSessionPurgeHooks } from './session-observers.mjs';
+import { deleteCompactionArchive } from '../compaction-archive.mjs';
 
 /** Strictly enumerate child-agent session files linked to one visible parent.
  * Used only by explicit parent deletion; ordinary close/context switches keep
@@ -130,6 +131,8 @@ export function deleteSession(id, options = {}) {
     // Preserve a sidecar published strictly after the sweep's scan snapshot.
     _deleteHeartbeatUnlessNewer(id, options);
     deleteSessionPresence(id);
+    // The display-only compaction archive has no meaning without its session.
+    deleteCompactionArchive(getStoreDir(), id);
     _clearLiveSession(id);
     // The file is gone: every marker of the retired incarnation goes with it
     // (save error + failed-snapshot evidence, split-brain drop flag, lifecycle

package/src/runtime/agent/orchestrator/session/store/sweep/sweep-finish.mjs

@@ -6,6 +6,7 @@ import { join } from 'node:path';
 import { probePath, PROBE_PRESENT, PROBE_ABSENT } from '../fs-probe.mjs';
 import { _queueSummaryIndexPrune } from '../summary-cache.mjs';
 import { deleteSession } from '../session-delete.mjs';
+import { COMPACTION_ARCHIVE_SUFFIX } from '../../compaction-archive.mjs';
 
 /** Retention cap: prune resumable open (non-tombstone) sessions newest-first
  *  — keep the most recent openMaxCount, prune anything older than openMaxAgeMs
@@ -47,18 +48,24 @@ export function pruneOpenCandidates({ plan, now, tally }) {
   }
 }
 
-/** Orphan .hb/.own reap: a heartbeat/presence sidecar whose .json no longer
+/** Orphan .hb/.own/compaction-archive reap: a sidecar whose .json no longer
  *  exists is dead weight once it is also stale (older than maxAge) — the
  *  session JSON was swept/closed but the sidecar lingered (crashed owner or
  *  pre-fix orphan). The staleness gate avoids nuking the sidecar of a session
  *  mid-create whose .json write has not landed yet. Yields between sidecars
  *  like the row loop. */
 export function* reapOrphanSidecars({ plan, dir, now, tally }) {
+  const recordOf = (sidecar) =>
+    sidecar.endsWith(COMPACTION_ARCHIVE_SUFFIX)
+      ? `${sidecar.slice(0, -COMPACTION_ARCHIVE_SUFFIX.length)}.json`
+      : sidecar.replace(/\.(hb|own)$/, '.json');
   try {
-    for (const h of readdirSync(dir).filter((f) => f.endsWith('.hb') || f.endsWith('.own'))) {
+    for (const h of readdirSync(dir).filter(
+      (f) => f.endsWith('.hb') || f.endsWith('.own') || f.endsWith(COMPACTION_ARCHIVE_SUFFIX)
+    )) {
       yield undefined;
       // Only a PROVEN-absent session file makes its sidecar an orphan.
-      if (probePath(join(dir, h.replace(/\.(hb|own)$/, '.json'))).state !== PROBE_ABSENT) continue;
+      if (probePath(join(dir, recordOf(h))).state !== PROBE_ABSENT) continue;
       const sidecarProbe = probePath(join(dir, h));
       if (sidecarProbe.state !== PROBE_PRESENT) continue;
       if (now - sidecarProbe.mtimeMs > plan.maxAge) {

package/src/runtime/agent/orchestrator/session/store-agent-worker-rows.mjs

@@ -27,6 +27,7 @@ import {
   storedLeadWorkerIndexPath,
 } from './store-summary-locations.mjs';
 import { cleanValue, isStoredSessionId, positiveNumber } from './store-summary-fields.mjs';
+import { sessionUsageTotals } from '../../../shared/session-usage-totals.mjs';
 
 const DEAD_AGENT_STATUS =
   /^(?:done|complete|completed|success|closed|error|fail|failed|cancelled|canceled|killed|timeout)$/i;
@@ -223,6 +224,7 @@ const WORKER_HEADER_FIELDS = [
   'model',
   'effort',
   'fast',
+  'autoEffort',
   'createdAt',
   'updatedAt',
   'cwd',
@@ -234,6 +236,9 @@ const WORKER_HEADER_FIELDS = [
   'startedAt',
   'cancelledAt',
   'finishedAt',
+  'totalInputTokens',
+  'totalOutputTokens',
+  'totalToolCalls',
   ...SESSION_CANCEL_FIELDS,
 ];
 
@@ -321,6 +326,7 @@ function projectChildWorkerRow(row, { now, heartbeatMtimes }) {
     model: cleanValue(row.model || session?.model) || null,
     effort: cleanValue(row.effort || session?.effort) || null,
     fast: row.fast === true || session?.fast === true,
+    ...(row.autoEffort === false || session?.autoEffort === false ? { autoEffort: false } : {}),
     status: declaredWorking && !working ? 'unknown' : declaredStatus,
     stage: declaredWorking && !working ? 'unknown' : declaredStage,
     // A live turn blocked on the user's approval (persisted by the agent
@@ -335,6 +341,7 @@ function projectChildWorkerRow(row, { now, heartbeatMtimes }) {
     cwd: cleanValue(row.cwd || session?.cwd) || null,
     clientHostPid: positiveNumber(row.clientHostPid || session?.clientHostPid, 0) || null,
     taskId: cleanValue(row.task_id || row.taskId) || null,
+    ...sessionUsageTotals(session),
   };
 }
 
@@ -356,6 +363,7 @@ function sidecarWorkerRow(
     model: cleanValue(session?.model) || current.model || null,
     effort: cleanValue(session?.effort) || current.effort || null,
     fast: session?.fast === true || current.fast === true,
+    ...(session?.autoEffort === false || current.autoEffort === false ? { autoEffort: false } : {}),
     status,
     stage: status,
     startedAt: session?.createdAt || current.startedAt || heartbeatAt,
@@ -365,6 +373,7 @@ function sidecarWorkerRow(
     cwd: cleanValue(session?.cwd) || current.cwd || null,
     clientHostPid: positiveNumber(session?.clientHostPid, 0) || current.clientHostPid || null,
     taskId: cleanValue(session?.task_id || session?.taskId) || current.taskId || null,
+    ...sessionUsageTotals(session),
   };
 }
 
@@ -458,6 +467,7 @@ function projectLeadWorkerRow(row, { now, heartbeatMtimes }) {
     model: cleanValue(row.model) || null,
     effort: cleanValue(row.effort) || null,
     fast: row.fast === true,
+    ...(row.autoEffort === false ? { autoEffort: false } : {}),
     status: shownStatus,
     stage: shownStatus,
     startedAt: row.startedAt || row.createdAt || null,
@@ -468,6 +478,7 @@ function projectLeadWorkerRow(row, { now, heartbeatMtimes }) {
     cwd: cleanValue(row.cwd) || null,
     clientHostPid: positiveNumber(row.clientHostPid, 0) || null,
     taskId: cleanValue(row.task_id || row.taskId) || null,
+    ...sessionUsageTotals(readWorkerSessionHeader(sessionId)),
   };
 }
 

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

@@ -19,6 +19,35 @@ export function cleanValue(value) {
   return String(value || '').trim();
 }
 
+const textOrNull = (value) => cleanValue(typeof value === 'string' ? value : '') || null;
+const TRANSITION_STATES = new Set(['idle', 'provisioning', 'switching', 'removing', 'recovery']);
+
+/** Catalog view of a session workspace record (the SessionWorkspace shape of
+ *  runtime/shared/worktrees/contract.mjs): where it executes (`cwd`, `branch`,
+ *  `worktreeId`) under which registered Project (`projectPath`), at which
+ *  `revision`. Null when the record is absent or lacks either path, so
+ *  consumers group by `projectPath` and never mistake a worktree `cwd` for
+ *  the project. */
+export function workspaceSummary(value) {
+  if (!value || typeof value !== 'object') return null;
+  const projectPath = cleanValue(typeof value.projectPath === 'string' ? value.projectPath : '');
+  const cwd = cleanValue(typeof value.cwd === 'string' ? value.cwd : '');
+  if (!projectPath || !cwd || projectPath.includes('\0') || cwd.includes('\0')) return null;
+  const state = TRANSITION_STATES.has(value.transition?.state) ? value.transition.state : 'idle';
+  const txId = state === 'idle' ? null : textOrNull(value.transition?.txId);
+  return {
+    projectPath,
+    repoCommonDir: textOrNull(value.repoCommonDir),
+    cwd,
+    worktreeId: textOrNull(value.worktreeId),
+    branch: textOrNull(value.branch),
+    baseCommit: textOrNull(value.baseCommit),
+    mergeTarget: textOrNull(value.mergeTarget),
+    revision: Number.isSafeInteger(value.revision) && value.revision >= 0 ? value.revision : 0,
+    transition: txId ? { state, txId } : { state: 'idle', txId: null },
+  };
+}
+
 export function desktopSession(value, cwd = '') {
   if (!value || typeof value !== 'object') return null;
   if (value.classification === 'task') return { classification: 'task', projectPath: null };

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

@@ -26,7 +26,7 @@ import {
   sessionMessageText,
 } from '../runtime-core/session-text.mjs';
 import { sessionVisibility } from './store-summary-visibility.mjs';
-import { isStoredSessionId, positiveNumber as _positiveNumber } from './store-summary-fields.mjs';
+import { isStoredSessionId, positiveNumber as _positiveNumber, workspaceSummary } from './store-summary-fields.mjs';
 
 export const SESSION_SUMMARY_INDEX_VERSION = 2;
 
@@ -182,11 +182,13 @@ export function _sessionSummary(session) {
     clientHostPid: _positiveNumber(session.clientHostPid, 0) || null,
     cwd: session.cwd || '',
     desktopSession: _desktopSessionSummary(session.desktopSession, session.cwd),
+    ...(workspaceSummary(session.workspace) ? { workspace: workspaceSummary(session.workspace) } : {}),
     provider: session.provider || null,
     model: session.model || null,
     presetName: session.presetName || session.profileId || null,
     effort: session.effort || null,
     fast: session.fast === true,
+    ...(session.autoEffort === false ? { autoEffort: false } : {}),
     modelParameters:
       session.modelParameters && typeof session.modelParameters === 'object' ? { ...session.modelParameters } : null,
     agentTag: session.agentTag || null,
@@ -231,11 +233,13 @@ function _normalizeSummaryRow(row) {
     clientHostPid: _positiveNumber(row.clientHostPid, 0) || null,
     cwd: row.cwd || '',
     desktopSession: _desktopSessionSummary(row.desktopSession, row.cwd),
+    ...(workspaceSummary(row.workspace) ? { workspace: workspaceSummary(row.workspace) } : {}),
     provider: row.provider || null,
     model: row.model || null,
     presetName: row.presetName || row.profileId || null,
     effort: row.effort || null,
     fast: row.fast === true,
+    ...(row.autoEffort === false ? { autoEffort: false } : {}),
     modelParameters: row.modelParameters && typeof row.modelParameters === 'object' ? { ...row.modelParameters } : null,
     agentTag: row.agentTag || null,
     task_id: row.task_id || null,

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

@@ -24,8 +24,9 @@ import {
 } from './store-transcript-worker.mjs';
 import { projectStoredTranscript } from './store-transcript-projection.mjs';
 import { dataDir, sessionHeartbeatMtimes } from './store-summary-locations.mjs';
-import { desktopSession, isStoredSessionId, positiveNumber } from './store-summary-fields.mjs';
+import { desktopSession, isStoredSessionId, positiveNumber, workspaceSummary } from './store-summary-fields.mjs';
 import { readArchivedAgentResult } from './store-summary-archived-agent.mjs';
+import { compactionArchivePath, readCompactionArchivePage } from './compaction-archive.mjs';
 import {
   readCanonicalSessionRecord as readCanonicalLifecycle,
   offerStrictSessionRecord,
@@ -132,6 +133,8 @@ function isLeadVisibleRow(row) {
   const sourceType = String(row.sourceType || '')
     .trim()
     .toLowerCase();
+  // Mirror listLeadSessions: one-shot `mixdog exec` runs stay out of Recent.
+  if (sourceType === 'exec') return false;
   const sourceName = String(row.sourceName || '')
     .trim()
     .toLowerCase();
@@ -200,6 +203,7 @@ function normalizedRow(row, heartbeatAt = 0) {
     clientHostPid: positiveNumber(row.clientHostPid, 0) || null,
     cwd: row.cwd || '',
     desktopSession: desktopSession(row.desktopSession, row.cwd),
+    ...(workspaceSummary(row.workspace) ? { workspace: workspaceSummary(row.workspace) } : {}),
     provider: row.provider || null,
     model: row.model || null,
     agentTag: row.agentTag || null,
@@ -426,11 +430,13 @@ function storedSessionMetadata(sessionId, session) {
     visibility: sessionVisibility(session),
     agentTag: session.agentTag || null,
     cwd: session.cwd || '',
+    ...(workspaceSummary(session.workspace) ? { workspace: workspaceSummary(session.workspace) } : {}),
     provider: session.provider || null,
     model: session.model || null,
     presetName: session.presetName || session.profileId || null,
     effort: session.effort || null,
     fast: session.fast === true,
+    ...(session.autoEffort === false ? { autoEffort: false } : {}),
     modelParameters: session.modelParameters || null,
     taskType: session.taskType || null,
     permission: session.permission || null,
@@ -452,6 +458,9 @@ function storedTranscriptInputPaths(sessionId) {
   return {
     recordPath: join(dataDir(), 'sessions', `${sessionId}.json`),
     checkpointPath: join(dataDir(), 'turn-checkpoints', `${sessionId}.json`),
+    // Written after the compaction commit that names it, so its identity
+    // joins the projection's.
+    archivePath: compactionArchivePath(join(dataDir(), 'sessions'), sessionId),
   };
 }
 
@@ -464,7 +473,7 @@ const STAMP_ABSENT_CODES = new Set(['ENOENT', 'ENOTDIR']);
 export function storedSessionTranscriptStamp(id) {
   const sessionId = String(id || '').trim();
   if (!isStoredSessionId(sessionId)) return null;
-  const { recordPath, checkpointPath } = storedTranscriptInputPaths(sessionId);
+  const { recordPath, checkpointPath, archivePath } = storedTranscriptInputPaths(sessionId);
   const settled = (path, absent) => {
     let stamp;
     try {
@@ -477,7 +486,8 @@ export function storedSessionTranscriptStamp(id) {
   };
   const record = settled(recordPath, null);
   const checkpoint = record && settled(checkpointPath, 'absent');
-  return checkpoint ? `${record}|${checkpoint}` : null;
+  const archive = checkpoint && settled(archivePath, 'absent');
+  return archive ? `${record}|${checkpoint}|${archive}` : null;
 }
 
 /** Read exactly one persisted session for a visible desktop pane. This never
@@ -489,8 +499,13 @@ export async function readStoredSessionTranscript(id, options = {}) {
   if (!isStoredSessionId(sessionId)) return null;
   // Same strict authority as the store, and the same fail-closed rule: an
   // absent, unreadable, ambiguous or foreign record yields no transcript.
-  const { recordPath, checkpointPath } = storedTranscriptInputPaths(sessionId);
+  const { recordPath, checkpointPath, archivePath } = storedTranscriptInputPaths(sessionId);
   if (options.metadataOnly === true) return readStoredSessionMetadata(recordPath, sessionId);
+  // One page of the display-only compaction archive (the live head loader
+  // pages it once a runtime's in-memory rows are exhausted).
+  if (options.compactionArchive && typeof options.compactionArchive === 'object') {
+    return readCompactionArchivePage(join(dataDir(), 'sessions'), sessionId, options.compactionArchive);
+  }
   // The checkpoint sidecar shapes the projection as much as the record does,
   // so its identity joins the cache fingerprint. Only a PROVABLY absent
   // checkpoint skips recovery: an unreadable probe must not silently
@@ -502,6 +517,7 @@ export async function readStoredSessionTranscript(id, options = {}) {
   if (recordStat.state === PROBE_ABSENT) return readArchivedAgentResult(sessionId);
   if (recordStat.state !== PROBE_PRESENT) return null;
   const checkpoint = probePath(checkpointPath);
+  const archive = probePath(archivePath);
   const requestedLimit = Number(options.transcriptItemLimit);
   const itemLimit = Number.isFinite(requestedLimit) && requestedLimit > 0 ? requestedLimit : Number.POSITIVE_INFINITY;
   let readState = PROBE_PRESENT;
@@ -525,6 +541,9 @@ export async function readStoredSessionTranscript(id, options = {}) {
       checkpoint.size,
       checkpoint.ino,
       checkpoint.dev,
+      archive.state,
+      archive.mtimeMs,
+      archive.size,
     ].join(':'),
     fileStat: recordStat,
     loadText: async () => {