mixdog 1.1.1 → 1.2.0

package/src/tui/session/compaction-view.mjs

@@ -0,0 +1,147 @@
+/**
+ * src/tui/session/compaction-view.mjs - the visible transcript across a
+ * compaction. The rows the compaction took out of the model context stay in
+ * view, marked `archived` (display-only: greyed, no model-state actions), and
+ * the completion row becomes the "compacted" divider at the boundary.
+ *
+ * The model transcript itself belongs to runtime.compact / the pre-send pass;
+ * the durable copy of the dropped rows is the runtime's compaction archive.
+ */
+import { COMPACTION_DIVIDER_LABEL } from '../../runtime/agent/orchestrator/session/compaction-archive.mjs';
+
+function isCompactionDivider(item) {
+  return item?.kind === 'statusdone' && item.status === 'compacted';
+}
+
+function archivedItem(item) {
+  if (!item || typeof item !== 'object' || item.archived === true || isCompactionDivider(item)) return item;
+  return { ...item, archived: true };
+}
+
+/** `divider` (id, detail) as the compaction boundary row. Every path — manual,
+ *  auto-clear, mid-turn — and the persisted archive carry the one compaction
+ *  label; the stats stay in `detail`. */
+function compactionDividerItem(item) {
+  return {
+    ...item,
+    kind: 'statusdone',
+    status: 'compacted',
+    label: COMPACTION_DIVIDER_LABEL,
+    at: item?.at ?? Date.now(),
+  };
+}
+
+/** Row kinds a transcript message backs (prompt, reply, tool card). */
+const MESSAGE_ROW_KINDS = new Set(['user', 'assistant', 'tool']);
+
+const idSet = (values) => new Set(Array.isArray(values) ? values.filter((value) => value != null) : []);
+
+/** The tool calls a tool row shows: its own call, a restored aggregate's
+ *  calls, a live aggregate's members (whose ids are their call ids). */
+function toolCallIdsOfItem(item) {
+  if (item?.kind !== 'tool') return [];
+  if (item.callId) return [String(item.callId)];
+  if (Array.isArray(item.callIds) && item.callIds.length) return item.callIds.filter(Boolean).map(String);
+  if (item.aggregate === true && Array.isArray(item.toolMembers)) {
+    return item.toolMembers
+      .map((member) => member?.id)
+      .filter((id) => id != null)
+      .map(String);
+  }
+  return [];
+}
+
+/**
+ * Which rows a compaction took out of the model context, from the result or
+ * event it reported:
+ *  - `droppedIdentities` ({ messageIds, callIds }) — whenever supplied,
+ *    whatever `droppedMessages` says — by id membership only:
+ *    a tool row whose calls all left (or, without call ids, whose message
+ *    id left); any other row with a message of its own (prompt, reply,
+ *    notification, restored marker) whose message id left — a prompt,
+ *    reply or tool row without an id stays live. Only a row with no
+ *    message of its own (a live completion, notice or status row) follows
+ *    its turn's prompt;
+ *  - no identities and `droppedMessages: 0` (a rewrite-only pass): none;
+ *  - neither (a source that reports nothing): every row.
+ * Returns a predicate over the rows before the boundary, in order.
+ */
+export function compactionArchivedRows(result) {
+  const identities = result?.droppedIdentities;
+  // Identities decide when supplied: a kept message can still have lost
+  // part of itself (its text, some calls) with no message fully dropped.
+  // The count is only the fallback for a source without identities.
+  if (!identities || typeof identities !== 'object') {
+    const count = result?.droppedMessages;
+    return count !== undefined && count !== null && !(Number(count) > 0) ? () => false : () => true;
+  }
+  const messageIds = idSet(identities.messageIds);
+  const callIds = idSet(identities.callIds);
+  let promptDropped = false;
+  const predicate = (item) => {
+    if (!item || typeof item !== 'object') return false;
+    const calls = toolCallIdsOfItem(item);
+    let dropped;
+    if (calls.length) dropped = calls.every((id) => callIds.has(id));
+    // A message-backed row is decided by its own id alone: one without an id
+    // has no display identity in the result and stays live.
+    else if (item.messageId || MESSAGE_ROW_KINDS.has(item.kind)) {
+      dropped = Boolean(item.messageId) && messageIds.has(item.messageId);
+    }
+    // Only an auxiliary row (no message of its own) follows its turn.
+    else return promptDropped;
+    if (item.kind === 'user') promptDropped = dropped;
+    return dropped;
+  };
+  // An aggregate row some of whose calls survive stays live, with its dropped
+  // members marked archived (the restart path archives exactly those calls).
+  predicate.markDroppedMembers = (item) => {
+    if (item?.kind !== 'tool' || item.aggregate !== true || !Array.isArray(item.toolMembers)) return item;
+    if (!item.toolMembers.some((member) => member?.id != null && callIds.has(String(member.id)))) return item;
+    return {
+      ...item,
+      toolMembers: item.toolMembers.map((member) =>
+        member?.id != null && callIds.has(String(member.id)) && member.archived !== true
+          ? { ...member, archived: true }
+          : member
+      ),
+    };
+  };
+  return predicate;
+}
+
+function classifiedRow(item, archived) {
+  if (archived(item)) return archivedItem(item);
+  return typeof archived.markDroppedMembers === 'function' ? archived.markDroppedMembers(item) : item;
+}
+
+/** Items with the rows before `boundary` (default: all) that `archived`
+ *  selects marked archived, and the divider inserted at the boundary.
+ *  Returns the next list and the divider's index. */
+export function archiveItemsForCompaction(
+  items,
+  divider,
+  boundary = null,
+  { archived = () => true, archiveTail = false } = {}
+) {
+  const list = Array.isArray(items) ? items : [];
+  const at = Number.isInteger(boundary) ? Math.max(0, Math.min(list.length, boundary)) : list.length;
+  const next = list.slice(0, at).map((item) => classifiedRow(item, archived));
+  next.push(compactionDividerItem(divider));
+  // The current turn's rows after the boundary stay in place but are still
+  // classified by the same result: what compaction explicitly dropped from
+  // this turn (its tool calls) is archived, the rest stays live.
+  for (let index = at; index < list.length; index += 1) {
+    next.push(archiveTail ? classifiedRow(list[index], archived) : list[index]);
+  }
+  return { items: next, dividerIndex: at };
+}
+
+/** The runtime archive range a resumed session exposes to paged views
+ *  (`transcriptArchive` state), or null. */
+export function resumedTranscriptArchive(range) {
+  const after = Number(range?.after);
+  const before = Number(range?.before);
+  if (!Number.isInteger(after) || !Number.isInteger(before) || before - 1 <= after) return null;
+  return { after, before };
+}

package/src/tui/session/context-state.mjs

@@ -61,12 +61,18 @@ export function createContextState({
     effortOptions: runtime.effortOptions,
     fast: runtime.fast,
     fastCapable: runtime.fastCapable,
+    autoEffort: runtime.autoEffort !== false,
     modelParameters: runtime.modelParameters || {},
     contextPercent: runtime.contextPercent,
     contextWindow: runtime.contextWindow,
     rawContextWindow: runtime.rawContextWindow,
     effectiveContextWindowPercent: runtime.effectiveContextWindowPercent,
     cwd: runtime.cwd || process.cwd(),
+    // Lead workspace record (worktrees/contract.mjs SessionWorkspace): the
+    // registered Project, the execution root, the worktree binding and its
+    // revision. Null while the session has never left its project folder.
+    // Identity-stable until a transition commits.
+    workspace: runtime.getWorkspace?.() ?? null,
     systemShell: runtime.systemShell || { source: 'auto', command: '', effective: '' },
     webSearchRoute: runtime.getWebSearchRoute?.() || runtime.webSearchRoute || null,
     autoClear: autoClearState(),

package/src/tui/session/initial-state.mjs

@@ -12,6 +12,9 @@ export function createInitialSessionState({ runtime, runtimeCwd, baseRouteState
     transcriptViewRevision: 0,
     transcriptHistoryBefore: false,
     transcriptHistoryAfter: false,
+    // Compaction-archive segments a paged view may load above the rows held
+    // here ({ after, before } segment numbers), set on resume.
+    transcriptArchive: null,
     structureRevision: 0,
     streamingTail: null,
     toasts: [],

package/src/tui/session/quota-resume.mjs

@@ -52,7 +52,8 @@ export function latestQuotaFailure(items) {
   const transcript = Array.isArray(items) ? items : [];
   for (let index = transcript.length - 1; index >= 0; index -= 1) {
     const item = transcript[index];
-    if (item?.kind === 'user') return null;
+    // A turn a compaction archived is no longer the model's to resume.
+    if (item?.kind === 'user' || item?.archived === true) return null;
     if (item?.kind !== 'turndone') continue;
     const quota = item.quota;
     if (String(item.status || '').toLowerCase() !== 'failed' || !quota || typeof quota.provider !== 'string') {

package/src/tui/session/session-api/commands.mjs

@@ -4,6 +4,7 @@
  * a turn is running). Each shows a command status while it holds the lock.
  */
 import { compactEventDetail } from '../labels.mjs';
+import { archiveItemsForCompaction, compactionArchivedRows } from '../compaction-view.mjs';
 
 export function createSessionCommandsApi(bag) {
   const {
@@ -108,8 +109,15 @@ export function createSessionCommandsApi(bag) {
           invalidateExact: compactChanged,
         });
         set({ ...routeState(), stats: { ...getState().stats } });
-        if (compactChanged) set({ items: replaceItems([]) });
-        pushItem(compactDoneItem(result, startedAt));
+        if (compactChanged) {
+          // The compacted rows stay visible (archived) above the divider.
+          const { items } = archiveItemsForCompaction(getState().items, compactDoneItem(result, startedAt), null, {
+            archived: compactionArchivedRows(result),
+          });
+          set({ items: replaceItems(items, { preserveSpill: true }) });
+        } else {
+          pushItem(compactDoneItem(result, startedAt));
+        }
         return result;
       });
     } finally {

package/src/tui/session/session-api/controls.mjs

@@ -63,6 +63,10 @@ export function createSessionControlsApi(bag) {
     taskControl: (args = {}) => {
       return runtime.taskControl?.(args) ?? null;
     },
+    // Structured stop of one background shell job: { stopped, error? }.
+    stopShellJob: async (taskId) => {
+      return (await runtime.stopShellJob?.(taskId)) ?? { stopped: false, error: 'shell job control is unavailable' };
+    },
     goalControl: async (args = {}) => {
       const result = await runtime.goalControl?.(args);
       if (['pause', 'stop'].includes(result?.action)) {

package/src/tui/session/session-api/extensions.mjs

@@ -14,15 +14,19 @@ export function createSessionExtensionsApi(bag) {
     resetStatsAndSyncContext,
     routeState,
   });
-  // One locked runtime mutation, then republish and announce it.
+  // One locked runtime mutation, then republish and announce it. A refused
+  // change throws so a caller never reports a skipped write as saved.
   const lockedChange = (call, notice) =>
-    withCommandLock(async (...args) => {
-      const result = await call(...args);
-      refreshRouteStats();
-      const [text, level = 'info'] = notice(result, ...args);
-      pushNotice(text, level);
-      return result;
-    });
+    withCommandLock(
+      async (...args) => {
+        const result = await call(...args);
+        refreshRouteStats();
+        const [text, level = 'info'] = notice(result, ...args);
+        pushNotice(text, level);
+        return result;
+      },
+      { busyError: 'Another command is still running; try again when it finishes.' }
+    );
   const pluginLabel = (result, plugin) => result?.plugin?.title || result?.plugin?.name || plugin?.name || plugin;
 
   return {

package/src/tui/session/session-api/intake/rewind.mjs

@@ -13,7 +13,8 @@ export function createRewindAction(bag) {
       if (getState().busy || getState().commandBusy) return null;
       const items = getState().items || [];
       const index = items.findIndex((item) => item?.kind === 'user' && String(item?.id) === target);
-      if (index < 0) return null;
+      // An archived prompt left the model context: there is nothing to rewind.
+      if (index < 0 || items[index]?.archived === true) return null;
       const text = String(items[index]?.text || '').trim();
       if (!text) return null;
       set({ commandBusy: true });

package/src/tui/session/session-api/integrations.mjs

@@ -61,6 +61,23 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
         checkpointId
       );
     },
+    getTurnChanges: async (options = {}) => {
+      return await requireRuntimeMethod('getTurnChanges', 'Turn changes are unavailable')(options);
+    },
+    revertTurnChanges: async (checkpointId, file, revision) => {
+      return await requireRuntimeMethod('revertTurnChanges', 'Turn changes undo is unavailable')(
+        checkpointId,
+        file,
+        revision
+      );
+    },
+    reapplyTurnChanges: async (checkpointId, file, revision) => {
+      return await requireRuntimeMethod('reapplyTurnChanges', 'Turn changes reapply is unavailable')(
+        checkpointId,
+        file,
+        revision
+      );
+    },
     getOnboardingStatus: () => {
       return runtime.getOnboardingStatus?.() || { completed: true, workflowRoutes: {} };
     },
@@ -68,6 +85,7 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
       // Completed-marking only; no route/agent/provider writes.
       return runtime.skipOnboarding?.() || null;
     },
+    saveStarterGuideState: (state) => runtime.saveStarterGuideState?.(state) || null,
     completeOnboarding: withCommandLock(async (payload = {}) => {
       const result = await runtime.completeOnboarding?.(payload);
       refreshRouteStats();

package/src/tui/session/session-api/lifecycle/dispose.mjs

@@ -35,7 +35,12 @@ export function createDisposeAction(bag, { oauthFlows }) {
       try {
         clearInterval(lifecycle.runtimePulseTimer);
       } catch {}
-      for (const key of ['unsubscribeRuntimeNotifications', 'unsubscribeAgentStatus', 'unsubscribeRemoteState']) {
+      for (const key of [
+        'unsubscribeRuntimeNotifications',
+        'unsubscribeAgentStatus',
+        'unsubscribeRemoteState',
+        'unsubscribeCompletionWakeGate',
+      ]) {
         try {
           lifecycle[key]?.();
         } catch {}

package/src/tui/session/session-api/lifecycle/inheritance.mjs

@@ -25,6 +25,8 @@ export function createInheritanceActions(bag, { restoreTranscriptItems }) {
     set({
       sessionId,
       items: replaceItems(items),
+      // An heir carries the conversation, never the source's archive.
+      transcriptArchive: null,
       toasts: [],
       queued: [],
       thinking: null,

package/src/tui/session/session-api/lifecycle/resume.mjs

@@ -1,6 +1,7 @@
 // Resume: reopen a stored session, rebuild the visible transcript from its
 // messages and reconcile live-share and steering at the same boundary.
 import { primeContextEstimates } from '../../../../runtime/agent/orchestrator/session/context-utils.mjs';
+import { resumedTranscriptArchive } from '../../compaction-view.mjs';
 
 export function createResumeAction(bag, { restoreTranscriptItems }) {
   const {
@@ -52,6 +53,8 @@ export function createResumeAction(bag, { restoreTranscriptItems }) {
         });
         set({
           items: replaceItems(items),
+          // Paged views continue into the compaction archive past these rows.
+          transcriptArchive: resumedTranscriptArchive(r.transcriptArchive),
           toasts: [],
           queued: [],
           thinking: null,

package/src/tui/session/session-api/routes.mjs

@@ -9,7 +9,16 @@ import { createApiHelpers } from './shared.mjs';
 // published before the runtime write settles. What is NOT previewed about the
 // route (effort options, Fast capability, context window) is provider
 // metadata the runtime resolves while the preview is already on screen.
-const ROUTE_PREVIEW_KEYS = ['provider', 'model', 'effort', 'fast', 'modelParameters', 'contextPercent'];
+const ROUTE_PREVIEW_KEYS = [
+  'provider',
+  'model',
+  'effort',
+  'fast',
+  'autoEffort',
+  'modelParameters',
+  'contextPercent',
+  'contextTokens',
+];
 
 /**
  * The patch that publishes a requested route before the runtime write settles.

package/src/tui/session/session-api/settings.mjs

@@ -129,6 +129,8 @@ export function createSessionSettingsApi(bag) {
     getTidyInstallStatus: () => runtime.getTidyInstallStatus?.(),
     getDeveloperSettings: () => runtime.getDeveloperSettings?.(),
     setDeveloperOption: lockedRuntimeCall((id, enabled) => runtime.setDeveloperOption?.(id, enabled)),
+    getWorktreeSettings: () => runtime.getWorktreeSettings(),
+    setWorktreeSettings: lockedRuntimeCall((patch) => runtime.setWorktreeSettings(patch)),
     setWebSearchEnabled: lockedRuntimeCall((enabled) => runtime.setWebSearchEnabled?.(enabled)),
     setInstructionFiles: lockedRuntimeCall((mode) => runtime.setInstructionFiles?.(mode)),
     setMemoryToolsEnabled: lockedRuntimeCall((enabled) => runtime.setMemoryToolsEnabled?.(enabled)),

package/src/tui/session/session-api/shared.mjs

@@ -5,15 +5,19 @@
  */
 export function createApiHelpers({ getState, set, resetStatsAndSyncContext, routeState, syncContextStats }) {
   /**
-   * Wrap a runtime call in the command lock: refused (→ `busyResult`) while
-   * another command holds commandBusy, otherwise held for the call's duration.
-   * `onRelease` runs after the lock drops (RPC replies read the published
-   * snapshot, not the mutable draft, so some callers flush there).
+   * Wrap a runtime call in the command lock: refused (→ `busyResult`, or a
+   * thrown `busyError` for callers that must not read a refusal as success)
+   * while another command holds commandBusy, otherwise held for the call's
+   * duration. `onRelease` runs after the lock drops (RPC replies read the
+   * published snapshot, not the mutable draft, so some callers flush there).
    */
   const withCommandLock =
-    (run, { busyResult = null, onRelease = null } = {}) =>
+    (run, { busyResult = null, busyError = '', onRelease = null } = {}) =>
     async (...args) => {
-      if (getState().commandBusy) return busyResult;
+      if (getState().commandBusy) {
+        if (busyError) throw new Error(busyError);
+        return busyResult;
+      }
       set({ commandBusy: true });
       try {
         return await run(...args);

package/src/tui/session/session-api/worktree.mjs

@@ -0,0 +1,60 @@
+/**
+ * worktree.mjs — the session object's Lead worktree surface. The daemon
+ * resolves these advertised actions by name (session-protocol.mjs) and each
+ * delegates to the runtime's workspace transition authority
+ * (session-runtime/workspace/transitions.mjs), then republishes the route
+ * state so the new `workspace` reaches every viewer. Failures are typed
+ * WorktreeErrors whose `code` crosses the daemon wire; a runtime without the
+ * authority rejects with WORKTREE_NOT_IMPLEMENTED.
+ *
+ *   getBranchMenu()                                → { workspace, pendingWorktree, branches, occupancy, retainedWorktree }
+ *   getProjectBranchMenu({ projectPath })          → { workspace, branches, occupancy, retainedWorktree: null }
+ *     (no session: a New Task draft or the source-control dock)
+ *   selectBranch({ branch, create?, expectedRevision?, confirmLarge? }) → { revision, workspace }
+ *   selectProjectBranch({ projectPath, branch, create?, remote?, startPoint? }) → { branch, changed, commit? }
+ *   selectProjectBranch({ projectPath, detach: commitId }) → { branch: null, changed, commit, detached: true }
+ *     (no session: the guarded project-folder checkout)
+ *   mergeProjectBranch({ projectPath, branch, target }) → backend merge result
+ *     (no session: the source-control dock's merge into the confirmed target)
+ *   requestWorktree({ name?, confirmLarge?, provision?, prompt?, txId?, expectedRevision? }) → { revision, workspace, pending, warnings? }
+ *     (provision: a New Task's first send creates and enters it now)
+ *   mergeWorkspace({ confirmed: true, target, cleanup?, expectedRevision? }) → backend merge result (+ cleanup)
+ *   removeWorktree({ force?, expectedRevision? })  → { revision, workspace, removed }
+ *     (expectedRevision: WORKTREE_REVISION_CONFLICT when the session moved on)
+ *     (WORKTREE_REMOVAL_INCOMPLETE: partly removed; call again to finish)
+ *   listWorktrees()                                → every managed worktree with its retention
+ *   pruneWorktrees()                               → reconcile report (never a retained worktree)
+ */
+import { worktreeError } from '../../../runtime/shared/worktrees/contract.mjs';
+
+/** Session actions of the Lead worktree feature (settings live in settings.mjs). */
+export const SESSION_WORKTREE_ACTIONS = Object.freeze([
+  'getBranchMenu',
+  'getProjectBranchMenu',
+  'selectBranch',
+  'selectProjectBranch',
+  'mergeProjectBranch',
+  'requestWorktree',
+  'mergeWorkspace',
+  'removeWorktree',
+  'listWorktrees',
+  'pruneWorktrees',
+]);
+
+export function createSessionWorktreeApi({ runtime, set, routeState } = {}) {
+  return Object.fromEntries(
+    SESSION_WORKTREE_ACTIONS.map((action) => [
+      action,
+      async (input = {}) => {
+        if (typeof runtime?.[action] !== 'function') {
+          throw worktreeError('WORKTREE_NOT_IMPLEMENTED', `${action} is not implemented yet.`);
+        }
+        const value = await runtime[action](input ?? {});
+        if (!action.startsWith('get') && typeof set === 'function' && typeof routeState === 'function') {
+          set({ ...routeState() });
+        }
+        return value;
+      },
+    ])
+  );
+}

package/src/tui/session/session-api.mjs

@@ -12,6 +12,7 @@ import { createSessionControlsApi } from './session-api/controls.mjs';
 import { createSessionExtensionsApi } from './session-api/extensions.mjs';
 import { createSessionCommandsApi } from './session-api/commands.mjs';
 import { createQuotaResumeApi } from './session-api/quota-resume.mjs';
+import { createSessionWorktreeApi } from './session-api/worktree.mjs';
 
 export function createSessionApi(bag) {
   const api = { ...createSessionApiA(bag), ...createSessionApiB(bag) };
@@ -59,5 +60,6 @@ export function createSessionApiA(bag) {
     ...createSessionExtensionsApi(bag),
     ...createSessionCommandsApi(bag),
     ...createQuotaResumeApi(bag),
+    ...createSessionWorktreeApi(bag),
   };
 }

package/src/tui/session/session-flow/auto-clear.mjs

@@ -5,6 +5,7 @@
  */
 import { presentErrorText } from '../../../runtime/shared/err-text.mjs';
 import { sessionActivityTimestamp } from '../queue-helpers.mjs';
+import { archiveItemsForCompaction, compactionArchivedRows } from '../compaction-view.mjs';
 
 // Upper bound on the awaited idle compaction. Without a bound a stalled
 // compaction wedges autoClearRunning/commandBusy and suppresses input drain.
@@ -52,23 +53,26 @@ export function createAutoClearOps(bag, { reset, kickDrain }) {
     autoClearState,
     routeState,
     syncContextStats,
+    replaceItems,
   } = bag;
 
-  // Only an actual compaction resets the visible transcript; an unchanged
-  // success keeps it. The model transcript always belongs to runtime.compact.
+  // Only an actual compaction resets the visible activity; an unchanged
+  // success keeps it. The compacted rows stay in view, archived above the
+  // divider. The model transcript always belongs to runtime.compact.
   function applyAutoClearUi(result) {
     if (result.changed === false) return false;
-    const compactChanged = result.changed !== false;
-    if (compactChanged) {
-      reset.resetStats();
-      reset.clearUiActivityBeforeContextSync();
-    }
-    syncContextStats({ allowEstimated: true, invalidateExact: compactChanged });
+    const kept = getState().items;
+    reset.resetStats();
+    reset.clearUiActivityBeforeContextSync({ keepTranscript: true });
+    syncContextStats({ allowEstimated: true, invalidateExact: true });
+    const { items } = archiveItemsForCompaction(kept, { id: nextId() }, null, {
+      archived: compactionArchivedRows(result),
+    });
     set({
+      items: replaceItems(items, { preserveSpill: true }),
       ...routeState(),
       stats: { ...getState().stats },
     });
-    pushItem({ kind: 'statusdone', id: nextId(), label: 'Auto-clear complete' });
     return true;
   }
 
@@ -129,7 +133,9 @@ export function createAutoClearOps(bag, { reset, kickDrain }) {
     }
   }
 
-  async function autoClearBeforeSubmit() {
+  // `ignorePending`: a completion-wake drain has already dequeued its own
+  // batch, so other queued entries must not veto the idle check.
+  async function autoClearBeforeSubmit({ ignorePending = false } = {}) {
     flushDeferredClearedSessionUi();
     const cfg = autoClearState();
     const now = Date.now();
@@ -138,7 +144,7 @@ export function createAutoClearOps(bag, { reset, kickDrain }) {
     const notIdle =
       !cfg.enabled ||
       getState().busy ||
-      pending.length > 0 ||
+      (!ignorePending && pending.length > 0) ||
       flags.autoClearRunning ||
       flags.autoClearInFlight ||
       idleMs < cfg.idleMs;
@@ -188,5 +194,18 @@ export function createAutoClearOps(bag, { reset, kickDrain }) {
     }
   }
 
-  return { autoClearBeforeSubmit, performAutoClear, flushDeferredClearedSessionUi };
+  // Same eligibility as a user submit, run before a completion wake turn so a
+  // cold cache after a long idle is compacted first. Never throws: a skipped or
+  // failed auto-clear must still let the wake run. A viewer mirroring another
+  // surface's owner leaves compaction to that owner.
+  async function autoClearBeforeWake() {
+    if (bag.liveShareMirroring?.() === true) return false;
+    try {
+      return await autoClearBeforeSubmit({ ignorePending: true });
+    } catch {
+      return false;
+    }
+  }
+
+  return { autoClearBeforeSubmit, autoClearBeforeWake, performAutoClear, flushDeferredClearedSessionUi };
 }

package/src/tui/session/session-flow/drain.mjs

@@ -114,7 +114,12 @@ function turnOptionsForBatch(batch, steering) {
   };
 }
 
-export function createDrainLoop(bag, { queue, steering, submissions, flushDeferredClearedSessionUi }) {
+const COMPLETION_WAKE_MODES = new Set(['task-notification', 'pending-resume']);
+
+export function createDrainLoop(
+  bag,
+  { queue, steering, submissions, flushDeferredClearedSessionUi, autoClearBeforeWake }
+) {
   const {
     tuiDebug,
     flags,
@@ -248,6 +253,15 @@ export function createDrainLoop(bag, { queue, steering, submissions, flushDeferr
         if (isGoalQueuedEntry(batch[0]) && bag.shouldRunGoalContinuation?.(batch[0]) !== true) {
           continue;
         }
+        // A completion wake calls the model like a user turn, so a cold cache
+        // after a long idle is compacted first; the wake runs regardless.
+        if (autoClearBeforeWake && batch.every((entry) => COMPLETION_WAKE_MODES.has(entry.mode))) {
+          await autoClearBeforeWake();
+          if (flags.drainEpoch !== drainEpoch || admission() !== 'open') {
+            queue.requeueEntriesFront(batch);
+            return;
+          }
+        }
         tuiDebug(`busy-queue drain batch=${batch.length} remaining=${pending.length}`);
         const merged = mergePromptContents(batch);
         rewindFailedTurnRows(batch);

package/src/tui/session/session-flow/session-reset.mjs

@@ -30,12 +30,13 @@ export function createSessionResetOps(bag) {
     return stats;
   };
 
-  const clearUiActivityBeforeContextSync = () => {
+  // `keepTranscript`: a compaction keeps the visible rows (its caller archives
+  // them); a clear or session reset wipes them and the archive range with them.
+  const clearUiActivityBeforeContextSync = ({ keepTranscript = false } = {}) => {
     clearToastTimers();
     resetAllStreamingMarkdownStablePrefixes();
-    const items = replaceItems([]);
     set({
-      items,
+      ...(keepTranscript ? {} : { items: replaceItems([]), transcriptArchive: null }),
       toasts: [],
       queued: [],
       thinking: null,

package/src/tui/session/session-flow.mjs

@@ -23,6 +23,7 @@ export function createSessionFlow(bag) {
     steering,
     submissions,
     flushDeferredClearedSessionUi: autoClear.flushDeferredClearedSessionUi,
+    autoClearBeforeWake: autoClear.autoClearBeforeWake,
   });
 
   return {
@@ -41,6 +42,7 @@ export function createSessionFlow(bag) {
     drainPendingSteering: steering.drainPendingSteering,
     restoreLeadSteeringFromDisk: steering.restoreLeadSteeringFromDisk,
     autoClearBeforeSubmit: autoClear.autoClearBeforeSubmit,
+    autoClearBeforeWake: autoClear.autoClearBeforeWake,
     performAutoClear: autoClear.performAutoClear,
     restoreQueued: queue.restoreQueued,
     prioritizeQueued: queue.prioritizeQueued,