mixdog 1.1.1 → 1.2.0

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn/segments.mjs

@@ -21,14 +21,15 @@ export function createTurnSegments({ messages, opts, suppressMidTurnText }) {
     // live. A suppressed sub-agent session neither surfaces nor accumulates
     // text — except on the max-output ladder, whose parts must still rebuild
     // the complete answer the caller receives (keepWhenSuppressed).
-    record(text, { keepWhenSuppressed = false } = {}) {
+    // `committed: true` marks text that is the just-committed message's own.
+    record(text, { keepWhenSuppressed = false, committed = false } = {}) {
       if (suppressMidTurnText) {
         if (keepWhenSuppressed) parts.push(text);
         return;
       }
       parts.push(text);
       try {
-        opts.onAssistantText?.(text);
+        opts.onAssistantText?.(text, { committed });
       } catch {
         /* best-effort */
       }

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn.mjs

@@ -108,7 +108,8 @@ export function createNoToolTurnResolver({
         drainSteering('terminal', {
           maxPriority: 'next',
           beforeAppend: () => {
-            if (segments.commitIntermediate(response) && hasContent) segments.record(response.content);
+            if (segments.commitIntermediate(response) && hasContent)
+              segments.record(response.content, { committed: true });
           },
         })
       ) {

package/src/runtime/agent/orchestrator/session/loop/send-phase.mjs

@@ -375,6 +375,7 @@ export function settleSendResult(state, round, sent) {
             model: response.model || model,
             usage: reportedUsage,
             sendTools: round.sendTools,
+            toolCalls: response.toolCalls?.length || 0,
           })
         )
       );

package/src/runtime/agent/orchestrator/session/loop/steering.mjs

@@ -1,5 +1,6 @@
 // Steering-message normalization/merge helpers.
 // Merges queued steering entries into a single content payload + display text.
+import { stableMessageId } from '../../../../shared/transcript-metadata.mjs';
 
 function steeringContentText(content) {
   if (typeof content === 'string') return content;
@@ -135,10 +136,14 @@ function injectSteeringEntry(merged, { messages, opts, stage, onSkillPrompt }) {
   const rawSubmittedAt = Number(merged.submittedAt);
   const submittedAt = Number.isFinite(rawSubmittedAt) && rawSubmittedAt > 0 ? rawSubmittedAt : undefined;
   const injectedAt = Date.now();
+  // Every steered message carries a stable id from creation; the surface
+  // gets it back (onSteerMessage) for the row it draws. A steered prompt
+  // keeps the id the surface gave it, else gets one.
+  const messageId = stableMessageId(merged.transcriptMeta?.messageId);
   const steeringTranscriptMeta =
     merged.transcriptMeta && typeof merged.transcriptMeta === 'object'
-      ? { at: submittedAt ?? injectedAt, ...merged.transcriptMeta }
-      : null;
+      ? { at: submittedAt ?? injectedAt, ...merged.transcriptMeta, messageId }
+      : { messageId };
   // Tag steering-origin user messages so provider lowering keeps them
   // distinct from preceding tool results. Keep each queued command as
   // its own user turn instead of collapsing priority/mode buckets
@@ -158,7 +163,7 @@ function injectSteeringEntry(merged, { messages, opts, stage, onSkillPrompt }) {
       source: notification ? 'task-notification' : 'steering',
       ...(execution ? { execution } : {}),
       ...(submissionIds.length ? { submissionIds } : {}),
-      ...(steeringTranscriptMeta ? { transcript: steeringTranscriptMeta } : {}),
+      transcript: steeringTranscriptMeta,
     },
   });
   if (!notification) onSkillPrompt(merged.content);
@@ -172,9 +177,12 @@ function injectSteeringEntry(merged, { messages, opts, stage, onSkillPrompt }) {
       ...(notification ? { mode: 'task-notification' } : {}),
       ...(execution ? { execution } : {}),
       ...(Array.isArray(merged.images) && merged.images.length ? { images: merged.images } : {}),
-      ...(steeringTranscriptMeta ? { transcriptMeta: steeringTranscriptMeta } : {}),
+      transcriptMeta: steeringTranscriptMeta,
+      messageId,
     });
-  } catch {}
+  } catch {
+    /* best-effort host callback */
+  }
   return {
     count: Number(merged.count) || 1,
     textLength: String(text || '').length,
@@ -224,9 +232,11 @@ export function createSteeringDrain({ messages, opts, sessionId, onSkillPrompt }
       try {
         process.stderr.write(
           `[steer] sess=${sessionId} injected ${stage} user message(s)` +
-            ` (merged=${totalCount} len=${totalTextLen} waitMs=${Math.max(0, maxQueueWaitMs)})\n`
+            ` (merged=${totalCount} len=${totalTextLen} waitMs=${maxQueueWaitMs})\n`
         );
-      } catch {}
+      } catch {
+        /* best-effort diagnostics */
+      }
     }
     return true;
   };

package/src/runtime/agent/orchestrator/session/loop/usage.mjs

@@ -40,6 +40,7 @@ export function usageDeltaEvent({
   model,
   usage,
   sendTools,
+  toolCalls = 0,
 }) {
   return {
     sessionId,
@@ -51,6 +52,8 @@ export function usageDeltaEvent({
     usageMetricsEpoch,
     deltaInput: usage.inputTokens || 0,
     deltaOutput: usage.outputTokens || 0,
+    // Tool calls this response dispatched; the session's cumulative count.
+    deltaToolCalls: toolCalls,
     ...reasoningUsage(usage),
     deltaPrompt: usage.promptTokens || 0,
     // Cache delta carried alongside input/output so live metrics reflect

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

@@ -40,13 +40,23 @@ const traceAskStart = (sessionId, explicitPrefetch) => {
 
 /** The transcript timestamps the caller supplied for this ask: the persisted
  *  user metadata plus a one-shot reader for the assistant metadata. */
-function createAskTranscriptMeta(rawTranscriptMeta) {
+export function createAskTranscriptMeta(rawTranscriptMeta) {
   return {
     raw: rawTranscriptMeta,
     user: persistedUserTranscriptMetadata(rawTranscriptMeta),
     takeAssistant: () => {
+      const live = rawTranscriptMeta && typeof rawTranscriptMeta === 'object';
+      // An id the live row already minted is the one persisted; otherwise the
+      // row has not been drawn yet and takes this message's id and time.
+      const rowKnowsId =
+        live && typeof rawTranscriptMeta.assistantMessageId === 'string' && rawTranscriptMeta.assistantMessageId;
       const metadata = persistedAssistantTranscriptMetadata(rawTranscriptMeta);
-      if (rawTranscriptMeta && typeof rawTranscriptMeta === 'object') delete rawTranscriptMeta.assistantAt;
+      if (live) {
+        // One-shot: the next reply gets its own time and stable id.
+        delete rawTranscriptMeta.assistantAt;
+        delete rawTranscriptMeta.assistantMessageId;
+        rawTranscriptMeta.persistedAssistant = rowKnowsId ? null : { messageId: metadata.messageId, at: metadata.at };
+      }
       return metadata;
     },
   };

package/src/runtime/agent/orchestrator/session/manager/ask-turn-auto-effort.mjs

@@ -70,6 +70,8 @@ export async function resolveTurnAutoEffort({ sessionId, session, provider, inpu
   // Agent sessions are judged like any other: their spawn brief and later Lead
   // `send` messages arrive as plain prompts.
   if (mode === 'off' || input?.promptSource) return null;
+  // The session's route turned Auto effort off: its chosen effort stands.
+  if (session?.autoEffort === false) return null;
   const request = promptContentText(input?.prompt).trim();
   // Skill bodies and runtime blocks arrive as tagged text, not as a request.
   if (!request || request.startsWith('<')) return null;

package/src/runtime/agent/orchestrator/session/manager/ask-turn-loop-options.mjs

@@ -13,7 +13,9 @@ const optionalFn = (value) => (typeof value === 'function' ? value : undefined);
 const relay = (fn, ...args) => {
   try {
     fn?.(...args);
-  } catch {}
+  } catch {
+    /* a host callback must never break the turn */
+  }
 };
 
 /**
@@ -70,10 +72,10 @@ export function buildAgentLoopOptions({
       checkpoint.schedule();
       if (typeof askOpts?.onReasoningDelta === 'function') askOpts.onReasoningDelta(chunk);
     },
-    onAssistantText: (text) => {
+    onAssistantText: (text, detail) => {
       interruption.recordAssistantText(text);
       checkpoint.schedule(true);
-      if (typeof askOpts?.onAssistantText === 'function') askOpts.onAssistantText(text);
+      if (typeof askOpts?.onAssistantText === 'function') askOpts.onAssistantText(text, detail);
     },
     takeAssistantTranscriptMetadata,
     // Send-opt only. Never copy onto `session` — a transient

package/src/runtime/agent/orchestrator/session/manager/ask-turn-settle.mjs

@@ -22,11 +22,13 @@ import { recordProviderContextBaseline } from '../loop/compact-policy.mjs';
 import { throwIfAborted } from '../../../../shared/abort-race.mjs';
 import { appendAssistantTurnMessage, persistProviderState, recordAskUsage } from './ask-turn-commit.mjs';
 
-function attachAssistantTranscriptCompletion(messages, completion, turnStartedAt = 0) {
+export function attachAssistantTranscriptCompletion(messages, completion, turnStartedAt = 0) {
   if (!Array.isArray(messages) || !completion || typeof completion !== 'object') return false;
   const elapsedMs = Math.max(0, Number(completion.elapsedMs || 0));
   const status = typeof completion.status === 'string' && completion.status ? completion.status : 'done';
   const verb = typeof completion.verb === 'string' && completion.verb ? completion.verb : 'Thought';
+  const checkpointId =
+    typeof completion.checkpointId === 'string' && completion.checkpointId ? completion.checkpointId : '';
   let turnStart = -1;
   const expectedAt = Number(turnStartedAt || 0);
   if (expectedAt > 0) {
@@ -60,7 +62,7 @@ function attachAssistantTranscriptCompletion(messages, completion, turnStartedAt
         ...meta,
         transcript: {
           ...transcript,
-          completion: { status, verb, elapsedMs },
+          completion: { status, verb, elapsedMs, ...(checkpointId ? { checkpointId } : {}) },
         },
       },
     };
@@ -145,6 +147,7 @@ export function publishAskTurn({ sessionId, opened, terminalResultPreview, askOp
         status: 'done',
         verb: rawTranscriptMeta?.completionVerb,
         elapsedMs: Date.now() - turnStartedAt,
+        checkpointId: rawTranscriptMeta?.checkpointId,
       },
       turnStartedAt
     );

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -15,6 +15,7 @@ import {
 } from '../context-utils.mjs';
 import { previewFreshContextCompaction, runFreshContextCompact } from '../loop/fresh-context.mjs';
 import { positiveInt } from '../../../../shared/numbers.mjs';
+import { writeStderrBestEffort } from '../../../../shared/best-effort-stderr.mjs';
 import { traceAgentCompact, messagePrefixHash } from '../../agent-trace.mjs';
 import { uncachedInputTokensForProvider } from './usage-metrics.mjs';
 import { pruneOffloadSession } from '../tool-result-offload.mjs';
@@ -33,6 +34,7 @@ import {
   shouldCompactForRequestMedia,
 } from '../loop/compact-policy.mjs';
 import { snapshotProviderRequestTools } from '../../runtime-core/tool-catalog.mjs';
+import { scheduleCompactionArchive, stampCompactionMessageIds } from '../compaction-archive-capture.mjs';
 
 // 'compacting' is a transient in-flight stage written just before Compact
 // runs. If the process crashes or only partially
@@ -126,7 +128,7 @@ function handoffSummaryTimeoutMs(session, messageTokens) {
  * mutated and nothing is persisted — so a caller may compact a COPY of a
  * conversation. Session inheritance relies on exactly that: an oversized
  * transcript is compacted for the heir while the session that owns it keeps
- * every message (user: 자동으로 컴팩트하고 승계).
+ * every message.
  */
 export async function runHandoffCompaction({
   session,
@@ -190,9 +192,8 @@ async function sessionCompactionPlan(session, opts) {
   }
   // Reserve must mirror loop.mjs (buildCompactPolicy): request reserve (tool
   // schema) PLUS the configured reserve (session.compaction.reservedTokens or
-  // MIXDOG_AGENT_COMPACT_RESERVED_TOKENS env). The old request-only value left
-  // the manual / auto-clear compact budget without the configured headroom the
-  // loop path reserves, so a compacted transcript could overflow on next send.
+  // MIXDOG_AGENT_COMPACT_RESERVED_TOKENS env). Without the configured headroom
+  // the loop path reserves, a compacted transcript could overflow on next send.
   // A cold (just loaded) transcript is metered in slices first; the plan
   // numbers below then read the per-message memos.
   await primeContextEstimates(messages, session);
@@ -202,6 +203,7 @@ async function sessionCompactionPlan(session, opts) {
     resolvedSessionId,
     mode,
     force,
+    archive: opts.archive !== false,
     messages,
     boundary,
     alignedPolicy,
@@ -292,8 +294,8 @@ function compactionRecord(plan, { stage, after, now, reserve, outcome }) {
 }
 
 // compact_meta parity with the loop's pre-send pass: the out-of-loop
-// (post-turn/manual) compaction — and its failure — used to be invisible to
-// trace analytics.
+// (post-turn/manual) compaction — and its failure — is visible to trace
+// analytics.
 function traceSessionCompaction(plan, compactStartedAt, { counts, failure }) {
   const { session, mode } = plan;
   traceAgentCompact({
@@ -342,13 +344,9 @@ async function runSessionHandoff(plan, opts) {
   } catch (err) {
     run.freshContextError = err;
     run.compactError = err;
-    try {
-      process.stderr.write(
-        `[session] fresh-context ${mode} compact failed (sess=${session.id || 'unknown'}): ${err?.message || err}\n`
-      );
-    } catch {
-      /* best-effort */
-    }
+    writeStderrBestEffort(
+      `[session] fresh-context ${mode} compact failed (sess=${session.id || 'unknown'}): ${err?.message || err}\n`
+    );
   }
   if (!run.compacted && !run.compactError) {
     run.compactError = new Error('fresh-context compact produced no messages');
@@ -515,8 +513,8 @@ function compactionOutcome(session, freshContextResult, changed, now) {
 }
 
 // Observability parity with the loop's pre-send pass: record the
-// out-of-loop mutation as compact_meta (observed live: a 403k→10k post-turn
-// compact traced as intentional_transition: null with no compact_meta).
+// out-of-loop mutation as compact_meta, so a large post-turn compact is not
+// traced as intentional_transition: null.
 function traceCommittedCompaction(plan, compactStartedAt, { messages, compacted, beforeBytes, afterBytes, changed }) {
   let beforePrefixHash = null;
   try {
@@ -645,6 +643,19 @@ async function commitSessionCompaction(plan, run, compactStartedAt) {
     },
     outcome: compactionOutcome(session, freshContextResult, changed, now),
   });
+  // Display-only: the dropped conversation stays readable above the divider.
+  // Only the selection and the segment number happen here; the projection and
+  // the write run later, off this commit.
+  const archived =
+    changed && plan.archive
+      ? scheduleCompactionArchive({
+          session,
+          sessionId: resolvedSessionId,
+          before: messages,
+          after: transcript,
+          at: now,
+        })
+      : null;
   if (changed) {
     invalidateProviderContextBaseline(session);
     if (postCompactPolicy) {
@@ -678,6 +689,10 @@ async function commitSessionCompaction(plan, run, compactStartedAt) {
       freshContextError: null,
       handoffSource: freshContextResult?.handoffSource || 'session-local',
       usage: freshContextResult?.usage || null,
+      // Messages that left the model context (0 for a rewrite-only pass):
+      // surfaces archive only those rows.
+      droppedMessages: archived?.dropped ?? 0,
+      droppedIdentities: archived?.identities ?? null,
     }
   );
 }
@@ -692,7 +707,8 @@ export async function runSessionCompaction(session, opts = {}) {
     });
   }
   plan.requireReduction =
-    (plan.mode === 'auto' || opts.requireReduction === true) && !shouldCompactForRequestMedia(plan.messages, session.provider);
+    (plan.mode === 'auto' || opts.requireReduction === true) &&
+    !shouldCompactForRequestMedia(plan.messages, session.provider);
   const skipped = () =>
     compactionResult(plan, { changed: false, skipped: true, reason: 'no_token_reduction' }, unchangedAfter(plan), {
       freshContext: false,
@@ -713,6 +729,11 @@ export async function runSessionCompaction(session, opts = {}) {
     }).reducesTokens
   )
     return skipped();
+  // Every message enters the compaction with a stable id (legacy ones are
+  // stamped now and persisted): the result's rewrites carry it, so what was
+  // dropped is exactly the ids the result no longer holds. The snapshot is a
+  // prefix of the live transcript holding the same message objects.
+  stampCompactionMessageIds(plan.messages, plan.resolvedSessionId);
   const compactStartedAt = Date.now();
   try {
     await opts.onStageChange?.('compacting');

package/src/runtime/agent/orchestrator/session/manager/context-meta.mjs

@@ -117,8 +117,12 @@ export function resolveSessionContextMeta(provider, model, seed = {}, { wholeWin
   // (a session older than selectedContextWindow, a route saved before the
   // catalog warmed) is still the user's choice and keeps the served window.
   const recordsSelection = wholeWindow || boundedPercent(seed.contextPercent) !== null;
+  // An exact token selection without its resolved window still names it,
+  // bounded by what the model serves.
+  const selectedTokens = positiveInt(seed.contextTokens);
   const requestedContextWindow =
     positiveInt(seed.selectedContextWindow) ||
+    (selectedTokens ? Math.min(selectedTokens, servedContextWindow) : 0) ||
     (recordsSelection
       ? servedContextWindow
       : contextWindowRange({ provider: providerNameOf(provider), contextWindow: servedContextWindow }).defaultWindow);

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

@@ -185,6 +185,96 @@ export function refreshSessionBp3Environment(session, cwd) {
   return true;
 }
 
+const CORE_MEMORY_HEADING = '# Core Memory\n';
+const INSTRUCTION_FILES_HEADING = '# Instruction Files';
+
+function trimmedSlice(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+// Where a heading-led slice starts in a BP3 join: `cut` ends the text before
+// it (separator included), `start` is the slice's first character.
+function bp3SliceAt(text, heading) {
+  if (text.startsWith(heading)) return { cut: 0, start: 0 };
+  const at = text.indexOf(`${BP3_PART_SEPARATOR}${heading}`);
+  return at < 0 ? null : { cut: at, start: at + BP3_PART_SEPARATOR.length };
+}
+
+/**
+ * Replace the workspace-scoped tail of a BP3 core (composeSystemPrompt order:
+ * …, `# Core Memory`, `# Instruction Files`). The instruction-files slice is
+ * always last and may itself contain separators, so it is cut by position;
+ * the core-memory slice is one separator-free part. `undefined` keeps a slice,
+ * an empty string drops it.
+ * @param {string} core
+ * @param {{ coreMemoryContext?: string, instructionFilesContext?: string }} slices
+ */
+export function replaceWorkspaceCoreSlices(core, { coreMemoryContext, instructionFilesContext } = {}) {
+  let head = String(core || '');
+  let instructionFiles = '';
+  const instructionAt = bp3SliceAt(head, INSTRUCTION_FILES_HEADING);
+  if (instructionAt) {
+    instructionFiles = head.slice(instructionAt.start);
+    head = head.slice(0, instructionAt.cut);
+  }
+  let parts = head ? head.split(BP3_PART_SEPARATOR) : [];
+  if (coreMemoryContext !== undefined) {
+    parts = parts.filter((part) => !part.startsWith(CORE_MEMORY_HEADING));
+    const memory = trimmedSlice(coreMemoryContext);
+    if (memory) parts.push(`${CORE_MEMORY_HEADING}${memory}`);
+  }
+  if (instructionFilesContext !== undefined) instructionFiles = trimmedSlice(instructionFilesContext);
+  return [...parts, instructionFiles].filter((part) => part && part.trim()).join(BP3_PART_SEPARATOR);
+}
+
+/**
+ * Replace the shell/project facts that lead the persisted environment tail
+ * (`- Cwd …`, shell tools, git state, cwd listing); the trailing response
+ * language block is kept. `undefined` keeps the facts.
+ */
+export function replaceWorkspaceEnvironment(environmentTail, environmentContext) {
+  if (environmentContext === undefined) return environmentTail;
+  const parts = typeof environmentTail === 'string' && environmentTail ? environmentTail.split(BP3_PART_SEPARATOR) : [];
+  const facts = trimmedSlice(environmentContext);
+  if (parts[0]?.startsWith('- ')) parts[0] = facts;
+  else parts.unshift(facts);
+  return parts.filter((part) => part && part.trim()).join(BP3_PART_SEPARATOR);
+}
+
+/**
+ * Re-root an existing session's prompt at a new workspace without touching
+ * the conversation: environment facts, project memory and instruction files
+ * are replaced in place (never appended), then the `# Session` block is
+ * rebuilt for `cwd`. Messages are replaced, not mutated, so delta saves write
+ * a full snapshot.
+ * @param {object} session
+ * @param {{ cwd: string, environmentContext?: string, coreMemoryContext?: string, instructionFilesContext?: string }} context
+ * @returns {boolean}
+ */
+export function refreshSessionWorkspaceContext(
+  session,
+  { cwd, environmentContext, coreMemoryContext, instructionFilesContext } = {}
+) {
+  if (!session) return false;
+  if (typeof session.bp3EnvironmentContext === 'string') {
+    session.bp3EnvironmentContext = replaceWorkspaceEnvironment(session.bp3EnvironmentContext, environmentContext);
+  }
+  const slices = { coreMemoryContext, instructionFilesContext };
+  if (session.bp3EnvSplit === true) {
+    const target = bp3SystemMessage(session);
+    if (target && typeof target.content === 'string') {
+      const nextCore = replaceWorkspaceCoreSlices(target.content, slices);
+      replaceSystemMessageContent(session, target, nextCore);
+      session.bp3CoreContext = nextCore;
+    }
+  } else if (typeof session.bp3CoreContext === 'string') {
+    // Legacy combined layout: refreshSessionBp3Environment rebuilds the tier3
+    // block from the core plus the environment below.
+    session.bp3CoreContext = replaceWorkspaceCoreSlices(session.bp3CoreContext, slices);
+  }
+  return refreshSessionBp3Environment(session, cwd);
+}
+
 export function resetSessionBp3Environment(session) {
   if (session?.bp3EnvSplit === true) {
     const target = bpEnvSystemMessage(session);

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
         )