@xelauvas/xela-cli 0.3.0 → 0.4.0

package/src/proactive/index.ts

@@ -0,0 +1,158 @@
+import { TICK_TAG } from '../constants/xml.js'
+
+/**
+ * Proactive mode: the model keeps working between user prompts. The session
+ * receives periodic <tick> prompts (interactive: useProactive in the REPL;
+ * headless: print.ts scheduleProactiveTick) and either does something useful
+ * or calls Sleep, which schedules the next tick. State lives on globalThis
+ * because this module is reached both through ESM imports and the CJS
+ * require shim, and React reads it through subscribeToProactiveChanges.
+ */
+export type ProactiveSource = 'command' | 'flag' | 'sdk' | 'env'
+
+type ProactiveState = {
+  active: boolean
+  paused: boolean
+  contextBlocked: boolean
+  source: ProactiveSource | null
+  activatedAt: number | null
+  tickCount: number
+  lastTickAt: number | null
+  /** When the next tick is due (set by Sleep or the ticker), null when none is scheduled. */
+  nextTickAt: number | null
+  listeners: Set<() => void>
+}
+
+const state: ProactiveState = ((globalThis as unknown as { __xelaProactive?: ProactiveState })
+  .__xelaProactive ??= {
+  active: false,
+  paused: false,
+  contextBlocked: false,
+  source: null,
+  activatedAt: null,
+  tickCount: 0,
+  lastTickAt: null,
+  nextTickAt: null,
+  listeners: new Set(),
+})
+
+/** Default spacing between ticks when the model does not Sleep itself. */
+export const PROACTIVE_TICK_INTERVAL_MS = Number(
+  process.env.CLAUDE_CODE_PROACTIVE_TICK_MS || 5 * 60_000,
+)
+/** First tick shortly after activation so the model greets and starts. */
+export const PROACTIVE_FIRST_TICK_MS = 1_500
+
+function notify(): void {
+  for (const l of state.listeners) {
+    try {
+      l()
+    } catch {
+      // listener errors must not break state updates
+    }
+  }
+}
+
+export function subscribeToProactiveChanges(listener: () => void): () => void {
+  state.listeners.add(listener)
+  return () => {
+    state.listeners.delete(listener)
+  }
+}
+
+export function isProactiveActive(): boolean {
+  return state.active
+}
+
+export function isProactivePaused(): boolean {
+  return state.paused || state.contextBlocked
+}
+
+export function isContextBlocked(): boolean {
+  return state.contextBlocked
+}
+
+export function getNextTickAt(): number | null {
+  return state.active && !isProactivePaused() ? state.nextTickAt : null
+}
+
+export function getProactiveState(): Readonly<Omit<ProactiveState, 'listeners'>> {
+  const { listeners: _l, ...rest } = state
+  return rest
+}
+
+export function activateProactive(source: ProactiveSource = 'command'): void {
+  state.active = true
+  state.paused = false
+  state.contextBlocked = false
+  state.source = source
+  state.activatedAt = Date.now()
+  state.nextTickAt = Date.now() + PROACTIVE_FIRST_TICK_MS
+  notify()
+}
+
+export function deactivateProactive(): void {
+  state.active = false
+  state.paused = false
+  state.source = null
+  state.nextTickAt = null
+  notify()
+}
+
+export function pauseProactive(): void {
+  if (!state.paused) {
+    state.paused = true
+    notify()
+  }
+}
+
+export function resumeProactive(): void {
+  if (state.paused || state.contextBlocked) {
+    state.paused = false
+    state.contextBlocked = false
+    notify()
+  }
+}
+
+/**
+ * Set when the context is too full to keep ticking (prompt-too-long with
+ * nothing left to compact). Cleared by /clear and by resumeProactive.
+ */
+export function setContextBlocked(blocked: boolean): void {
+  if (state.contextBlocked !== blocked) {
+    state.contextBlocked = blocked
+    notify()
+  }
+}
+
+/** Schedule the next tick `ms` from now (Sleep tool, ticker). */
+export function scheduleNextTick(ms: number): number {
+  const at = Date.now() + Math.max(0, ms)
+  state.nextTickAt = at
+  notify()
+  return at
+}
+
+export function clearNextTick(): void {
+  if (state.nextTickAt !== null) {
+    state.nextTickAt = null
+    notify()
+  }
+}
+
+export function recordTick(): number {
+  state.tickCount++
+  state.lastTickAt = Date.now()
+  state.nextTickAt = null
+  notify()
+  return state.tickCount
+}
+
+/** The prompt injected on every tick: the user's local time, as in headless mode. */
+export function getTickPrompt(): string {
+  return `<${TICK_TAG}>${new Date().toLocaleTimeString()}</${TICK_TAG}>`
+}
+
+export function isTickPrompt(text: string): boolean {
+  return new RegExp(`^<${TICK_TAG}\\b`).test(text.trimStart())
+}

package/src/proactive/useProactive.ts

@@ -0,0 +1,78 @@
+import { useEffect, useRef, useSyncExternalStore } from 'react'
+import { logForDebugging } from '../utils/debug.js'
+import {
+  getNextTickAt,
+  getTickPrompt,
+  isProactiveActive,
+  isProactivePaused,
+  PROACTIVE_TICK_INTERVAL_MS,
+  recordTick,
+  scheduleNextTick,
+  subscribeToProactiveChanges,
+} from './index.js'
+
+type Props = {
+  isLoading: boolean
+  queuedCommandsLength: number
+  hasActiveLocalJsxUI: boolean
+  isInPlanMode: boolean
+  /** Submit a tick prompt right away (idle REPL). */
+  onSubmitTick: (prompt: string) => void
+  /** Queue a tick prompt behind the current turn (busy REPL). */
+  onQueueTick: (prompt: string) => void
+}
+
+/**
+ * Interactive tick driver. While proactive mode is active and not paused,
+ * fires a <tick> prompt when the scheduled time arrives (set by Sleep or,
+ * failing that, the default interval). Ticks wait while a turn is running,
+ * while commands are queued, while a local dialog is open, or in plan mode.
+ */
+export function useProactive({
+  isLoading,
+  queuedCommandsLength,
+  hasActiveLocalJsxUI,
+  isInPlanMode,
+  onSubmitTick,
+  onQueueTick,
+}: Props): void {
+  const active = useSyncExternalStore(subscribeToProactiveChanges, isProactiveActive)
+  const paused = useSyncExternalStore(subscribeToProactiveChanges, isProactivePaused)
+  const nextTickAt = useSyncExternalStore(subscribeToProactiveChanges, getNextTickAt)
+
+  const latest = useRef({ isLoading, queuedCommandsLength, hasActiveLocalJsxUI, isInPlanMode, onSubmitTick, onQueueTick })
+  latest.current = { isLoading, queuedCommandsLength, hasActiveLocalJsxUI, isInPlanMode, onSubmitTick, onQueueTick }
+
+  // Nothing scheduled while active and idle: fall back to the default interval
+  // so a turn that ended without Sleep still gets a follow-up.
+  useEffect(() => {
+    if (!active || paused || nextTickAt !== null || isLoading) return
+    scheduleNextTick(PROACTIVE_TICK_INTERVAL_MS)
+  }, [active, paused, nextTickAt, isLoading])
+
+  useEffect(() => {
+    if (!active || paused || nextTickAt === null) return
+    const fire = (): void => {
+      const l = latest.current
+      if (!isProactiveActive() || isProactivePaused()) {
+        logForDebugging('[proactive] tick skipped: inactive or paused')
+        return
+      }
+      if (l.hasActiveLocalJsxUI || l.isInPlanMode) {
+        // Try again shortly; the user is in a dialog or planning.
+        logForDebugging('[proactive] tick deferred: dialog open or plan mode')
+        scheduleNextTick(15_000)
+        return
+      }
+      const n = recordTick()
+      const prompt = getTickPrompt()
+      logForDebugging(`[proactive] tick ${n} ${l.isLoading || l.queuedCommandsLength > 0 ? 'queued' : 'submitted'}`)
+      if (l.isLoading || l.queuedCommandsLength > 0) l.onQueueTick(prompt)
+      else l.onSubmitTick(prompt)
+    }
+    const delay = Math.max(0, nextTickAt - Date.now())
+    logForDebugging(`[proactive] next tick in ${Math.round(delay / 1000)}s`)
+    const timer = setTimeout(fire, delay)
+    return () => clearTimeout(timer)
+  }, [active, paused, nextTickAt])
+}

package/src/screens/REPL.tsx

@@ -1,4 +1,9 @@
 import { c as _c } from "react/compiler-runtime";
+// Static imports (not require): these touch React context / shared state and
+// must be the same module instance as the rest of the ESM graph.
+import * as proactiveModuleImpl from '../proactive/index.js';
+import { useProactive as useProactiveImpl } from '../proactive/useProactive.js';
+import { useScheduledTasks as useScheduledTasksImpl } from '../hooks/useScheduledTasks.js';
 // biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
 import { feature } from 'bun:bundle';
 import { spawnSync } from 'child_process';
@@ -67,6 +72,7 @@ import { SkillImprovementSurvey } from '../components/SkillImprovementSurvey.js'
 import { useSkillImprovementSurvey } from '../hooks/useSkillImprovementSurvey.js';
 import { useMoreRight } from '../moreright/useMoreRight.js';
 import { SpinnerWithVerb, BriefIdleStatus, type SpinnerMode } from '../components/Spinner.js';
+import type { CompactProgressInfo } from '../components/Spinner.js';
 import { getSystemPrompt } from '../constants/prompts.js';
 import { buildEffectiveSystemPrompt } from '../utils/systemPrompt.js';
 import { getSystemContext, getUserContext } from '../context.js';
@@ -191,12 +197,12 @@ import { restoreRemoteAgentTasks } from '../tasks/RemoteAgentTask/RemoteAgentTas
 import { useInboxPoller } from '../hooks/useInboxPoller.js';
 // Dead code elimination: conditional import for loop mode
 /* eslint-disable @typescript-eslint/no-require-imports */
-const proactiveModule = feature('PROACTIVE') || feature('KAIROS') ? require('../proactive/index.js') : null;
+const proactiveModule = feature('PROACTIVE') || feature('KAIROS') ? proactiveModuleImpl : null;
 const PROACTIVE_NO_OP_SUBSCRIBE = (_cb: () => void) => () => {};
 const PROACTIVE_FALSE = () => false;
 const SUGGEST_BG_PR_NOOP = (_p: string, _n: string): boolean => false;
-const useProactive = feature('PROACTIVE') || feature('KAIROS') ? require('../proactive/useProactive.js').useProactive : null;
-const useScheduledTasks = feature('AGENT_TRIGGERS') ? require('../hooks/useScheduledTasks.js').useScheduledTasks : null;
+const useProactive = feature('PROACTIVE') || feature('KAIROS') ? useProactiveImpl : null;
+const useScheduledTasks = feature('AGENT_TRIGGERS') ? useScheduledTasksImpl : null;
 /* eslint-enable @typescript-eslint/no-require-imports */
 import { isAgentSwarmsEnabled } from '../utils/agentSwarmsEnabled.js';
 import { useTaskListWatcher } from '../hooks/useTaskListWatcher.js';
@@ -1473,6 +1479,9 @@ export function REPL({
   const visibleStreamingText = streamingText && showStreamingText ? streamingText.substring(0, streamingText.lastIndexOf('\n') + 1) || null : null;
   const [lastQueryCompletionTime, setLastQueryCompletionTime] = useState(0);
   const [spinnerMessage, setSpinnerMessage] = useState<string | null>(null);
+  // Set while a compaction summary is being generated; drives the progress
+  // bar under the spinner (see CompactProgressBar in Spinner.tsx).
+  const [compactProgress, setCompactProgress] = useState<CompactProgressInfo | null>(null);
   const [spinnerColor, setSpinnerColor] = useState<keyof Theme | null>(null);
   const [spinnerShimmerColor, setSpinnerShimmerColor] = useState<keyof Theme | null>(null);
   const [isMessageSelectorVisible, setIsMessageSelectorVisible] = useState(false);
@@ -1576,6 +1585,7 @@ export function REPL({
     setStreamingText(null);
     setStreamingToolUses([]);
     setSpinnerMessage(null);
+    setCompactProgress(null);
     setSpinnerColor(null);
     setSpinnerShimmerColor(null);
     pickNewSpinnerTip();
@@ -2503,9 +2513,14 @@ export function REPL({
             break;
           case 'compact_start':
             setSpinnerMessage('Compacting conversation');
+            setCompactProgress({
+              startedAt: Date.now(),
+              preCompactTokenCount: event.preCompactTokenCount ?? 0
+            });
             break;
           case 'compact_end':
             setSpinnerMessage(null);
+            setCompactProgress(null);
             setSpinnerColor(null);
             setSpinnerShimmerColor(null);
             break;
@@ -3062,7 +3077,7 @@ export function REPL({
       }
 
       // Atomically: clear initial message, set permission mode and rules, and store plan for verification
-      const shouldStorePlanForVerification = initialMsg.message.planContent && "external" === 'ant' && isEnvTruthy(undefined);
+      const shouldStorePlanForVerification = initialMsg.message.planContent && process.env.CLAUDE_CODE_VERIFY_PLAN === 'true';
       setAppState(prev => {
         // Build and apply permission updates (mode + allowedPrompts rules)
         let updatedToolPermissionContext = initialMsg.mode ? applyPermissionUpdates(prev.toolPermissionContext, buildPermissionUpdates(initialMsg.mode, initialMsg.allowedPrompts)) : prev.toolPermissionContext;
@@ -4073,10 +4088,15 @@ export function REPL({
       onSubmitTask: handleIncomingPrompt
     });
 
-    // Loop mode: auto-tick when enabled (via /job command)
+  }
+
+  // Proactive mode: auto-tick when enabled (/proactive, --proactive). Upstream
+  // this sat inside the ant-only block above; the tick driver is needed in
+  // every build where PROACTIVE is on.
+  if (feature('PROACTIVE') || feature('KAIROS')) {
     // eslint-disable-next-line react-hooks/rules-of-hooks
-    // biome-ignore lint/correctness/useHookAtTopLevel: conditional for dead code elimination in external builds
-    useProactive?.({
+    // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+    useProactive!({
       // Suppress ticks while an initial message is pending — the initial
       // message will be processed asynchronously and a premature tick would
       // race with it, causing concurrent-query enqueue of expanded skill text.
@@ -4584,7 +4604,7 @@ export function REPL({
               {"external" === 'ant' && <TungstenLiveMonitor />}
               {feature('WEB_BROWSER_TOOL') ? WebBrowserPanelModule && <WebBrowserPanelModule.WebBrowserPanel /> : null}
               <Box flexGrow={1} />
-              {showSpinner && <SpinnerWithVerb mode={streamMode} spinnerTip={spinnerTip} responseLengthRef={responseLengthRef} apiMetricsRef={apiMetricsRef} overrideMessage={spinnerMessage} spinnerSuffix={stopHookSpinnerSuffix} verbose={verbose} loadingStartTimeRef={loadingStartTimeRef} totalPausedMsRef={totalPausedMsRef} pauseStartTimeRef={pauseStartTimeRef} overrideColor={spinnerColor} overrideShimmerColor={spinnerShimmerColor} hasActiveTools={inProgressToolUseIDs.size > 0} leaderIsIdle={!isLoading} />}
+              {showSpinner && <SpinnerWithVerb mode={streamMode} spinnerTip={spinnerTip} responseLengthRef={responseLengthRef} apiMetricsRef={apiMetricsRef} overrideMessage={spinnerMessage} compactProgress={compactProgress} spinnerSuffix={stopHookSpinnerSuffix} verbose={verbose} loadingStartTimeRef={loadingStartTimeRef} totalPausedMsRef={totalPausedMsRef} pauseStartTimeRef={pauseStartTimeRef} overrideColor={spinnerColor} overrideShimmerColor={spinnerShimmerColor} hasActiveTools={inProgressToolUseIDs.size > 0} leaderIsIdle={!isLoading} />}
               {!showSpinner && !isLoading && !userInputOnProcessing && !hasRunningTeammates && isBriefOnly && !viewedAgentTask && <BriefIdleStatus />}
               {isFullscreenEnvEnabled() && <PromptInputQueuedCommands />}
             </>} bottom={<Box flexDirection={feature('BUDDY') && companionNarrow ? 'column' : 'row'} width="100%" alignItems={feature('BUDDY') && companionNarrow ? undefined : 'flex-end'}>

package/src/services/api/claude.ts

@@ -1214,7 +1214,7 @@ async function* queryModel(
     cachedMCEnabled = featureEnabled && modelSupported
     const config = getCachedMCConfig()
     logForDebugging(
-      `Cached MC gate: enabled=${featureEnabled} modelSupported=${modelSupported} model=${options.model} supportedModels=${jsonStringify(config.supportedModels)}`,
+      `Cached MC gate: enabled=${featureEnabled} modelSupported=${modelSupported} model=${options.model} supportedModels=${jsonStringify(config?.supportedModels)}`,
     )
   }
 
@@ -1951,7 +1951,9 @@ async function* queryModel(
       let totalStallTime = 0
       let stallCount = 0
 
+      let __xelaParts = 0
       for await (const part of stream) {
+        __xelaParts++
         resetStreamIdleTimer()
         const now = Date.now()
 
@@ -2316,6 +2318,9 @@ async function* queryModel(
           ...(part.type === 'message_start' ? { ttftMs } : undefined),
         }
       }
+      if (process.env.XELA_LOADER_DEBUG) {
+        process.stderr.write(`[claude.ts] stream loop exited: ${__xelaParts} parts, source=${options.querySource}, newMessages=${newMessages.length}\n`)
+      }
       // Clear the idle timeout watchdog now that the stream loop has exited
       clearStreamIdleTimers()
 

package/src/services/compact/autoCompact.ts

@@ -31,11 +31,14 @@ const MAX_OUTPUT_TOKENS_FOR_SUMMARY = 20_000
 
 // Returns the context window size minus the max output tokens for the model
 export function getEffectiveContextWindowSize(model: string): number {
+  let contextWindow = getContextWindowForModel(model, getSdkBetas())
+  // The fixed reserves were sized for a 200k window. On a small local window
+  // (64k) they would leave almost nothing for the conversation, so scale them.
   const reservedTokensForSummary = Math.min(
     getMaxOutputTokensForModel(model),
     MAX_OUTPUT_TOKENS_FOR_SUMMARY,
+    smallWindowCap(contextWindow, 8),
   )
-  let contextWindow = getContextWindowForModel(model, getSdkBetas())
 
   const autoCompactWindow = process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW
   if (autoCompactWindow) {
@@ -69,11 +72,20 @@ export const MANUAL_COMPACT_BUFFER_TOKENS = 3_000
 // in a single session, wasting ~250K API calls/day globally.
 const MAX_CONSECUTIVE_AUTOCOMPACT_FAILURES = 3
 
+// OpenAI-compatible backends only: cap a fixed token reserve at 1/divisor of the
+// window, so 64k-128k local models keep most of their context usable
+function smallWindowCap(contextWindow: number, divisor: number): number {
+  return process.env.OPENAI_API_KEY
+    ? Math.floor(contextWindow / divisor)
+    : Number.POSITIVE_INFINITY
+}
+
 export function getAutoCompactThreshold(model: string): number {
   const effectiveContextWindow = getEffectiveContextWindowSize(model)
 
   const autocompactThreshold =
-    effectiveContextWindow - AUTOCOMPACT_BUFFER_TOKENS
+    effectiveContextWindow -
+    Math.min(AUTOCOMPACT_BUFFER_TOKENS, smallWindowCap(effectiveContextWindow, 10))
 
   // Override for easier testing of autocompact
   const envPercent = process.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE
@@ -110,8 +122,10 @@ export function calculateTokenWarningState(
     Math.round(((threshold - tokenUsage) / threshold) * 100),
   )
 
-  const warningThreshold = threshold - WARNING_THRESHOLD_BUFFER_TOKENS
-  const errorThreshold = threshold - ERROR_THRESHOLD_BUFFER_TOKENS
+  const warningThreshold =
+    threshold - Math.min(WARNING_THRESHOLD_BUFFER_TOKENS, smallWindowCap(threshold, 8))
+  const errorThreshold =
+    threshold - Math.min(ERROR_THRESHOLD_BUFFER_TOKENS, smallWindowCap(threshold, 8))
 
   const isAboveWarningThreshold = tokenUsage >= warningThreshold
   const isAboveErrorThreshold = tokenUsage >= errorThreshold

package/src/services/compact/cachedMCConfig.ts

@@ -0,0 +1 @@
+export { getCachedMCConfig, type CachedMCConfig } from './cachedMicrocompact.js'

package/src/services/compact/cachedMicrocompact.ts

@@ -0,0 +1,113 @@
+/**
+ * Cached microcompact: instead of rewriting old tool results locally, ask the
+ * API to drop them from the cached prompt with `cache_edits` blocks. That
+ * needs Anthropic's cache-editing beta, which no OpenAI-compatible backend
+ * offers, so this implementation keeps the bookkeeping but never enables the
+ * path. Enabling it requires CLAUDE_CODE_CACHED_MICROCOMPACT=1 and a model
+ * listed in the config.
+ */
+import { isEnvTruthy } from '../../utils/envUtils.js'
+
+export type CacheEdit = {
+  type: 'clear_tool_uses_20250919'
+  tool_use_ids: string[]
+}
+
+export type CacheEditsBlock = {
+  type: 'cache_edits'
+  edits: CacheEdit[]
+}
+
+export type PinnedCacheEdits = {
+  userMessageIndex: number
+  block: CacheEditsBlock
+}
+
+export type CachedMCState = {
+  /** tool_use_id -> whether the result has been sent to the API at least once */
+  toolResults: Map<string, { sent: boolean; order: number }>
+  /** tool_use_ids grouped by the user message that carried them, oldest first */
+  toolMessages: string[][]
+  /** ids already deleted via cache edits */
+  deleted: Set<string>
+  pinnedEdits: PinnedCacheEdits[]
+  nextOrder: number
+}
+
+export type CachedMCConfig = {
+  supportedModels: string[]
+  /** start deleting once this many sent tool results exist */
+  triggerThreshold: number
+  /** keep this many most recent tool results */
+  keepRecent: number
+}
+
+const DEFAULT_CONFIG: CachedMCConfig = {
+  supportedModels: [],
+  triggerThreshold: 40,
+  keepRecent: 20,
+}
+
+export function getCachedMCConfig(): CachedMCConfig {
+  const models = (process.env.CLAUDE_CODE_CACHED_MC_MODELS || '')
+    .split(',')
+    .map(s => s.trim())
+    .filter(Boolean)
+  return { ...DEFAULT_CONFIG, supportedModels: models }
+}
+
+export function isCachedMicrocompactEnabled(): boolean {
+  return isEnvTruthy(process.env.CLAUDE_CODE_CACHED_MICROCOMPACT)
+}
+
+export function isModelSupportedForCacheEditing(model: string): boolean {
+  if (!isCachedMicrocompactEnabled()) return false
+  return getCachedMCConfig().supportedModels.some(m => model.includes(m))
+}
+
+export function createCachedMCState(): CachedMCState {
+  return {
+    toolResults: new Map(),
+    toolMessages: [],
+    deleted: new Set(),
+    pinnedEdits: [],
+    nextOrder: 0,
+  }
+}
+
+export function resetCachedMCState(state: CachedMCState): void {
+  state.toolResults.clear()
+  state.toolMessages = []
+  state.deleted.clear()
+  state.pinnedEdits = []
+  state.nextOrder = 0
+}
+
+export function registerToolResult(state: CachedMCState, toolUseId: string): void {
+  if (!state.toolResults.has(toolUseId)) {
+    state.toolResults.set(toolUseId, { sent: false, order: state.nextOrder++ })
+  }
+}
+
+export function registerToolMessage(state: CachedMCState, toolUseIds: string[]): void {
+  if (toolUseIds.length > 0) state.toolMessages.push([...toolUseIds])
+}
+
+export function markToolsSentToAPI(state: CachedMCState): void {
+  for (const entry of state.toolResults.values()) entry.sent = true
+}
+
+/** Oldest sent tool results beyond the keep window, not yet deleted. */
+export function getToolResultsToDelete(state: CachedMCState): string[] {
+  const { triggerThreshold, keepRecent } = getCachedMCConfig()
+  const sent = [...state.toolResults.entries()]
+    .filter(([id, e]) => e.sent && !state.deleted.has(id))
+    .sort((a, b) => a[1].order - b[1].order)
+  if (sent.length < triggerThreshold) return []
+  return sent.slice(0, Math.max(0, sent.length - keepRecent)).map(([id]) => id)
+}
+
+export function createCacheEditsBlock(state: CachedMCState, toolUseIds: string[]): CacheEditsBlock {
+  for (const id of toolUseIds) state.deleted.add(id)
+  return { type: 'cache_edits', edits: [{ type: 'clear_tool_uses_20250919', tool_use_ids: toolUseIds }] }
+}

package/src/services/compact/compact.ts

@@ -426,7 +426,7 @@ export async function compactConversation(
     // Show requesting mode with up arrow and custom message
     context.setStreamMode?.('requesting')
     context.setResponseLength?.(() => 0)
-    context.onCompactProgress?.({ type: 'compact_start' })
+    context.onCompactProgress?.({ type: 'compact_start', preCompactTokenCount })
 
     // 3P default: true — forked-agent path reuses main conversation's prompt cache.
     // Experiment (Jan 2026) confirmed: false path is 98% cache miss, costs ~0.76% of
@@ -835,7 +835,7 @@ export async function partialCompactConversation(
 
     context.setStreamMode?.('requesting')
     context.setResponseLength?.(() => 0)
-    context.onCompactProgress?.({ type: 'compact_start' })
+    context.onCompactProgress?.({ type: 'compact_start', preCompactTokenCount })
 
     const compactPrompt = getPartialCompactPrompt(customInstructions, direction)
     const summaryRequest = createUserMessage({
@@ -1197,6 +1197,21 @@ async function streamCompactSummary({
           // fork — same signal the streaming fallback uses at
           // `signal: context.abortController.signal` below.
           overrides: { abortController: context.abortController },
+          // Feed streamed summary text into the parent's response counter so
+          // the spinner's progress bar and token count move while the
+          // summary is generated (the fork's own context is a no-op there).
+          onStreamEvent: message => {
+            const ev = message as { type?: string; event?: { type?: string; delta?: { type?: string; text?: string } } }
+            if (
+              ev.type === 'stream_event' &&
+              ev.event?.type === 'content_block_delta' &&
+              ev.event.delta?.type === 'text_delta' &&
+              typeof ev.event.delta.text === 'string'
+            ) {
+              const n = ev.event.delta.text.length
+              context.setResponseLength?.(length => length + n)
+            }
+          },
         })
         const assistantMsg = getLastAssistantMessage(result.messages)
         const assistantText = assistantMsg
@@ -1325,6 +1340,7 @@ async function streamCompactSummary({
         },
       })
       const streamIter = streamingGen[Symbol.asyncIterator]()
+      let summaryCharsStreamed = 0
       let next = await streamIter.next()
 
       while (!next.done) {
@@ -1346,6 +1362,7 @@ async function streamCompactSummary({
           event.event.delta.type === 'text_delta'
         ) {
           const charactersStreamed = event.event.delta.text.length
+          summaryCharsStreamed += charactersStreamed
           context.setResponseLength?.(length => length + charactersStreamed)
         }
 
@@ -1357,6 +1374,9 @@ async function streamCompactSummary({
       }
 
       if (response) {
+        logForDebugging(
+          `[compact] summary streamed: ${summaryCharsStreamed} chars, hasStartedStreaming=${hasStartedStreaming}`,
+        )
         return response
       }