mixdog 1.0.4 → 1.0.6

package/src/standalone/local-session-runtime.mjs

@@ -0,0 +1,488 @@
+/**
+ * Daemon-hosted session store shared by terminal, desktop and remote clients.
+ *
+ * Runs mixdog's session manager inside the singleton daemon and exposes the
+ * subscribable store projected to clients. React/ink consumes the matching
+ * remote view through useSyncExternalStore (src/tui/hooks/useSession.mjs).
+ *
+ * Product TUI/CLI callers use src/tui/session.mjs, never this implementation.
+ * The singleton daemon and explicit parity tests are the only callers.
+ */
+import { performance } from 'node:perf_hooks';
+import { isDeepStrictEqual } from 'node:util';
+import { bootProfile } from '../tui/session/boot-profile.mjs';
+import { createGoalContinuation } from '../tui/session/goal-continuation.mjs';
+import { createToolApproval } from '../tui/session/tool-approval.mjs';
+import { createToolCardResults } from '../tui/session/tool-card-results.mjs';
+import { createAgentJobFeed } from '../tui/session/agent-job-feed.mjs';
+import { createContextState } from '../tui/session/context-state.mjs';
+import { createSessionFlow } from '../tui/session/session-flow.mjs';
+import { createRunTurn } from '../tui/session/turn.mjs';
+import { createSessionApi } from '../tui/session/session-api.mjs';
+import { createSessionDraftStore } from '../tui/session/draft-store.mjs';
+import { createInitialSessionState } from '../tui/session/initial-state.mjs';
+import { createActiveToolTracker } from '../tui/session/active-tool-summary.mjs';
+import { createTranscriptStore } from '../tui/session/transcript-store.mjs';
+import { createTranscriptIntake } from '../tui/session/transcript-intake.mjs';
+import { createNoticeSurface } from '../tui/session/notice-surface.mjs';
+import { attachCrossSurfaceShare } from '../tui/session/cross-surface-share.mjs';
+import { createTranscriptRouteMetadata } from '../runtime/shared/transcript-metadata.mjs';
+import { formatDoctorReport, runDoctorChecks } from '../tui/app/doctor.mjs';
+// tuiDebug is an opt-in diagnostic trace for the hang chain (runTurn start/end,
+// busy-queue enqueue/drain). Quiet by default so it can never tear through
+// the alternate-screen render; enable with MIXDOG_TUI_DEBUG=1.
+import { tuiDebug, nextId, createTranscriptSpillBuffer } from '../tui/session/transcript-spill.mjs';
+
+const SESSION_RUNTIME_MODULE = '../mixdog-session-runtime.mjs';
+
+// The runtime graph is imported lazily, but that import (measured ~250ms) used
+// to land inside the FIRST session runtime creation, which desktop performs while it
+// holds its transition lock — so the user's first navigation paid for it. Hosts
+// can start it during their own idle startup instead; the promise is shared, so
+// the create path either awaits an in-flight preload or does the import itself.
+let sessionRuntimeModulePromise = null;
+function importSessionRuntimeModule() {
+  sessionRuntimeModulePromise ??= import(SESSION_RUNTIME_MODULE);
+  return sessionRuntimeModulePromise;
+}
+
+export function preloadSessionRuntimeModule() {
+  return importSessionRuntimeModule().catch(() => {
+    // A real load failure surfaces on the authoritative create path.
+    sessionRuntimeModulePromise = null;
+  });
+}
+
+let agentLoopPrewarmPromise = null;
+export function preloadAgentLoopRuntime() {
+  agentLoopPrewarmPromise ??= import('../runtime/agent/orchestrator/session/manager/runtime-loaders.mjs').then(
+    (module) => module.prewarmAgentLoop()
+  );
+  void agentLoopPrewarmPromise.catch(() => {
+    // Reservation-time prewarm retries through the same shared loader.
+    agentLoopPrewarmPromise = null;
+  });
+  return agentLoopPrewarmPromise;
+}
+
+// Memory-runtime attach (PG proxy + embed warmup) measured ~6.5s cold and is
+// the largest first-turn blocker: loadCoreMemoryContext races it with a 2s
+// cap, but a cold attach stalls the event loop hard enough that even that
+// timer fires seconds late (probe: core-memory settle at ~6.0s). Warm the
+// EXACT shared proxy instance the session create path resolves —
+// getStandaloneMemoryRuntime caches by entry+dataDir, so the first turn finds
+// it initialized. Honors the same MIXDOG_BOOT_CORE_MEMORY opt-out.
+let memoryRuntimePrewarmPromise = null;
+export function preloadMemoryRuntime() {
+  const bootFlag = String(process.env.MIXDOG_BOOT_CORE_MEMORY ?? '')
+    .trim()
+    .toLowerCase();
+  if (bootFlag === '0' || bootFlag === 'false' || bootFlag === 'no' || bootFlag === 'off') {
+    return Promise.resolve();
+  }
+  memoryRuntimePrewarmPromise ??= (async () => {
+    const [{ getStandaloneMemoryRuntime }, { getPluginData }, { fileURLToPath }] = await Promise.all([
+      import('../session-runtime/services/memory-runtime-proxy.mjs'),
+      import('../runtime/agent/orchestrator/config.mjs'),
+      import('node:url'),
+    ]);
+    const runtime = getStandaloneMemoryRuntime({
+      entry: fileURLToPath(new URL('../runtime/memory/index.mjs', import.meta.url)),
+      dataDir: process.env.MIXDOG_DATA_DIR || getPluginData?.() || undefined,
+    });
+    await runtime.init();
+  })();
+  void memoryRuntimePrewarmPromise.catch(() => {
+    // Opportunistic: loadCoreMemoryContext retries through the same proxy.
+    memoryRuntimePrewarmPromise = null;
+  });
+  return memoryRuntimePrewarmPromise;
+}
+
+// Windows keychain reads go through a DPAPI PowerShell host whose cold start
+// dominates a packaged boot (measured ~1.5s). The runtime batches every secret
+// into one call, but it only starts that batch when the runtime is created —
+// late enough that the first context switch waits on it. Hosts can start the
+// same batch while their window is still coming up.
+let keychainPrewarmPromise = null;
+export function preloadKeychainSecrets() {
+  keychainPrewarmPromise ??= (async () => {
+    try {
+      const { createRequire } = await import('node:module');
+      const require = createRequire(import.meta.url);
+      const keychain = require('../lib/keychain-cjs.cjs');
+      await keychain.prewarmSecrets?.();
+    } catch {
+      // Prewarm is opportunistic; the runtime still warms on its own path.
+    }
+  })();
+  return keychainPrewarmPromise;
+}
+
+const TOOL_APPROVAL_TIMEOUT_MS = (() => {
+  const value = Number(process.env.MIXDOG_TOOL_APPROVAL_TIMEOUT_MS);
+  return Number.isFinite(value) && value > 0 ? Math.max(1000, Math.round(value)) : 120_000;
+})();
+
+export {
+  cleanupStaleTranscriptSpillDirs,
+  createTranscriptSpillBuffer,
+  refillTranscriptViewOverlap,
+  replaceSessionItemsState,
+  createSessionItemMutators,
+  TRANSCRIPT_LIVE_ITEM_CAP,
+  TRANSCRIPT_SPILL_CHUNK_ITEMS,
+} from '../tui/session/transcript-spill.mjs';
+export { parseBackgroundTaskEnvelope } from '../tui/session/agent-envelope.mjs';
+
+/**
+ * The 2s runtime pulse picks up runtime-derived state that changes without a
+ * notification: the route (model/effort/context window/cwd/Goal), the context
+ * gauge stats, and agent status. It publishes ONLY when one of those values
+ * actually differs from the draft or the published snapshot. Re-publishing an
+ * unchanged session minted a fresh snapshot every 2s, which the session
+ * service projected as a new revision and which kept its idle-projection
+ * release from ever firing for a watched session.
+ */
+export function createRuntimePulse({
+  flags,
+  liveShareMirroring,
+  getState,
+  getPublishedState,
+  set,
+  emit,
+  routeState,
+  agentStatusState,
+  syncContextStats,
+}) {
+  const publishChanged = (patch) => {
+    const draftState = getState();
+    const published = getPublishedState();
+    const changed = {};
+    let dirty = false;
+    for (const [key, value] of Object.entries(patch)) {
+      // syncContextStats stages its fields straight into the draft without
+      // scheduling a frame, so a value equal to the draft may still be
+      // unpublished.
+      if (isDeepStrictEqual(draftState[key], value) && isDeepStrictEqual(published[key], value)) continue;
+      changed[key] = value;
+      dirty = true;
+    }
+    if (!dirty) return false;
+    if (!set(changed)) emit();
+    return true;
+  };
+  return () => {
+    if (flags.disposed) return;
+    if (flags.pendingSessionReset) return;
+    // Attached viewer with a live pipe: the owner's frames are authoritative
+    // for stats/agent/tool state. Recomputing them locally here would stomp
+    // the mirror with this process's empty registries every 2s.
+    if (liveShareMirroring()) {
+      publishChanged({ ...routeState() });
+      return;
+    }
+    syncContextStats({ allowEstimated: true });
+    publishChanged({
+      ...routeState(),
+      stats: { ...getState().stats },
+      ...agentStatusState(),
+    });
+  };
+}
+
+export async function createLocalSessionRuntime({
+  provider: providerName,
+  model,
+  effort,
+  fast,
+  modelParameters,
+  toolMode = 'full',
+  remote = false,
+  cwd,
+  desktopSession,
+  sessionProfile,
+  executeAgentControl,
+} = {}) {
+  const startedAt = performance.now();
+  bootProfile('session:create:start', { provider: providerName, model, toolMode, remote });
+  // Silence provider/session diagnostics so they cannot tear through the
+  // alternate-screen React/ink render.
+  process.env.MIXDOG_QUIET_PROVIDER_LOG = '1';
+  process.env.MIXDOG_QUIET_SESSION_LOG = '1';
+  process.env.MIXDOG_QUIET_MCP_LOG = '1';
+  process.env.MIXDOG_QUIET_MEMORY_LOG = '1';
+  process.env.MIXDOG_PATCH_NATIVE_PREWARM ??= '0';
+
+  const importStartedAt = performance.now();
+  const { createMixdogSessionRuntime } = await importSessionRuntimeModule();
+  bootProfile('session-runtime:imported', { ms: (performance.now() - importStartedAt).toFixed(1) });
+  const runtime = await createMixdogSessionRuntime({
+    provider: providerName,
+    model,
+    effort,
+    fast,
+    modelParameters,
+    toolMode,
+    remote,
+    ...(cwd ? { cwd } : {}),
+    ...(desktopSession ? { desktopSession } : {}),
+    ...(sessionProfile && typeof sessionProfile === 'object' ? { sessionProfile } : {}),
+    ...(typeof executeAgentControl === 'function' ? { executeAgentControl } : {}),
+  });
+  bootProfile('session:create:runtime-ready', { ms: (performance.now() - startedAt).toFixed(1) });
+  const runtimeCwd = runtime.cwd || process.cwd();
+  const stateStartedAt = performance.now();
+  const flags = {
+    disposed: false,
+    draining: false,
+    autoClearRunning: false,
+    pendingSessionReset: false,
+    lastUserActivityAt: Date.now(),
+    leadTurnEpoch: 0,
+    activePromptRestore: null,
+    pushingFromDeferredEntry: false,
+    flushDeferredBeforeImmediatePush: null,
+    pendingTranscriptMeta: null,
+  };
+  const lifecycle = {
+    runtimePulseTimer: null,
+    unsubscribeRuntimeNotifications: null,
+    unsubscribeAgentStatus: null,
+    unsubscribeRemoteState: null,
+  };
+  const pending = [];
+  const pendingNotificationKeys = new Set();
+  const displayedExecutionNotificationKeys = new Set();
+  const bag = {};
+  // The one synchronous draft every collaborator reads through; the draft
+  // store below publishes immutable snapshots from it once per frame.
+  const draft = { state: null };
+  // Bound once the goal-continuation controller exists: route publications
+  // read the Goal through its archive mask, never the raw record.
+  let visibleGoalStatus = null;
+  // Route/context/agent-status derivations live in src/tui/session/context-state.mjs.
+  // getState()/updateState() are late-bound to the draft so they serve both
+  // the pre-publication seed below and every later pulse.
+  const { autoClearState, agentStatusState, baseRouteState, routeState, syncContextStats } = createContextState({
+    runtime,
+    getState: () => draft.state,
+    updateState: (patch) => {
+      draft.state = { ...draft.state, ...patch };
+    },
+    getPendingSessionReset: () => flags.pendingSessionReset,
+    getVisibleGoal: () => (visibleGoalStatus ? visibleGoalStatus() : runtime.goalStatus?.() || null),
+  });
+  draft.state = createInitialSessionState({ runtime, runtimeCwd, baseRouteState });
+  bootProfile('session:route-state-ready', { ms: (performance.now() - stateStartedAt).toFixed(1) });
+  bootProfile('session:state-ready', { ms: (performance.now() - stateStartedAt).toFixed(1) });
+  const contextStartedAt = performance.now();
+  syncContextStats({ allowEstimated: true });
+  bootProfile('session:context-ready', { ms: (performance.now() - contextStartedAt).toFixed(1) });
+  const listeners = new Set();
+  const store = createSessionDraftStore({
+    draft,
+    listeners,
+    isDisposed: () => flags.disposed,
+    onBusyReleased: () => {
+      void bag.drain?.();
+      bag.scheduleGoalContinuation?.();
+    },
+  });
+  const { getState, getPublishedState, set, flushEmit, flushEmitImmediate } = store;
+
+  const itemIndexById = new Map();
+  const transcriptSpill = createTranscriptSpillBuffer();
+  const { markToolCallActive, markToolCallDone, clearActiveToolSummary, resetActiveToolCalls } =
+    createActiveToolTracker({ getState, set });
+  const {
+    restoreOlderTranscript,
+    restoreNewerTranscript,
+    replaceItems,
+    pushItem,
+    appendItems,
+    patchItem,
+    updateStreamingTail,
+    settleStreamingTail,
+    clearStreamingTail,
+  } = createTranscriptStore({
+    draft,
+    store,
+    flags,
+    transcriptSpill,
+    itemIndexById,
+    onBulkReplace: resetActiveToolCalls,
+  });
+  const transcriptRouteMetadata = (at = Date.now()) => createTranscriptRouteMetadata(runtime.session, routeState(), at);
+  const { upsertSyntheticToolItem, pushUserOrSyntheticItem, pushAsyncAgentResponse } = createTranscriptIntake({
+    getState,
+    flags,
+    pushItem,
+    patchItem,
+    transcriptRouteMetadata,
+  });
+  const { pushToast, pushNotice, removeNotice, setProgressHint, clearToastTimers } = createNoticeSurface({
+    getState,
+    set,
+    isDisposed: () => flags.disposed,
+    pushItem,
+    replaceItems,
+  });
+  const { presentNextToolApproval, finishToolApproval, denyAllToolApprovals, requestToolApproval } = createToolApproval(
+    {
+      getState,
+      set,
+      nextId,
+      getDisposed: () => flags.disposed,
+      timeoutMs: TOOL_APPROVAL_TIMEOUT_MS,
+    }
+  );
+  lifecycle.runtimePulseTimer = setInterval(
+    createRuntimePulse({
+      flags,
+      liveShareMirroring: () => bag.liveShareMirroring?.() === true,
+      getState,
+      getPublishedState,
+      set,
+      emit: store.emit,
+      routeState,
+      agentStatusState,
+      syncContextStats,
+    }),
+    2000
+  );
+  lifecycle.runtimePulseTimer.unref?.();
+
+  const {
+    kickExecutionPendingResume,
+    flushDeferredExecutionPendingResumeKick,
+    scheduleExecutionPendingResumeKick,
+    discardExecutionPendingResume,
+    updateAgentJobCard,
+    buildAgentJobCardPatch,
+    subscribeRuntimeNotifications,
+    clearExecutionDedupState,
+  } = createAgentJobFeed({
+    runtime,
+    getState,
+    set,
+    nextId,
+    getDisposed: () => flags.disposed,
+    patchItem,
+    enqueue: (...args) => bag.enqueue(...args),
+    drain: (...args) => bag.drain(...args),
+    pushUserOrSyntheticItem,
+    pushAsyncAgentResponse,
+    makeQueueEntry: (...args) => bag.makeQueueEntry(...args),
+    getPending: () => pending,
+    agentStatusState,
+    displayedExecutionNotificationKeys,
+    pushNotice,
+    itemIndexById,
+  });
+  lifecycle.unsubscribeRuntimeNotifications = subscribeRuntimeNotifications();
+  if (typeof runtime.onAgentStatusChange === 'function') {
+    lifecycle.unsubscribeAgentStatus = runtime.onAgentStatusChange(() => {
+      if (flags.disposed || flags.pendingSessionReset || bag.liveShareMirroring?.()) return;
+      set({ ...agentStatusState({ force: true }) });
+      bag.scheduleGoalContinuation?.();
+    });
+  }
+
+  const { patchToolCardResult, flushToolResults } = createToolCardResults({
+    getState,
+    set,
+    patchItem,
+    markToolCallDone,
+    updateAgentJobCard,
+    buildAgentJobCardPatch,
+    agentStatusState,
+    itemIndexById,
+  });
+
+  Object.assign(bag, {
+    runtime,
+    nextId,
+    tuiDebug,
+    flags,
+    lifecycle,
+    pending,
+    pendingNotificationKeys,
+    displayedExecutionNotificationKeys,
+    clearExecutionDedupState,
+    listeners,
+    itemIndexById,
+    getState,
+    getPublishedState,
+    set,
+    flushEmit,
+    flushEmitImmediate,
+    disposeEmit: store.disposeEmit,
+    pushItem,
+    appendItems,
+    patchItem,
+    replaceItems,
+    restoreOlderTranscript,
+    restoreNewerTranscript,
+    updateStreamingTail,
+    settleStreamingTail,
+    clearStreamingTail,
+    pushToast,
+    pushNotice,
+    removeNotice,
+    setProgressHint,
+    pushUserOrSyntheticItem,
+    pushAsyncAgentResponse,
+    upsertSyntheticToolItem,
+    markToolCallActive,
+    markToolCallDone,
+    clearActiveToolSummary,
+    clearToastTimers,
+    autoClearState,
+    agentStatusState,
+    baseRouteState,
+    routeState,
+    transcriptRouteMetadata,
+    syncContextStats,
+    disposeTranscriptSpill: () => transcriptSpill.dispose(),
+    snapshotTranscriptSpill: () => transcriptSpill.snapshot(),
+    restoreTranscriptSpill: (snapshot) => transcriptSpill.restoreSnapshot(snapshot),
+    releaseTranscriptSpill: (snapshot) => transcriptSpill.releaseSnapshot(snapshot),
+    presentNextToolApproval,
+    finishToolApproval,
+    denyAllToolApprovals,
+    requestToolApproval,
+    patchToolCardResult,
+    flushToolResults,
+    kickExecutionPendingResume,
+    flushDeferredExecutionPendingResumeKick,
+    scheduleExecutionPendingResumeKick,
+    discardExecutionPendingResume,
+    updateAgentJobCard,
+    subscribeRuntimeNotifications,
+  });
+  Object.assign(bag, createSessionFlow(bag));
+  Object.assign(
+    bag,
+    createGoalContinuation({
+      runtime,
+      flags,
+      getState,
+      set,
+      getPending: () => pending,
+      enqueue: (...args) => bag.enqueue(...args),
+    })
+  );
+  visibleGoalStatus = bag.visibleGoalStatus;
+  bag.runTurn = createRunTurn(bag);
+  bag.doctor = { runDoctorChecks, formatDoctorReport };
+  const api = createSessionApi(bag);
+  attachCrossSurfaceShare({ runtime, api, bag, flags, getState, getPublishedState, listeners, set });
+  void Promise.resolve(bag.restoreLeadSteeringFromDisk())
+    .catch(() => {})
+    .finally(() => {
+      bag.refreshGoalState?.();
+      bag.scheduleGoalContinuation?.();
+    });
+  return api;
+}

package/src/standalone/session-protocol.mjs

@@ -38,6 +38,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'inspectHuggingFaceModel',
   'getLocalProviderModelDetails',
   'getSessionReviewDiff',
+  'getSessionUsage',
   'getTurnReviewDiff',
   'getTurnLiveness',
   'getUpdateSettings',

package/src/standalone/session-runtime-inline-host.mjs

@@ -15,7 +15,7 @@ export function createInlineSessionRuntimeHost({
   cwd = process.cwd(),
   log = () => {},
   measureBootPhase = async (_phase, task) => await task(),
-  loadLocalModule = () => import('../tui/session-local.mjs'),
+  loadLocalModule = () => import('./local-session-runtime.mjs'),
   loadAgentGraph = () =>
     Promise.all([
       import('../runtime/agent/orchestrator/config.mjs'),

package/src/tui/hooks/useSession.mjs

@@ -1,7 +1,7 @@
 /**
  * src/tui/hooks/useSession.mjs — subscribe React to the session store.
  *
- * The store (session-local.mjs) lives outside React and emits immutable snapshots;
+ * The store (local-session-runtime.mjs) lives outside React and emits immutable snapshots;
  * useSyncExternalStore re-renders the tree whenever a snapshot changes. This
  * keeps the agentLoop fully decoupled from React's lifecycle.
  */

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

@@ -17,7 +17,7 @@ export function createSessionCommandsApi(bag) {
     routeState,
     syncContextStats,
     replaceItems,
-    // Injected by the store composer (session-local.mjs): the doctor checks
+    // Injected by the store composer (local-session-runtime.mjs): the doctor checks
     // live in the app layer, which the session layer must not import.
     doctor,
   } = bag;

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

@@ -68,6 +68,9 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
     getQuotaHistory: async (options = {}) => {
       return await runtime.getQuotaHistory?.(options);
     },
+    getSessionUsage: async () => {
+      return await runtime.getSessionUsage?.();
+    },
     consumeCodexRateLimitResetCredit: async (options = {}) => {
       // Desktop capability parity: without this delegation the session runtime
       // surface rejects the sidebar's reset-credit invoke as unsupported even

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

@@ -57,6 +57,7 @@ export function createAutoClearOps(bag, { reset, kickDrain }) {
   // Only an actual compaction resets the visible transcript; an unchanged
   // success keeps it. 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();
@@ -68,6 +69,7 @@ export function createAutoClearOps(bag, { reset, kickDrain }) {
       stats: { ...getState().stats },
     });
     pushItem({ kind: 'statusdone', id: nextId(), label: 'Auto-clear complete' });
+    return true;
   }
 
   // Flush a deferred cleared-session UI sync once the active turn has settled.
@@ -77,8 +79,7 @@ export function createAutoClearOps(bag, { reset, kickDrain }) {
     const { result } = flags.pendingClearedSessionUi;
     flags.pendingClearedSessionUi = null;
     flags.autoClearInFlight = false;
-    applyAutoClearUi(result);
-    pushNotice(LATE_COMPLETION_NOTICE, 'info');
+    if (applyAutoClearUi(result)) pushNotice(LATE_COMPLETION_NOTICE, 'info');
   }
 
   function onLateCompact(lateResult) {
@@ -86,8 +87,7 @@ export function createAutoClearOps(bag, { reset, kickDrain }) {
       // Do not wipe items/queued or force busy=false mid-turn.
       flags.pendingClearedSessionUi = { result: lateResult };
     } else {
-      applyAutoClearUi(lateResult);
-      pushNotice(LATE_COMPLETION_NOTICE, 'info');
+      if (applyAutoClearUi(lateResult)) pushNotice(LATE_COMPLETION_NOTICE, 'info');
     }
   }
 
@@ -95,7 +95,7 @@ export function createAutoClearOps(bag, { reset, kickDrain }) {
   // late completion can reset the UI. Never follow compact with clear:
   // that would discard conversation/execution records the compactor kept.
   async function compactWithinTimeout(compactTimeoutMs) {
-    const compactPromise = runtime.compact().then((result) => {
+    const compactPromise = runtime.compact({ requireReduction: true }).then((result) => {
       if (!result) throw new Error('no active session');
       if (result.error) throw new Error(result.error);
       return result;
@@ -161,8 +161,7 @@ export function createAutoClearOps(bag, { reset, kickDrain }) {
       // Without this, long idle clears can look like a frozen prompt followed by
       // an already-complete status row.
       await new Promise((resolve) => setTimeout(resolve, 0));
-      applyAutoClearUi(await compactWithinTimeout(compactTimeoutMs));
-      return true;
+      return applyAutoClearUi(await compactWithinTimeout(compactTimeoutMs));
     } catch (error) {
       const message = presentErrorText(error, { surface: 'compact' });
       pushItem({

package/src/tui/session/tool-card-results.mjs

@@ -1,7 +1,7 @@
 /**
  * src/tui/session/tool-card-results.mjs — the tool-card result state machine
  * (patchToolCardResult + flushToolResults) for the session runtime
- * (session-local.mjs), as a dependency-injection factory.
+ * (local-session-runtime.mjs), as a dependency-injection factory.
  *
  * These handlers own the per-turn accounting that reflects tool results into
  * store items: aggregate cards, non-aggregate/legacy agent-job cards, grouped

package/src/tui/session/turn.mjs

@@ -408,6 +408,11 @@ function turnDoneItem({ turn, stream, cards, getState, nextId }) {
     id: nextId(),
     elapsedMs: Date.now() - turn.startedAt,
     status: turnOutcome(turn.cancelled, turn.failed),
+    // Notifications resolve this exact terminal assistant item, never a
+    // session preview or a tool preamble from earlier in the turn.
+    ...(turn.finishedNormally && stream.currentAssistantId != null
+      ? { finalAssistantId: stream.currentAssistantId }
+      : {}),
     outputTokens: finalOutputTokens(stream, getState().spinner?.outputTokens),
     thinkingElapsedMs: stream.thinkingStartedAt ? stream.accumulatedThinkingMs : 0,
     toolCount: cards.toolCards.length,