subagent-cli 0.2.9 → 0.3.1

package/src/services/compact/compactWarningHook.ts

@@ -1,16 +0,0 @@
-import { useSyncExternalStore } from 'react'
-import { compactWarningStore } from './compactWarningState.js'
-
-/**
- * React hook to subscribe to compact warning suppression state.
- *
- * Lives in its own file so that compactWarningState.ts stays React-free:
- * microCompact.ts imports the pure state functions, and pulling React into
- * that module graph would drag it into the print-mode startup path.
- */
-export function useCompactWarningSuppression(): boolean {
-  return useSyncExternalStore(
-    compactWarningStore.subscribe,
-    compactWarningStore.getState,
-  )
-}

package/src/services/compact/compactWarningState.ts

@@ -1,18 +0,0 @@
-import { createStore } from '../../state/store.js'
-
-/**
- * Tracks whether the "context left until autocompact" warning should be suppressed.
- * We suppress immediately after successful compaction since we don't have accurate
- * token counts until the next API response.
- */
-export const compactWarningStore = createStore<boolean>(false)
-
-/** Suppress the compact warning. Call after successful compaction. */
-export function suppressCompactWarning(): void {
-  compactWarningStore.setState(() => true)
-}
-
-/** Clear the compact warning suppression. Called at start of new compact attempt. */
-export function clearCompactWarningSuppression(): void {
-  compactWarningStore.setState(() => false)
-}

package/src/services/compact/grouping.ts

@@ -1,63 +0,0 @@
-import type { Message } from '../../types/message.js'
-
-/**
- * Groups messages at API-round boundaries: one group per API round-trip.
- * A boundary fires when a NEW assistant response begins (different
- * message.id from the prior assistant). For well-formed conversations
- * this is an API-safe split point — the API contract requires every
- * tool_use to be resolved before the next assistant turn, so pairing
- * validity falls out of the assistant-id boundary. For malformed inputs
- * (dangling tool_use after resume/truncation) the fork's
- * ensureToolResultPairing repairs the split at API time.
- *
- * Replaces the prior human-turn grouping (boundaries only at real user
- * prompts) with finer-grained API-round grouping, allowing reactive
- * compact to operate on single-prompt agentic sessions (SDK/CCR/eval
- * callers) where the entire workload is one human turn.
- *
- * Extracted to its own file to break the compact.ts ↔ compactMessages.ts
- * cycle (CC-1180) — the cycle shifted module-init order enough to surface
- * a latent ws CJS/ESM resolution race in CI shard-2.
- */
-export function groupMessagesByApiRound(messages: Message[]): Message[][] {
-  const groups: Message[][] = []
-  let current: Message[] = []
-  // message.id of the most recently seen assistant. This is the sole
-  // boundary gate: streaming chunks from the same API response share an
-  // id, so boundaries only fire at the start of a genuinely new round.
-  // normalizeMessages yields one AssistantMessage per content block, and
-  // StreamingToolExecutor interleaves tool_results between chunks live
-  // (yield order, not concat order — see query.ts:613). The id check
-  // correctly keeps `[tu_A(id=X), result_A, tu_B(id=X)]` in one group.
-  let lastAssistantId: string | undefined
-
-  // In a well-formed conversation the API contract guarantees every
-  // tool_use is resolved before the next assistant turn, so lastAssistantId
-  // alone is a sufficient boundary gate. Tracking unresolved tool_use IDs
-  // would only do work when the conversation is malformed (dangling tool_use
-  // after resume-from-partial-batch or max_tokens truncation) — and in that
-  // case it pins the gate shut forever, merging all subsequent rounds into
-  // one group. We let those boundaries fire; the summarizer fork's own
-  // ensureToolResultPairing at claude.ts:1136 repairs the dangling tu at
-  // API time.
-  for (const msg of messages) {
-    if (
-      msg.type === 'assistant' &&
-      msg.message.id !== lastAssistantId &&
-      current.length > 0
-    ) {
-      groups.push(current)
-      current = [msg]
-    } else {
-      current.push(msg)
-    }
-    if (msg.type === 'assistant') {
-      lastAssistantId = msg.message.id
-    }
-  }
-
-  if (current.length > 0) {
-    groups.push(current)
-  }
-  return groups
-}

package/src/services/compact/microCompact.ts

@@ -1,530 +0,0 @@
-import { feature } from 'src/_stubs/bun-bundle.js'
-import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'
-import type { QuerySource } from '../../constants/querySource.js'
-import type { ToolUseContext } from '../../Tool.js'
-import { FILE_EDIT_TOOL_NAME } from '../../tools/FileEditTool/constants.js'
-import { FILE_READ_TOOL_NAME } from '../../tools/FileReadTool/prompt.js'
-import { FILE_WRITE_TOOL_NAME } from '../../tools/FileWriteTool/prompt.js'
-import { GLOB_TOOL_NAME } from '../../tools/GlobTool/prompt.js'
-import { GREP_TOOL_NAME } from '../../tools/GrepTool/prompt.js'
-import { WEB_FETCH_TOOL_NAME } from '../../tools/WebFetchTool/prompt.js'
-import { WEB_SEARCH_TOOL_NAME } from '../../tools/WebSearchTool/prompt.js'
-import type { Message } from '../../types/message.js'
-import { logForDebugging } from '../../utils/debug.js'
-import { getMainLoopModel } from '../../utils/model/model.js'
-import { SHELL_TOOL_NAMES } from '../../utils/shell/shellToolUtils.js'
-import { jsonStringify } from '../../utils/slowOperations.js'
-import {
-  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
-  logEvent,
-} from '../analytics/index.js'
-import { notifyCacheDeletion } from '../api/promptCacheBreakDetection.js'
-import { roughTokenCountEstimation } from '../tokenEstimation.js'
-import {
-  clearCompactWarningSuppression,
-  suppressCompactWarning,
-} from './compactWarningState.js'
-import {
-  getTimeBasedMCConfig,
-  type TimeBasedMCConfig,
-} from './timeBasedMCConfig.js'
-
-// Inline from utils/toolResultStorage.ts — importing that file pulls in
-// sessionStorage → utils/messages → services/api/errors, completing a
-// circular-deps loop back through this file via promptCacheBreakDetection.
-// Drift is caught by a test asserting equality with the source-of-truth.
-export const TIME_BASED_MC_CLEARED_MESSAGE = '[Old tool result content cleared]'
-
-const IMAGE_MAX_TOKEN_SIZE = 2000
-
-// Only compact these tools
-const COMPACTABLE_TOOLS = new Set<string>([
-  FILE_READ_TOOL_NAME,
-  ...SHELL_TOOL_NAMES,
-  GREP_TOOL_NAME,
-  GLOB_TOOL_NAME,
-  WEB_SEARCH_TOOL_NAME,
-  WEB_FETCH_TOOL_NAME,
-  FILE_EDIT_TOOL_NAME,
-  FILE_WRITE_TOOL_NAME,
-])
-
-// --- Cached microcompact state (ant-only, gated by feature('CACHED_MICROCOMPACT')) ---
-
-// Lazy-initialized cached MC module and state to avoid importing in external builds.
-// The imports and state live inside feature() checks for dead code elimination.
-let cachedMCModule: typeof import('./cachedMicrocompact.js') | null = null
-let cachedMCState: import('./cachedMicrocompact.js').CachedMCState | null = null
-let pendingCacheEdits:
-  | import('./cachedMicrocompact.js').CacheEditsBlock
-  | null = null
-
-async function getCachedMCModule(): Promise<
-  typeof import('./cachedMicrocompact.js')
-> {
-  if (!cachedMCModule) {
-    cachedMCModule = await import('./cachedMicrocompact.js')
-  }
-  return cachedMCModule
-}
-
-function ensureCachedMCState(): import('./cachedMicrocompact.js').CachedMCState {
-  if (!cachedMCState && cachedMCModule) {
-    cachedMCState = cachedMCModule.createCachedMCState()
-  }
-  if (!cachedMCState) {
-    throw new Error(
-      'cachedMCState not initialized — getCachedMCModule() must be called first',
-    )
-  }
-  return cachedMCState
-}
-
-/**
- * Get new pending cache edits to be included in the next API request.
- * Returns null if there are no new pending edits.
- * Clears the pending state (caller must pin them after insertion).
- */
-export function consumePendingCacheEdits():
-  | import('./cachedMicrocompact.js').CacheEditsBlock
-  | null {
-  const edits = pendingCacheEdits
-  pendingCacheEdits = null
-  return edits
-}
-
-/**
- * Get all previously-pinned cache edits that must be re-sent at their
- * original positions for cache hits.
- */
-export function getPinnedCacheEdits(): import('./cachedMicrocompact.js').PinnedCacheEdits[] {
-  if (!cachedMCState) {
-    return []
-  }
-  return cachedMCState.pinnedEdits
-}
-
-/**
- * Pin a new cache_edits block to a specific user message position.
- * Called after inserting new edits so they are re-sent in subsequent calls.
- */
-export function pinCacheEdits(
-  userMessageIndex: number,
-  block: import('./cachedMicrocompact.js').CacheEditsBlock,
-): void {
-  if (cachedMCState) {
-    cachedMCState.pinnedEdits.push({ userMessageIndex, block })
-  }
-}
-
-/**
- * Marks all registered tools as sent to the API.
- * Called after a successful API response.
- */
-export function markToolsSentToAPIState(): void {
-  if (cachedMCState && cachedMCModule) {
-    cachedMCModule.markToolsSentToAPI(cachedMCState)
-  }
-}
-
-export function resetMicrocompactState(): void {
-  if (cachedMCState && cachedMCModule) {
-    cachedMCModule.resetCachedMCState(cachedMCState)
-  }
-  pendingCacheEdits = null
-}
-
-// Helper to calculate tool result tokens
-function calculateToolResultTokens(block: ToolResultBlockParam): number {
-  if (!block.content) {
-    return 0
-  }
-
-  if (typeof block.content === 'string') {
-    return roughTokenCountEstimation(block.content)
-  }
-
-  // Array of TextBlockParam | ImageBlockParam | DocumentBlockParam
-  return block.content.reduce((sum, item) => {
-    if (item.type === 'text') {
-      return sum + roughTokenCountEstimation(item.text)
-    } else if (item.type === 'image' || item.type === 'document') {
-      // Images/documents are approximately 2000 tokens regardless of format
-      return sum + IMAGE_MAX_TOKEN_SIZE
-    }
-    return sum
-  }, 0)
-}
-
-/**
- * Estimate token count for messages by extracting text content
- * Used for rough token estimation when we don't have accurate API counts
- * Pads estimate by 4/3 to be conservative since we're approximating
- */
-export function estimateMessageTokens(messages: Message[]): number {
-  let totalTokens = 0
-
-  for (const message of messages) {
-    if (message.type !== 'user' && message.type !== 'assistant') {
-      continue
-    }
-
-    if (!Array.isArray(message.message.content)) {
-      continue
-    }
-
-    for (const block of message.message.content) {
-      if (block.type === 'text') {
-        totalTokens += roughTokenCountEstimation(block.text)
-      } else if (block.type === 'tool_result') {
-        totalTokens += calculateToolResultTokens(block)
-      } else if (block.type === 'image' || block.type === 'document') {
-        totalTokens += IMAGE_MAX_TOKEN_SIZE
-      } else if (block.type === 'thinking') {
-        // Match roughTokenCountEstimationForBlock: count only the thinking
-        // text, not the JSON wrapper or signature (signature is metadata,
-        // not model-tokenized content).
-        totalTokens += roughTokenCountEstimation(block.thinking)
-      } else if (block.type === 'redacted_thinking') {
-        totalTokens += roughTokenCountEstimation(block.data)
-      } else if (block.type === 'tool_use') {
-        // Match roughTokenCountEstimationForBlock: count name + input,
-        // not the JSON wrapper or id field.
-        totalTokens += roughTokenCountEstimation(
-          block.name + jsonStringify(block.input ?? {}),
-        )
-      } else {
-        // server_tool_use, web_search_tool_result, etc.
-        totalTokens += roughTokenCountEstimation(jsonStringify(block))
-      }
-    }
-  }
-
-  // Pad estimate by 4/3 to be conservative since we're approximating
-  return Math.ceil(totalTokens * (4 / 3))
-}
-
-export type PendingCacheEdits = {
-  trigger: 'auto'
-  deletedToolIds: string[]
-  // Baseline cumulative cache_deleted_input_tokens from the previous API response,
-  // used to compute the per-operation delta (the API value is sticky/cumulative)
-  baselineCacheDeletedTokens: number
-}
-
-export type MicrocompactResult = {
-  messages: Message[]
-  compactionInfo?: {
-    pendingCacheEdits?: PendingCacheEdits
-  }
-}
-
-/**
- * Walk messages and collect tool_use IDs whose tool name is in
- * COMPACTABLE_TOOLS, in encounter order. Shared by both microcompact paths.
- */
-function collectCompactableToolIds(messages: Message[]): string[] {
-  const ids: string[] = []
-  for (const message of messages) {
-    if (
-      message.type === 'assistant' &&
-      Array.isArray(message.message.content)
-    ) {
-      for (const block of message.message.content) {
-        if (block.type === 'tool_use' && COMPACTABLE_TOOLS.has(block.name)) {
-          ids.push(block.id)
-        }
-      }
-    }
-  }
-  return ids
-}
-
-// Prefix-match because promptCategory.ts sets the querySource to
-// 'repl_main_thread:outputStyle:<style>' when a non-default output style
-// is active. The bare 'repl_main_thread' is only used for the default style.
-// query.ts:350/1451 use the same startsWith pattern; the pre-existing
-// cached-MC `=== 'repl_main_thread'` check was a latent bug — users with a
-// non-default output style were silently excluded from cached MC.
-function isMainThreadSource(querySource: QuerySource | undefined): boolean {
-  return !querySource || querySource.startsWith('repl_main_thread')
-}
-
-export async function microcompactMessages(
-  messages: Message[],
-  toolUseContext?: ToolUseContext,
-  querySource?: QuerySource,
-): Promise<MicrocompactResult> {
-  // Clear suppression flag at start of new microcompact attempt
-  clearCompactWarningSuppression()
-
-  // Time-based trigger runs first and short-circuits. If the gap since the
-  // last assistant message exceeds the threshold, the server cache has expired
-  // and the full prefix will be rewritten regardless — so content-clear old
-  // tool results now, before the request, to shrink what gets rewritten.
-  // Cached MC (cache-editing) is skipped when this fires: editing assumes a
-  // warm cache, and we just established it's cold.
-  const timeBasedResult = maybeTimeBasedMicrocompact(messages, querySource)
-  if (timeBasedResult) {
-    return timeBasedResult
-  }
-
-  // Only run cached MC for the main thread to prevent forked agents
-  // (session_memory, prompt_suggestion, etc.) from registering their
-  // tool_results in the global cachedMCState, which would cause the main
-  // thread to try deleting tools that don't exist in its own conversation.
-  if (feature('CACHED_MICROCOMPACT')) {
-    const mod = await getCachedMCModule()
-    const model = toolUseContext?.options.mainLoopModel ?? getMainLoopModel()
-    if (
-      mod.isCachedMicrocompactEnabled() &&
-      mod.isModelSupportedForCacheEditing(model) &&
-      isMainThreadSource(querySource)
-    ) {
-      return await cachedMicrocompactPath(messages, querySource)
-    }
-  }
-
-  // Legacy microcompact path removed — tengu_cache_plum_violet is always true.
-  // For contexts where cached microcompact is not available (external builds,
-  // non-ant users, unsupported models, sub-agents), no compaction happens here;
-  // autocompact handles context pressure instead.
-  return { messages }
-}
-
-/**
- * Cached microcompact path - uses cache editing API to remove tool results
- * without invalidating the cached prefix.
- *
- * Key differences from regular microcompact:
- * - Does NOT modify local message content (cache_reference and cache_edits are added at API layer)
- * - Uses count-based trigger/keep thresholds from GrowthBook config
- * - Takes precedence over regular microcompact (no disk persistence)
- * - Tracks tool results and queues cache edits for the API layer
- */
-async function cachedMicrocompactPath(
-  messages: Message[],
-  querySource: QuerySource | undefined,
-): Promise<MicrocompactResult> {
-  const mod = await getCachedMCModule()
-  const state = ensureCachedMCState()
-  const config = mod.getCachedMCConfig()
-
-  const compactableToolIds = new Set(collectCompactableToolIds(messages))
-  // Second pass: register tool results grouped by user message
-  for (const message of messages) {
-    if (message.type === 'user' && Array.isArray(message.message.content)) {
-      const groupIds: string[] = []
-      for (const block of message.message.content) {
-        if (
-          block.type === 'tool_result' &&
-          compactableToolIds.has(block.tool_use_id) &&
-          !state.registeredTools.has(block.tool_use_id)
-        ) {
-          mod.registerToolResult(state, block.tool_use_id)
-          groupIds.push(block.tool_use_id)
-        }
-      }
-      mod.registerToolMessage(state, groupIds)
-    }
-  }
-
-  const toolsToDelete = mod.getToolResultsToDelete(state)
-
-  if (toolsToDelete.length > 0) {
-    // Create and queue the cache_edits block for the API layer
-    const cacheEdits = mod.createCacheEditsBlock(state, toolsToDelete)
-    if (cacheEdits) {
-      pendingCacheEdits = cacheEdits
-    }
-
-    logForDebugging(
-      `Cached MC deleting ${toolsToDelete.length} tool(s): ${toolsToDelete.join(', ')}`,
-    )
-
-    // Log the event
-    logEvent('tengu_cached_microcompact', {
-      toolsDeleted: toolsToDelete.length,
-      deletedToolIds: toolsToDelete.join(
-        ',',
-      ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
-      activeToolCount: state.toolOrder.length - state.deletedRefs.size,
-      triggerType:
-        'auto' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
-      threshold: config.triggerThreshold,
-      keepRecent: config.keepRecent,
-    })
-
-    // Suppress warning after successful compaction
-    suppressCompactWarning()
-
-    // Notify cache break detection that cache reads will legitimately drop
-    if (feature('PROMPT_CACHE_BREAK_DETECTION')) {
-      // Pass the actual querySource — isMainThreadSource now prefix-matches
-      // so output-style variants enter here, and getTrackingKey keys on the
-      // full source string, not the 'repl_main_thread' prefix.
-      notifyCacheDeletion(querySource ?? 'repl_main_thread')
-    }
-
-    // Return messages unchanged - cache_reference and cache_edits are added at API layer
-    // Boundary message is deferred until after API response so we can use
-    // actual cache_deleted_input_tokens from the API instead of client-side estimates
-    // Capture the baseline cumulative cache_deleted_input_tokens from the last
-    // assistant message so we can compute a per-operation delta after the API call
-    const lastAsst = messages.findLast(m => m.type === 'assistant')
-    const baseline =
-      lastAsst?.type === 'assistant'
-        ? ((
-            lastAsst.message.usage as unknown as Record<
-              string,
-              number | undefined
-            >
-          )?.cache_deleted_input_tokens ?? 0)
-        : 0
-
-    return {
-      messages,
-      compactionInfo: {
-        pendingCacheEdits: {
-          trigger: 'auto',
-          deletedToolIds: toolsToDelete,
-          baselineCacheDeletedTokens: baseline,
-        },
-      },
-    }
-  }
-
-  // No compaction needed, return messages unchanged
-  return { messages }
-}
-
-/**
- * Time-based microcompact: when the gap since the last main-loop assistant
- * message exceeds the configured threshold, content-clear all but the most
- * recent N compactable tool results.
- *
- * Returns null when the trigger doesn't fire (disabled, wrong source, gap
- * under threshold, nothing to clear) — caller falls through to other paths.
- *
- * Unlike cached MC, this mutates message content directly. The cache is cold,
- * so there's no cached prefix to preserve via cache_edits.
- */
-/**
- * Check whether the time-based trigger should fire for this request.
- *
- * Returns the measured gap (minutes since last assistant message) when the
- * trigger fires, or null when it doesn't (disabled, wrong source, under
- * threshold, no prior assistant, unparseable timestamp).
- *
- * Extracted so other pre-request paths (e.g. snip force-apply) can consult
- * the same predicate without coupling to the tool-result clearing action.
- */
-export function evaluateTimeBasedTrigger(
-  messages: Message[],
-  querySource: QuerySource | undefined,
-): { gapMinutes: number; config: TimeBasedMCConfig } | null {
-  const config = getTimeBasedMCConfig()
-  // Require an explicit main-thread querySource. isMainThreadSource treats
-  // undefined as main-thread (for cached-MC backward-compat), but several
-  // callers (/context, /compact, analyzeContext) invoke microcompactMessages
-  // without a source for analysis-only purposes — they should not trigger.
-  if (!config.enabled || !querySource || !isMainThreadSource(querySource)) {
-    return null
-  }
-  const lastAssistant = messages.findLast(m => m.type === 'assistant')
-  if (!lastAssistant) {
-    return null
-  }
-  const gapMinutes =
-    (Date.now() - new Date(lastAssistant.timestamp).getTime()) / 60_000
-  if (!Number.isFinite(gapMinutes) || gapMinutes < config.gapThresholdMinutes) {
-    return null
-  }
-  return { gapMinutes, config }
-}
-
-function maybeTimeBasedMicrocompact(
-  messages: Message[],
-  querySource: QuerySource | undefined,
-): MicrocompactResult | null {
-  const trigger = evaluateTimeBasedTrigger(messages, querySource)
-  if (!trigger) {
-    return null
-  }
-  const { gapMinutes, config } = trigger
-
-  const compactableIds = collectCompactableToolIds(messages)
-
-  // Floor at 1: slice(-0) returns the full array (paradoxically keeps
-  // everything), and clearing ALL results leaves the model with zero working
-  // context. Neither degenerate is sensible — always keep at least the last.
-  const keepRecent = Math.max(1, config.keepRecent)
-  const keepSet = new Set(compactableIds.slice(-keepRecent))
-  const clearSet = new Set(compactableIds.filter(id => !keepSet.has(id)))
-
-  if (clearSet.size === 0) {
-    return null
-  }
-
-  let tokensSaved = 0
-  const result: Message[] = messages.map(message => {
-    if (message.type !== 'user' || !Array.isArray(message.message.content)) {
-      return message
-    }
-    let touched = false
-    const newContent = message.message.content.map(block => {
-      if (
-        block.type === 'tool_result' &&
-        clearSet.has(block.tool_use_id) &&
-        block.content !== TIME_BASED_MC_CLEARED_MESSAGE
-      ) {
-        tokensSaved += calculateToolResultTokens(block)
-        touched = true
-        return { ...block, content: TIME_BASED_MC_CLEARED_MESSAGE }
-      }
-      return block
-    })
-    if (!touched) return message
-    return {
-      ...message,
-      message: { ...message.message, content: newContent },
-    }
-  })
-
-  if (tokensSaved === 0) {
-    return null
-  }
-
-  logEvent('tengu_time_based_microcompact', {
-    gapMinutes: Math.round(gapMinutes),
-    gapThresholdMinutes: config.gapThresholdMinutes,
-    toolsCleared: clearSet.size,
-    toolsKept: keepSet.size,
-    keepRecent: config.keepRecent,
-    tokensSaved,
-  })
-
-  logForDebugging(
-    `[TIME-BASED MC] gap ${Math.round(gapMinutes)}min > ${config.gapThresholdMinutes}min, cleared ${clearSet.size} tool results (~${tokensSaved} tokens), kept last ${keepSet.size}`,
-  )
-
-  suppressCompactWarning()
-  // Cached-MC state (module-level) holds tool IDs registered on prior turns.
-  // We just content-cleared some of those tools AND invalidated the server
-  // cache by changing prompt content. If cached-MC runs next turn with the
-  // stale state, it would try to cache_edit tools whose server-side entries
-  // no longer exist. Reset it.
-  resetMicrocompactState()
-  // We just changed the prompt content — the next response's cache read will
-  // be low, but that's us, not a break. Tell the detector to expect a drop.
-  // notifyCacheDeletion (not notifyCompaction) because it's already imported
-  // here and achieves the same false-positive suppression — adding the second
-  // symbol to the import was flagged by the circular-deps check.
-  // Pass the actual querySource: getTrackingKey returns the full source string
-  // (e.g. 'repl_main_thread:outputStyle:custom'), not just the prefix.
-  if (feature('PROMPT_CACHE_BREAK_DETECTION') && querySource) {
-    notifyCacheDeletion(querySource)
-  }
-
-  return { messages: result }
-}