@shawnstack/quickforge 1.3.30 → 1.4.1

package/dist/assets/xterm-BrP-ENHg.css

@@ -0,0 +1 @@
+.xterm{cursor:text;-webkit-user-select:none;user-select:none;position:relative}.xterm.focus,.xterm:focus{outline:none}.xterm .xterm-helpers{z-index:5;position:absolute;top:0}.xterm .xterm-helper-textarea{opacity:0;z-index:-5;white-space:nowrap;resize:none;border:0;width:0;height:0;margin:0;padding:0;position:absolute;top:0;left:-9999em;overflow:hidden}.xterm .composition-view{color:#fff;white-space:nowrap;z-index:1;background:#000;display:none;position:absolute}.xterm .composition-view.active{display:block}.xterm .xterm-viewport{cursor:default;background-color:#000;position:absolute;inset:0;overflow-y:scroll}.xterm .xterm-screen{position:relative}.xterm .xterm-screen canvas{position:absolute;top:0;left:0}.xterm-char-measure-element{visibility:hidden;line-height:normal;display:inline-block;position:absolute;top:0;left:-9999em}.xterm.enable-mouse-events{cursor:default}.xterm.xterm-cursor-pointer,.xterm .xterm-cursor-pointer{cursor:pointer}.xterm.column-select.focus{cursor:crosshair}.xterm .xterm-accessibility:not(.debug),.xterm .xterm-message{z-index:10;color:#0000;pointer-events:none;position:absolute;inset:0}.xterm .xterm-accessibility-tree:not(.debug) ::selection{color:#0000}.xterm .xterm-accessibility-tree{-webkit-user-select:text;user-select:text;white-space:pre;font-family:monospace}.xterm .xterm-accessibility-tree>div{transform-origin:0;width:fit-content}.xterm .live-region{width:1px;height:1px;position:absolute;left:-9999px;overflow:hidden}.xterm-dim{opacity:1!important}.xterm-underline-1{text-decoration:underline}.xterm-underline-2{-webkit-text-decoration:underline double;text-decoration:underline double}.xterm-underline-3{-webkit-text-decoration:underline wavy;text-decoration:underline wavy}.xterm-underline-4{-webkit-text-decoration:underline dotted;text-decoration:underline dotted}.xterm-underline-5{-webkit-text-decoration:underline dashed;text-decoration:underline dashed}.xterm-overline{text-decoration:overline}.xterm-overline.xterm-underline-1{text-decoration:underline overline}.xterm-overline.xterm-underline-2{-webkit-text-decoration:overline double underline;text-decoration:overline double underline}.xterm-overline.xterm-underline-3{-webkit-text-decoration:overline wavy underline;text-decoration:overline wavy underline}.xterm-overline.xterm-underline-4{-webkit-text-decoration:overline dotted underline;text-decoration:overline dotted underline}.xterm-overline.xterm-underline-5{-webkit-text-decoration:overline dashed underline;text-decoration:overline dashed underline}.xterm-strikethrough{text-decoration:line-through}.xterm-screen .xterm-decoration-container .xterm-decoration{z-index:6;position:absolute}.xterm-screen .xterm-decoration-container .xterm-decoration.xterm-decoration-top-layer{z-index:7}.xterm-decoration-overview-ruler{z-index:8;pointer-events:none;position:absolute;top:0;right:0}.xterm-decoration-top{z-index:2;position:relative}.xterm .xterm-scrollable-element>.scrollbar{cursor:default}.xterm .xterm-scrollable-element>.scrollbar>.scra{cursor:pointer;font-size:11px!important}.xterm .xterm-scrollable-element>.visible{opacity:1;z-index:11;background:0 0;transition:opacity .1s linear}.xterm .xterm-scrollable-element>.invisible{opacity:0;pointer-events:none}.xterm .xterm-scrollable-element>.invisible.fade{transition:opacity .8s linear}.xterm .xterm-scrollable-element>.shadow{display:none;position:absolute}.xterm .xterm-scrollable-element>.shadow.top{width:100%;height:3px;box-shadow:var(--vscode-scrollbar-shadow,#000) 0 6px 6px -6px inset;display:block;top:0;left:3px}.xterm .xterm-scrollable-element>.shadow.left{width:3px;height:100%;box-shadow:var(--vscode-scrollbar-shadow,#000) 6px 0 6px -6px inset;display:block;top:3px;left:0}.xterm .xterm-scrollable-element>.shadow.top-left-corner{width:3px;height:3px;display:block;top:0;left:0}.xterm .xterm-scrollable-element>.shadow.top.left{box-shadow:var(--vscode-scrollbar-shadow,#000) 6px 0 6px -6px inset}

package/dist/index.html

@@ -11,13 +11,16 @@
     <meta name="apple-mobile-web-app-title" content="QuickForge" />
     <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
     <title>速构 QuickForge</title>
-    <script type="module" crossorigin src="/assets/index-CQq-kPng.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-CkqCuyE9.js">
+    <script type="module" crossorigin src="/assets/index-Dcf73EL8.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-DWdDZTNf.js">
+    <link rel="modulepreload" crossorigin href="/assets/pi-ai-Cx633yhb.js">
     <link rel="modulepreload" crossorigin href="/assets/lit-vendor-Dr3cpBGF.js">
+    <link rel="modulepreload" crossorigin href="/assets/pi-web-ui-CBet4bMl.js">
     <link rel="modulepreload" crossorigin href="/assets/css-utils-rkE68RDy.js">
-    <link rel="modulepreload" crossorigin href="/assets/icons-BVM5--R9.js">
-    <link rel="modulepreload" crossorigin href="/assets/react-vendor-DAoL5p8_.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-D0c0FMPa.css">
+    <link rel="modulepreload" crossorigin href="/assets/icons-BWtivFsx.js">
+    <link rel="modulepreload" crossorigin href="/assets/react-vendor-Mthyt1p4.js">
+    <link rel="modulepreload" crossorigin href="/assets/logger-B65Akg8A.js">
+    <link rel="stylesheet" crossorigin href="/assets/index-CxOHP41X.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shawnstack/quickforge",
-  "version": "1.3.30",
+  "version": "1.4.1",
   "description": "AI chat application with YOLO-mode local workspace tools. React + Vite + Tailwind CSS frontend, local Node.js storage server.",
   "keywords": [
     "ai",

package/server/agent-manager.mjs

@@ -35,7 +35,6 @@ import { omitDetailsForLlm, serverConvertToLlm, messageText, lastAssistantText }
 import { isPlainObject, mergeQuickForgeTiming, wrapToolDefinition, wrapMcpToolDefinition, wrapPluginToolDefinition, sessionSkillsContext } from './tool-wiring.mjs'
 import {
   APPROVAL_TIMEOUT_MS,
-  commandRestrictedTools,
   safeReadTools,
   pendingApprovals,
   pendingAutoCompactApprovals,
@@ -196,19 +195,14 @@ function createApprovalPromise(session, toolCallId, toolName, args, source) {
       source,
     })
 
-    // Notify the frontend via both the session-level and global event buses.
-    // The global SSE handler (/api/agents/events) only listens to `agentEvents`,
-    // so events emitted only on session.eventBus never reach the client.
-    const approvalEvent = {
+    emitSessionEvent(session, {
       type: 'tool_approval_required',
       sessionId: session.sessionId,
       toolCallId,
       toolName,
       args,
       source,
-    }
-    session.eventBus.emit('agent_event', approvalEvent)
-    agentEvents.emit('agent_event', approvalEvent)
+    })
   })
 }
 
@@ -312,11 +306,18 @@ function estimateTokenReduction(originalChars, finalChars) {
   return Math.max(0, Math.min(99, Math.round(((originalChars - finalChars) / originalChars) * 100)))
 }
 
+function nextSessionStateVersion(session) {
+  const current = Number.isFinite(session?.stateVersion) ? session.stateVersion : 0
+  session.stateVersion = current + 1
+  return session.stateVersion
+}
+
 function emitSessionEvent(session, event) {
+  const stateVersion = nextSessionStateVersion(session)
   const enrichedEvent = (event?.type === 'message_end' || event?.type === 'agent_end' || event?.type === 'messages_replaced' || event?.type === 'auto_compact_completed')
     && event.contextUsage === undefined
-    ? { ...event, contextUsage: getSessionContextUsage(session) }
-    : event
+    ? { ...event, contextUsage: getSessionContextUsage(session), stateVersion }
+    : { ...event, stateVersion }
   session.eventBus.emit('agent_event', enrichedEvent)
   agentEvents.emit('agent_event', { sessionId: session.sessionId, ...enrichedEvent })
 }
@@ -543,9 +544,59 @@ async function clearSession(session) {
   return { sessionId: session.sessionId, status: session.status, cleared: true }
 }
 
-async function resolveCommandState(session, userMessage) {
+const QUICKFORGE_COMMAND_DETAILS_KEY = 'quickforgeCommand'
+
+function normalizedPromptCommand(command) {
+  return command?.type === 'plan' ? { type: 'plan' } : null
+}
+
+function objectDetails(message) {
+  const details = message?.details
+  return details && typeof details === 'object' && !Array.isArray(details) ? details : {}
+}
+
+function promptCommandFromMessage(message) {
+  return normalizedPromptCommand(objectDetails(message)[QUICKFORGE_COMMAND_DETAILS_KEY])
+}
+
+function messageWithPromptCommand(message, command) {
+  const normalized = normalizedPromptCommand(command)
+  if (!normalized || !message || typeof message !== 'object') return message
+  return {
+    ...message,
+    details: {
+      ...objectDetails(message),
+      [QUICKFORGE_COMMAND_DETAILS_KEY]: normalized,
+    },
+  }
+}
+
+function internalInvocationForPromptCommand(userMessage, command) {
+  const normalized = normalizedPromptCommand(command)
+  if (normalized?.type === 'plan') {
+    // Derive the task from the message text. Strip a leading "/plan" so that
+    // toggling plan mode while typing "/plan <task>" yields the clean task —
+    // matching the slash-command parse path and avoiding a redundant prefix.
+    const raw = messageText(userMessage).trim()
+    const planPrefix = raw.match(/^\/plan(?:\s+([\s\S]*))?$/i)
+    return { type: 'plan', args: planPrefix ? (planPrefix[1] || '').trim() : raw }
+  }
+  return parseInternalCommandInvocation(userMessage)
+}
+
+function planCommandState(userMessage, args) {
+  return {
+    userMessage: messageWithPromptCommand(userMessage, { type: 'plan' }),
+    commandPrompt: formatPlanCommandPrompt(args),
+    permissions: { allowEdit: false, allowCommands: false, allowSubagents: true },
+    commandName: 'plan',
+  }
+}
+
+async function resolveCommandState(session, userMessage, promptCommand = null) {
+  const command = normalizedPromptCommand(promptCommand) || promptCommandFromMessage(userMessage)
   const internalResponse = await handleInternalCommand(
-    parseInternalCommandInvocation(userMessage),
+    internalInvocationForPromptCommand(userMessage, command),
     session.projectContext?.workspaceRoot,
     session.projectContext?.project?.commandDir,
   )
@@ -553,12 +604,7 @@ async function resolveCommandState(session, userMessage) {
   if (internalResponse?.clear) return { clear: internalResponse }
   if (internalResponse?.compact) return { compact: internalResponse }
   if (internalResponse?.plan) {
-    return {
-      userMessage,
-      commandPrompt: formatPlanCommandPrompt(internalResponse.args),
-      permissions: { allowEdit: false, allowCommands: false, allowSubagents: true },
-      commandName: 'plan',
-    }
+    return planCommandState(userMessage, internalResponse.args)
   }
   if (internalResponse?.review) {
     return {
@@ -569,7 +615,22 @@ async function resolveCommandState(session, userMessage) {
     }
   }
 
-  if (!session.projectContext?.workspaceRoot) return { userMessage }
+  if (!session.projectContext?.workspaceRoot) {
+    // Even without a project, user-level custom commands (~/.quickforge/commands/) are available
+    const invocation = await resolveCustomCommandInvocation(
+      userMessage,
+      null,
+      session.projectContext?.project?.commandDir,
+    )
+    if (!invocation) return { userMessage }
+
+    return {
+      userMessage,
+      commandPrompt: invocation.systemPrompt,
+      permissions: invocation.permissions,
+      commandName: invocation.command.name,
+    }
+  }
 
   const invocation = await resolveCustomCommandInvocation(
     userMessage,
@@ -1138,6 +1199,7 @@ export async function createAgent(sessionId, config = {}) {
     activeCommandPrompt: null,
     eventBus,
     idleTimer: null,
+    persistTimer: null,
     titleGenerated: false,
     toolTimings: new Map(),
     getApiKey,
@@ -1145,6 +1207,7 @@ export async function createAgent(sessionId, config = {}) {
     agentProfile: agentProfile ? agentProfileSnapshot(agentProfile) : null,
     lastTransformedContextMessages: null,
     autoCompacting: false,
+    stateVersion: 0,
     lastAutoCompactAt: null,
     lastAutoCompactRejected: null,
     /** Track active SSE connections. Only one SSE stream allowed per session to prevent
@@ -1159,8 +1222,20 @@ export async function createAgent(sessionId, config = {}) {
     // complete session history.  Replace with the authoritative full state
     // before forwarding to clients.
     const timedEvent = addToolTimingToEvent(session, event)
-    const forwardEvent = timedEvent.type === 'agent_end' && timedEvent.messages
-      ? { ...timedEvent, messages: agent.state.messages }
+    const eventEndStatus = event.type === 'agent_end'
+      ? session.agent.signal?.aborted
+        ? 'aborted'
+        : session.agent.state.errorMessage
+          ? 'error'
+          : 'idle'
+      : undefined
+    const forwardEvent = timedEvent.type === 'agent_end'
+      ? {
+          ...timedEvent,
+          ...(timedEvent.messages ? { messages: agent.state.messages } : {}),
+          status: eventEndStatus,
+          ...(session.agent.state.errorMessage && timedEvent.errorMessage === undefined ? { errorMessage: session.agent.state.errorMessage } : {}),
+        }
       : timedEvent
 
     // Forward all events to the session event bus and the global bus.
@@ -1178,22 +1253,21 @@ export async function createAgent(sessionId, config = {}) {
     }
 
     if (event.type === 'agent_end') {
-      session.status = session.agent.state.errorMessage ? 'error' : 'idle'
+      session.status = eventEndStatus || (session.agent.state.errorMessage ? 'error' : 'idle')
       session.finishedAt = new Date().toISOString()
       session.toolTimings?.clear()
       resetIdleTimer(session)
 
-      // Persist after run ends
-      persistSession(session).catch((err) =>
+      // Persist after run ends. Flush any debounced write so the final state is durable.
+      flushSessionPersist(session).catch((err) =>
         logger.error(`Failed to persist session ${sessionId}:`, err, { sessionId }),
       )
     }
 
     if (event.type === 'message_end') {
-      // Do a lightweight persist on message_end for crash recovery
-      persistSession(session).catch((err) =>
-        logger.error(`Failed to persist session ${sessionId}:`, err, { sessionId }),
-      )
+      // Debounced persist for crash recovery; coalesces the many message_end
+      // events within a single run into infrequent full-session writes.
+      scheduleSessionPersist(session)
     }
   })
 
@@ -1337,6 +1411,44 @@ async function persistSession(session) {
 }
 
 export async function persistSessionState(session) {
+  await flushSessionPersist(session)
+}
+
+/**
+ * Coalesce fire-and-forget session persists during a run.
+ *
+ * persistSession() serializes the ENTIRE session (all messages) on every call,
+ * and the agent event loop calls it on agent_start / each message_end / agent_end.
+ * Within a single run these events fire many times (one per assistant turn +
+ * tool result), so writing on each one makes cumulative disk I/O O(n^2) as a
+ * conversation grows. These message_end call sites are fire-and-forget
+ * (crash-recovery only), so we debounce them into at most one write per
+ * PERSIST_DEBOUNCE_MS. Run boundaries (agent_end) and explicit persists cancel
+ * the pending timer and write the current state immediately, so the final
+ * state is always durable.
+ */
+const PERSIST_DEBOUNCE_MS = 400
+
+function scheduleSessionPersist(session) {
+  if (session.persistTimer) return
+  session.persistTimer = setTimeout(() => {
+    session.persistTimer = null
+    persistSession(session).catch((err) =>
+      logger.error(`Failed to persist session ${session.sessionId}:`, err, { sessionId: session.sessionId }),
+    )
+  }, PERSIST_DEBOUNCE_MS).unref?.()
+}
+
+/**
+ * Cancel any pending debounced write and persist the current state immediately.
+ * Used at run boundaries (agent_end) and by explicit persistSessionState() so
+ * the final state is always durable regardless of a pending timer.
+ */
+async function flushSessionPersist(session) {
+  if (session.persistTimer) {
+    clearTimeout(session.persistTimer)
+    session.persistTimer = null
+  }
   await persistSession(session)
 }
 
@@ -1399,7 +1511,7 @@ export async function rollbackSessionMessages(sessionId, rollbackMessageIndex) {
  * Send a user message to the agent and start the agent loop.
  * Returns immediately; events are streamed via the event bus.
  */
-export async function runPrompt(sessionId, message, selectedCapabilities = []) {
+export async function runPrompt(sessionId, message, selectedCapabilities = [], promptCommand = null) {
   let session = agentSessions.get(sessionId)
   if (!session) {
     session = await restoreAgent(sessionId)
@@ -1418,7 +1530,7 @@ export async function runPrompt(sessionId, message, selectedCapabilities = []) {
   const initialUserMessage = typeof message === 'string'
     ? { role: 'user', content: message, timestamp: new Date().toISOString() }
     : message
-  const commandState = await resolveCommandState(session, initialUserMessage)
+  const commandState = await resolveCommandState(session, initialUserMessage, promptCommand)
   const userMessage = commandState.userMessage ?? initialUserMessage
 
   if (commandState.textResponse) {
@@ -1516,14 +1628,27 @@ export async function continueSession(sessionId) {
     throw Object.assign(new Error('Cannot continue: no user message found.'), { statusCode: 400 })
   }
 
-  const trimmedMessages = messages.slice(0, lastUserIndex + 1)
+  const lastUserMessage = messages[lastUserIndex]
+  const commandState = await resolveCommandState(session, lastUserMessage)
+  const continuedUserMessage = commandState.userMessage ?? lastUserMessage
+  const trimmedMessages = messages.slice(0, lastUserIndex).concat(continuedUserMessage)
   updateSessionMessages(session, trimmedMessages)
   resetSessionCompaction(session)
 
   resetIdleTimer(session)
+  session.activeCommandName = commandState.commandName ?? null
+  session.activeCommandPermissions = commandState.permissions ?? null
+  session.activeCommandPrompt = commandState.commandPrompt ?? null
+  session.activeCapabilityPrompt = null
+
   session.agent.continue().catch((err) => {
     logger.error(`Agent continue error for session ${sessionId}:`, err, { sessionId })
     emitSessionEvent(session, { type: 'error', error: err.message || 'Unknown error' })
+  }).finally(() => {
+    session.activeCommandName = null
+    session.activeCommandPermissions = null
+    session.activeCommandPrompt = null
+    session.activeCapabilityPrompt = null
   })
 
   return { sessionId, status: 'running' }
@@ -1562,6 +1687,7 @@ export async function abortRun(sessionId) {
     )
     const event = {
       type: 'agent_end',
+      status: 'aborted',
       messages: session.agent.state.messages,
     }
     emitSessionEvent(session, event)
@@ -1631,6 +1757,7 @@ export function getSessionState(sessionId) {
     title: session.title,
     createdAt: session.createdAt,
     lastModified: session.lastModified,
+    stateVersion: session.stateVersion || 0,
     status: session.status,
     startedAt: session.startedAt,
     finishedAt: session.finishedAt,
@@ -1643,6 +1770,33 @@ export function getSessionState(sessionId) {
   }
 }
 
+/**
+ * Get a lightweight status snapshot for SSE-first state recovery.
+ */
+export function getSessionStatus(sessionId) {
+  const session = agentSessions.get(sessionId)
+  if (!session) return null
+
+  const messages = session.agent.state.messages || []
+  const lastMessage = messages[messages.length - 1]
+  return {
+    sessionId: session.sessionId,
+    scope: session.scope,
+    projectId: session.projectId,
+    title: session.title,
+    createdAt: session.createdAt,
+    lastModified: session.lastModified,
+    stateVersion: session.stateVersion || 0,
+    status: session.status,
+    startedAt: session.startedAt,
+    finishedAt: session.finishedAt,
+    isStreaming: session.agent.state.isStreaming,
+    errorMessage: session.agent.state.errorMessage,
+    messageCount: messages.length,
+    lastMessageTimestamp: lastMessage?.timestamp ?? null,
+  }
+}
+
 /**
  * Try to claim the SSE slot for a session. Returns true if acquired, false if
  * another tab already holds the SSE connection for this session.
@@ -1689,6 +1843,10 @@ export async function destroyAgent(sessionId) {
   logger.info(`Destroying session ${sessionId} (status: ${session.status})`, { sessionId, status: session.status })
 
   if (session.idleTimer) clearTimeout(session.idleTimer)
+  if (session.persistTimer) {
+    clearTimeout(session.persistTimer)
+    session.persistTimer = null
+  }
   session.toolTimings?.clear()
 
   try {

package/server/approval-store.mjs

@@ -24,6 +24,14 @@ export const commandRestrictedTools = new Set([
   'run_subagent',
 ])
 
+export const planAllowedTools = new Set([
+  'read_file',
+  'grep_files',
+  'activate_skill',
+  'read_skill_resource',
+  'run_subagent',
+])
+
 export const safeReadTools = new Set([
   'read_file',
   'grep_files',
@@ -45,7 +53,11 @@ export const pendingAutoCompactApprovals = new Map()
 
 export function commandToolPermissionError(session, toolName) {
   const permissions = session?.activeCommandPermissions
-  if (!permissions || !commandRestrictedTools.has(toolName)) return null
+  if (!permissions) return null
+  if (session?.activeCommandName === 'plan' && !planAllowedTools.has(toolName)) {
+    return `Command /plan is read-only and cannot use ${toolName}.`
+  }
+  if (!commandRestrictedTools.has(toolName)) return null
   if (toolName === 'run_command' && permissions.allowCommands === false) {
     return `Command /${session.activeCommandName} does not allow running shell commands.`
   }

package/server/auto-compaction.mjs

@@ -1,5 +1,6 @@
 import { readStore } from './storage.mjs'
 import { compactConversation, saveCompactBackup } from './conversation-compaction.mjs'
+import { estimateContextUsage, shouldCompactContextByPercent } from './context-usage.mjs'
 
 export const AUTO_COMPACT_SETTINGS_KEY = 'auto-compact-settings'
 
@@ -44,14 +45,6 @@ function safeJson(value) {
   }
 }
 
-function estimateTextTokens(value) {
-  const text = String(value || '')
-  if (!text) return 0
-  const cjkChars = text.match(/[\u3400-\u9fff\uf900-\ufaff]/g)?.length ?? 0
-  const otherChars = Math.max(0, text.length - cjkChars)
-  return Math.ceil(cjkChars + otherChars / 3.5)
-}
-
 function contentToText(content) {
   if (typeof content === 'string') return content
   if (!Array.isArray(content)) return ''
@@ -65,19 +58,6 @@ function contentToText(content) {
   }).filter(Boolean).join('\n')
 }
 
-function estimateMessageTokens(message) {
-  if (!message || typeof message !== 'object') return 0
-  const parts = [message.role || '', contentToText(message.content)]
-  if (message.toolName) parts.push(message.toolName)
-  if (message.toolCallId) parts.push(message.toolCallId)
-  if (message.attachments !== undefined) parts.push(safeJson(message.attachments))
-  return estimateTextTokens(parts.join('\n'))
-}
-
-function estimateMessagesTokens(messages) {
-  return (Array.isArray(messages) ? messages : []).reduce((total, message) => total + estimateMessageTokens(message), 0)
-}
-
 function estimateMessagesChars(messages) {
   return (Array.isArray(messages) ? messages : []).reduce((total, message) => {
     if (!message || typeof message !== 'object') return total
@@ -85,50 +65,6 @@ function estimateMessagesChars(messages) {
   }, 0)
 }
 
-function messageTimestampMs(message) {
-  const timestamp = message?.timestamp
-  if (typeof timestamp === 'number') return timestamp
-  if (typeof timestamp === 'string') {
-    const parsed = Date.parse(timestamp)
-    return Number.isNaN(parsed) ? 0 : parsed
-  }
-  return 0
-}
-
-function latestCompactTimestampMs(session) {
-  return messageTimestampMs(session?.contextCompaction?.summaryMessage)
-}
-
-function latestKnownInputTokens(messages, sinceTimestamp = 0) {
-  let latestTimestamp = -1
-  let latestInput = 0
-  for (const message of Array.isArray(messages) ? messages : []) {
-    if (message?.role !== 'assistant' || !message.usage) continue
-    const timestamp = messageTimestampMs(message)
-    if (sinceTimestamp > 0 && timestamp <= sinceTimestamp) continue
-    if (timestamp < latestTimestamp) continue
-    const input = Math.max(0, Number(message.usage.input ?? message.usage.totalTokens) || 0)
-    if (input <= 0) continue
-    latestTimestamp = timestamp
-    latestInput = input
-  }
-  return latestInput
-}
-
-export function estimateContextUsage({ systemPrompt, messages, tools, model, knownInputTokens = 0 }) {
-  const contextWindow = Number(model?.contextWindow) || 0
-  const reservedOutputTokens = Math.max(0, Number(model?.maxTokens) || 4096)
-  const estimatedInputTokens =
-    estimateTextTokens(systemPrompt) +
-    estimateMessagesTokens(messages) +
-    estimateTextTokens(safeJson(tools))
-  const knownInput = Math.max(0, Number(knownInputTokens) || 0)
-  const inputTokens = Math.max(estimatedInputTokens, knownInput)
-  const totalTokens = inputTokens + reservedOutputTokens
-  const percent = contextWindow > 0 ? Math.round((totalTokens / contextWindow) * 1000) / 10 : 0
-  return { inputTokens, estimatedInputTokens, knownInputTokens: knownInput, reservedOutputTokens, totalTokens, contextWindow, percent }
-}
-
 function isUserMessage(message) {
   return message?.role === 'user' || message?.role === 'user-with-attachments'
 }
@@ -220,17 +156,74 @@ export function estimateSessionContextUsage(session, messages = session?.agent?.
   const sourceMessages = Array.isArray(messages) ? messages : []
   const contextWindow = Number(session.model?.contextWindow) || 0
   if (sourceMessages.length === 0) {
-    return { inputTokens: 0, estimatedInputTokens: 0, knownInputTokens: 0, reservedOutputTokens: 0, totalTokens: 0, contextWindow, percent: 0 }
+    return {
+      inputTokens: 0,
+      estimatedInputTokens: 0,
+      knownInputTokens: 0,
+      inputTokenSource: 'estimated',
+      reservedOutputTokens: 0,
+      totalTokens: 0,
+      contextWindow,
+      percent: 0,
+      isCompacted: false,
+      originalMessageCount: 0,
+      effectiveMessageCount: 0,
+      breakdown: {
+        systemPromptTokens: 0,
+        messagesTokens: 0,
+        toolsTokens: 0,
+        reservedOutputTokens: 0,
+      },
+    }
   }
+
+  // Cache by input identity. Context usage delegates message token estimation
+  // to pi-agent-core and JSON-stringifies the full tools array, but its
+  // inputs (messages, model, systemPrompt, tools, contextCompaction) are stable
+  // within a run and only change on discrete events (message_end, tool result,
+  // compaction). Reference equality makes the cache check essentially free, so
+  // the repeated calls from emitSessionEvent() on message_end/agent_end/etc.
+  // only recompute when something actually changed.
+  const lastMessage = sourceMessages[sourceMessages.length - 1]
+  const cacheKey = {
+    messages,
+    messagesLength: sourceMessages.length,
+    lastMessage,
+    model: session.model,
+    systemPrompt: session.agent.state.systemPrompt,
+    tools: session.agent.state.tools,
+    contextCompaction: session.contextCompaction,
+  }
+  const cached = session._contextUsageCache
+  if (
+    cached &&
+    cached.key.messages === cacheKey.messages &&
+    cached.key.messagesLength === cacheKey.messagesLength &&
+    cached.key.lastMessage === cacheKey.lastMessage &&
+    cached.key.model === cacheKey.model &&
+    cached.key.systemPrompt === cacheKey.systemPrompt &&
+    cached.key.tools === cacheKey.tools &&
+    cached.key.contextCompaction === cacheKey.contextCompaction
+  ) {
+    return cached.value
+  }
+
   const loopMessages = buildAutoCompactLoopMessages(session, sourceMessages)
-  const knownInputTokens = latestKnownInputTokens(sourceMessages, latestCompactTimestampMs(session))
-  return estimateContextUsage({
+  const value = estimateContextUsage({
     systemPrompt: session.agent.state.systemPrompt,
     messages: loopMessages,
     tools: session.agent.state.tools,
     model: session.model,
-    knownInputTokens,
   })
+  value.isCompacted = loopMessages !== sourceMessages
+  value.originalMessageCount = sourceMessages.length
+  value.effectiveMessageCount = loopMessages.length
+  if (session.contextCompaction?.summaryMessage) {
+    value.compactedUpToIndex = Math.min(sourceMessages.length, Math.max(0, Number(session.contextCompaction.compactedUpToIndex) || 0))
+  }
+
+  session._contextUsageCache = { key: cacheKey, value }
+  return value
 }
 
 export async function maybeAutoCompactSession({ session, messages, signal, emitSessionEvent, persistSession, logger, confirmAutoCompact }) {
@@ -240,16 +233,14 @@ export async function maybeAutoCompactSession({ session, messages, signal, emitS
   if (signal?.aborted) return { compacted: false, reason: 'aborted' }
 
   const loopMessages = buildAutoCompactLoopMessages(session, messages)
-  const knownInputTokens = latestKnownInputTokens(messages, latestCompactTimestampMs(session))
   const usage = estimateContextUsage({
     systemPrompt: session.agent.state.systemPrompt,
     messages: loopMessages,
     tools: session.agent.state.tools,
     model: session.model,
-    knownInputTokens,
   })
   if (!usage.contextWindow) return { compacted: false, usage, reason: 'missing_context_window' }
-  if (usage.percent < settings.thresholdPercent) return { compacted: false, usage, reason: 'below_threshold' }
+  if (!shouldCompactContextByPercent(usage, settings.thresholdPercent)) return { compacted: false, usage, reason: 'below_threshold' }
   if (shouldSuppressAfterRejection(session, messages, usage)) return { compacted: false, usage, reason: 'user_rejected_recently' }
 
   const now = Date.now()