mixdog 1.1.1 → 1.2.0

package/src/runtime/agent/orchestrator/session/manager/session-prompt-composition.mjs

@@ -60,6 +60,33 @@ function buildShellEnvironmentContext(opts, ownerIsAgent, toolsForRouting) {
     .join('\n');
 }
 
+/**
+ * Workspace-scoped prompt facts for an existing session re-rooted at `cwd`
+ * (a Lead workspace change or a worker following its Lead): the shell/git/
+ * listing environment and the instruction files of the new root, derived
+ * exactly as at creation. `undefined` means "keep what the session has": a
+ * tool-free role carries neither, a profile skipping instruction files keeps
+ * none.
+ * @returns {{ environmentContext: string|undefined, instructionFilesContext: string|undefined }}
+ */
+export function buildWorkspacePromptContext(session, cwd) {
+  const ownerIsAgent = session?.owner === 'agent';
+  const toolFreeRole =
+    ownerIsAgent && Array.isArray(session?.schemaAllowedTools) && session.schemaAllowedTools.length === 0;
+  if (toolFreeRole) return { environmentContext: undefined, instructionFilesContext: undefined };
+  const tools = [
+    ...(Array.isArray(session?.tools) ? session.tools : []),
+    ...(Array.isArray(session?.deferredToolCatalog) ? session.deferredToolCatalog : []),
+  ];
+  return {
+    environmentContext: buildShellEnvironmentContext({ cwd }, ownerIsAgent, tools),
+    instructionFilesContext:
+      session?.skipInstructionFiles === true
+        ? undefined
+        : loadInstructionFilesContext({ mode: configuredInstructionFilesMode(), cwd }),
+  };
+}
+
 // BP1/BP2/BP3 rule blocks plus the volatile environment, composed into the
 // four system blocks; environmentTailContext is the persisted env tail.
 export function composeSessionSystem(opts, { profile, providerName, modelName, surface }) {

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/manager.mjs

@@ -1,9 +1,5 @@
 // src/runtime/agent/orchestrator/session/manager.mjs
-// Thin facade over the split session-manager modules in ./manager/. This file
-// re-exports the EXACT public surface the previous monolith exposed so every
-// importer (loop.mjs, loop/tool-exec.mjs, agent-dispatch.mjs, session-builder,
-// abort-lookup, statusline-agents, headless-role, session-runtime, and the
-// smoke scripts) keeps resolving its symbols through manager.mjs unchanged.
+// Thin facade over the split session-manager modules in ./manager/.
 //
 // Module map:
 //   manager/runtime-liveness.mjs       — in-memory stage/heartbeat + accessors

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/read-dedup.mjs

@@ -1,5 +1,4 @@
 // Thin re-export facade — re-exports all cache symbols from their split modules.
-// Existing import paths keep working unchanged.
 export * from './cache/read-cache.mjs';
 export * from './cache/scoped-cache.mjs';
 export * from './cache/prefetch-cache.mjs';

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,