mixdog 1.1.2 → 1.2.1

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

@@ -25,6 +25,8 @@ import {
 import { getProvider } from '../../providers/registry.mjs';
 import { isSessionCompactionBlocked, getSessionAbortSignal, _runtimeEntries } from './runtime-liveness.mjs';
 import { mintSessionId } from './session-id.mjs';
+import { hideCompactionArchive } from '../compaction-archive-capture.mjs';
+import { writeStderrBestEffort } from '../../../../shared/best-effort-stderr.mjs';
 
 /** Force-flush session metrics to disk. Used by watchdog terminal-reap (fix B). */
 export async function flushSessionMetrics(sessionId) {
@@ -97,14 +99,6 @@ export async function updateSessionManualTitle(id, title) {
   return true;
 }
 // --- Clear messages (keep system prompt + provider/model/cwd) ---
-function bestEffortStderr(line) {
-  try {
-    process.stderr.write(line);
-  } catch {
-    /* best-effort */
-  }
-}
-
 // Token/provider accounting a cleared transcript starts from; shared by the
 // live session and the cold fork of its outgoing transcript.
 function clearedTokenAccounting(now) {
@@ -112,6 +106,7 @@ function clearedTokenAccounting(now) {
     providerState: undefined,
     totalInputTokens: 0,
     totalOutputTokens: 0,
+    totalToolCalls: 0,
     reasoningUsage: null,
     totalCachedReadTokens: 0,
     totalCacheWriteTokens: 0,
@@ -133,11 +128,18 @@ async function compactBeforeClear(session, sessionId, clearOptions) {
   let clearCompactError = null;
   if (messages.length >= 3) {
     try {
-      const compactResult = await runSessionCompaction(session, { mode: 'manual', force: true, sessionId });
+      // The clear right after discards this compaction's display too, so it
+      // archives nothing (clear semantics are unchanged).
+      const compactResult = await runSessionCompaction(session, {
+        mode: 'manual',
+        force: true,
+        sessionId,
+        archive: false,
+      });
       if (compactResult?.error) clearCompactError = new Error(compactResult.error);
     } catch (err) {
       clearCompactError = err;
-      bestEffortStderr(`[session] auto-clear pre-compact failed (sess=${sessionId}): ${err?.message || err}\n`);
+      writeStderrBestEffort(`[session] auto-clear pre-compact failed (sess=${sessionId}): ${err?.message || err}\n`);
     }
     messages = Array.isArray(session.messages) ? session.messages : [];
   }
@@ -208,6 +210,11 @@ function forkOutgoingTranscript(session, messages, now) {
       ...clearedTokenAccounting(now),
     };
     delete fork.liveTurnMessages;
+    // The archive sidecar belongs to the source id; the fork has none.
+    if (fork.compaction?.archive) {
+      fork.compaction = { ...fork.compaction };
+      delete fork.compaction.archive;
+    }
     setLiveSession(fork);
     void saveSessionAsync(fork)
       .then(() => {
@@ -219,10 +226,10 @@ function forkOutgoingTranscript(session, messages, now) {
         evictLiveSession(forkId);
       })
       .catch((err) => {
-        bestEffortStderr(`[session] clear-fork save failed (sess=${forkId}): ${err?.message || err}\n`);
+        writeStderrBestEffort(`[session] clear-fork save failed (sess=${forkId}): ${err?.message || err}\n`);
       });
   } catch (err) {
-    bestEffortStderr(`[session] clear-fork failed (sess=${session.id}): ${err?.message || err}\n`);
+    writeStderrBestEffort(`[session] clear-fork failed (sess=${session.id}): ${err?.message || err}\n`);
   }
 }
 
@@ -277,6 +284,9 @@ export async function clearSessionMessages(sessionId, options = {}) {
     lastClearAfterMessageTokens: tokens.afterMessageTokens,
     lastClearCompactError: clearCompactError?.message || null,
   };
+  // A clear wipes the visible conversation: earlier compactions' archived
+  // display goes with it (nothing new is archived).
+  hideCompactionArchive(session);
   if (summaryCarriedForward && tokens.postClearPolicy) {
     recordContextUsageSnapshot(session, tokens.postClearPolicy, {
       messages: keep,

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

@@ -32,11 +32,13 @@ import {
   unusedModelEditToolName,
 } from '../../../../shared/edit-tool-dialect.mjs';
 import { resolveSessionContextMeta } from './context-meta.mjs';
+import { normalizeContextTokens } from '../../../../shared/llm/default-context-window.mjs';
 import { getAgentRuntimeSync, warnAgentRuntimeResolveFailureOnce } from './agent-runtime-singleton.mjs';
 import { ensureCodexWireSessionId, mintSessionId } from './session-id.mjs';
 import { providerCacheKey } from './provider-cache-key.mjs';
 import { buildSessionRecord, normalizeDesktopSessionMetadata, sessionOriginFields } from './session-record.mjs';
 import { refreshSessionBp3Environment } from './prompt-utils.mjs';
+import { isWorktreeBound } from '../../../../shared/worktrees/contract.mjs';
 
 // Owner liveness (attach-on-resume guard) and the durable turn-checkpoint
 // recovery it gates; re-exported so prior importers of this module stay
@@ -153,6 +155,8 @@ function resolveSessionRoute(opts, presetObj, profile) {
   const toolPreset = opts.tools || presetObj?.tools || (typeof opts.preset === 'string' ? opts.preset : null) || 'full';
   const effort = Object.hasOwn(opts, 'effort') ? opts.effort || null : presetObj?.effort || null;
   const fast = presetObj?.fast === true || opts.fast === true;
+  // Absent means on: an explicit request wins, else the preset's own flag.
+  const autoEffort = opts.autoEffort !== undefined ? opts.autoEffort !== false : presetObj?.autoEffort !== false;
   let modelParameters = {};
   if (opts.modelParameters && typeof opts.modelParameters === 'object') {
     modelParameters = { ...opts.modelParameters };
@@ -160,6 +164,7 @@ function resolveSessionRoute(opts, presetObj, profile) {
     modelParameters = { ...presetObj.modelParameters };
   }
   const contextPercent = normalizeContextPercent(opts.contextPercent);
+  const contextTokens = normalizeContextTokens(opts.contextTokens) || null;
   if (!providerName) throw new Error('createSession: provider is required');
   if (!modelName) throw new Error('createSession: model is required');
   const provider = getProvider(providerName);
@@ -172,7 +177,19 @@ function resolveSessionRoute(opts, presetObj, profile) {
   // materialization. Supplying that reservation here keeps the address
   // stable across intake -> queued turn -> provider execution.
   const id = requestedId || mintSessionId();
-  return { providerName, modelName, provider, toolPreset, effort, fast, modelParameters, contextPercent, id };
+  return {
+    providerName,
+    modelName,
+    provider,
+    toolPreset,
+    effort,
+    fast,
+    autoEffort,
+    modelParameters,
+    contextPercent,
+    contextTokens,
+    id,
+  };
 }
 
 // Unified-shard policy — no broad role-specific schema filter. Keep
@@ -213,6 +230,7 @@ export function createSession(opts) {
   const contextMeta = resolveSessionContextMeta(provider, modelName, {
     selectedContextWindow: opts.selectedContextWindow,
     contextPercent: route.contextPercent,
+    contextTokens: route.contextTokens,
   });
   const session = buildSessionRecord({
     opts,
@@ -287,6 +305,10 @@ function applyRouteFields(session, route) {
   if (route.provider) session.provider = route.provider;
   if (route.model) session.model = route.model;
   if (Object.hasOwn(route, 'fast')) session.fast = route.fast === true;
+  if (Object.hasOwn(route, 'autoEffort')) {
+    if (route.autoEffort === false) session.autoEffort = false;
+    else delete session.autoEffort;
+  }
   if (Object.hasOwn(route, 'effort')) session.effort = route.effort || null;
   ensureCodexWireSessionId(session);
   if (Object.hasOwn(route, 'modelParameters')) {
@@ -294,6 +316,8 @@ function applyRouteFields(session, route) {
       route.modelParameters && typeof route.modelParameters === 'object' ? { ...route.modelParameters } : {};
   }
   if (Object.hasOwn(route, 'contextPercent')) session.contextPercent = normalizeContextPercent(route.contextPercent);
+  if (Object.hasOwn(route, 'contextTokens'))
+    session.contextTokens = normalizeContextTokens(route.contextTokens) || null;
   if (Object.hasOwn(route, 'selectedContextWindow')) {
     session.selectedContextWindow = Number(route.selectedContextWindow) || null;
   }
@@ -441,13 +465,18 @@ function _applyDesktopResumeScope(session, options) {
   }
   // The host's summary may predate a cwd change. It supplies the
   // classification check, not permission to overwrite the session's
-  // newer execution Project. Task metadata always remains pathless.
+  // newer execution Project. Task metadata always remains pathless. A Lead
+  // in its worktree executes outside the Project: its registered Project
+  // stays the workspace record's projectPath, never the worktree cwd.
+  const workspace = session.workspace;
+  const executionProject =
+    isWorktreeBound(workspace) && typeof workspace.projectPath === 'string' ? workspace.projectPath : session.cwd;
   session.desktopSession =
     expectedDesktop.classification === 'project'
       ? normalizeDesktopSessionMetadata(
           {
             ...expectedDesktop,
-            projectPath: session.cwd || expectedDesktop.projectPath,
+            projectPath: executionProject || expectedDesktop.projectPath,
           },
           session.cwd
         )

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

@@ -72,7 +72,6 @@ export {
 // attach-on-resume guard) — resolved through the manager facade so the
 // session-runtime turn API reaches it as mgr.publishSessionPresence.
 export { publishSessionPresence, deleteSessionPresence } from './store.mjs';
-export { isInternalRuntimeNotificationText as _isInternalRuntimeNotificationText } from './manager/prompt-utils.mjs';
 
 // ── Usage-metrics surface — re-exported unchanged so loop.mjs / smoke scripts
 //    keep resolving these through the facade. ────────────────────────────────

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
@@ -404,9 +408,10 @@ function adoptCompactedTranscript(ctx, run) {
   // providerState so the next send starts a fresh chain.
   ctx.providerState = undefined;
   ctx.providerStateCleared = true;
-  // Compaction shrank the transcript, so prior turns no longer pressure the
-  // window — reset the iteration counter so a steadily-compacting long task
-  // isn't killed by the cap, while a non-compacting tight loop still hits it.
+  // Compaction starts a new loop epoch: the iteration counter restarts at 0
+  // so iteration indices (traces, usage metrics, cross-turn dedup windows)
+  // count from the compacted transcript. The counter bounds nothing — the
+  // loop has no iteration cap.
   ctx.iterations = 0;
   // New loop epoch so persistIterationMetrics idempotency keys do not
   // collide when iteration indices restart at 1 (incl. iter 1 → iter 1).
@@ -451,6 +456,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 +467,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 +500,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/listing.mjs

@@ -30,6 +30,7 @@ import { _saveAsyncQueued, _saveWorkerPending } from './save-worker.mjs';
 import { STORED_SESSION_UNREADABLE, _ensureLifecycleFields, _storedSessionFromFile } from './serialize.mjs';
 import { _savePending } from './pending-saves.mjs';
 import { isOrdinarySession } from '../store-summary-visibility.mjs';
+import { closeSessionCatalogDb } from '../catalog-db/index.mjs';
 
 // Disk mtime of the summary index when the in-memory cache was last refreshed
 // from it — the cross-process staleness detector.
@@ -145,8 +146,9 @@ function scheduleSessionSummaryIndexRebuild() {
 
 /**
  * Resolves once no summary-index writer of this process is running: the
- * background rebuild worker a cold listing (or sweep) spawned has exited and
- * every queued index mutation has landed. Both write the index, its lock and
+ * background rebuild worker a cold listing (or sweep) spawned has exited,
+ * every queued index mutation has landed and the session catalog DB is
+ * closed. Both write the index, its lock and
  * temp files into the data dir after the listing/sweep/save that caused them
  * has returned, so an owner that removes or switches the data dir awaits this
  * first.
@@ -159,6 +161,8 @@ export async function settleSessionSummaryIndex() {
     await new Promise((resolve) => worker.once('exit', resolve));
   }
   await settleSummaryIndexWrites();
+  // The daemon's session catalog DB holds its file, WAL and lock open.
+  await closeSessionCatalogDb();
 }
 
 export function listStoredSessionSummaries(options = {}) {

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