@shawnstack/quickforge 1.4.0 → 1.5.0

package/server/agent-profile-files.mjs

@@ -0,0 +1,179 @@
+import { existsSync, promises as fs } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { dataDir } from './storage.mjs'
+import { firstOptionalBoolean, firstString, parseFrontmatter, splitDelimitedList } from './frontmatter.mjs'
+
+const DEFAULT_MAX_RUNTIME_MS = 30 * 60 * 1000
+const DEFAULT_MAX_TOOL_CALLS = 300
+const nameRegex = /^[a-z][a-z0-9_-]{1,39}$/
+const allowedToolNames = new Set(['read_file', 'grep_files', 'write_file', 'edit_file', 'run_command'])
+
+const toolAliases = new Map([
+  ['Read', 'read_file'],
+  ['Grep', 'grep_files'],
+  ['Bash', 'run_command'],
+  ['Write', 'write_file'],
+  ['Edit', 'edit_file'],
+])
+
+const claudeUserAgentsDir = path.join(os.homedir(), '.claude', 'agents')
+const userAgentsDir = path.join(dataDir, 'agents')
+
+function normalizeString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined
+}
+
+function normalizeName(value) {
+  const name = normalizeString(value)?.toLowerCase()
+  return name && nameRegex.test(name) ? name : null
+}
+
+function normalizeRuntime(value) {
+  if (value === undefined || value === null || value === '') return DEFAULT_MAX_RUNTIME_MS
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_MAX_RUNTIME_MS
+  return Math.min(Math.max(Math.round(parsed), 1000), DEFAULT_MAX_RUNTIME_MS)
+}
+
+function normalizeToolCalls(value) {
+  if (value === undefined || value === null || value === '') return DEFAULT_MAX_TOOL_CALLS
+  const parsed = Number(value)
+  if (!Number.isInteger(parsed) || parsed <= 0) return DEFAULT_MAX_TOOL_CALLS
+  return Math.min(parsed, DEFAULT_MAX_TOOL_CALLS)
+}
+
+function normalizeTools(value) {
+  const tools = []
+  const seen = new Set()
+  for (const item of splitDelimitedList(value)) {
+    const mapped = toolAliases.get(item) || item
+    if (!allowedToolNames.has(mapped) || seen.has(mapped)) continue
+    seen.add(mapped)
+    tools.push(mapped)
+  }
+  return tools.length ? tools : ['read_file', 'grep_files']
+}
+
+function hasMutationTool(allowedTools) {
+  return allowedTools.some((toolName) => toolName === 'write_file' || toolName === 'edit_file')
+}
+
+export function agentProfileFromMarkdown(file, text, options = {}) {
+  const parsed = parseFrontmatter(text)
+  if (!parsed.body) return null
+
+  const metadata = parsed.metadata || {}
+  const name = normalizeName(metadata.name) || normalizeName(path.basename(file, '.md'))
+  if (!name) return null
+  if (options.reservedNames?.has(name)) return null
+
+  const allowedTools = normalizeTools(
+    metadata.tools ?? metadata['allowed-tools'] ?? metadata.allowedTools,
+  )
+  const label = firstString(metadata.label, metadata.displayName, metadata.title) || name
+  const enabledAsSubagent = firstOptionalBoolean(
+    metadata['enabled-as-subagent'],
+    metadata.enabled_as_subagent,
+    metadata.enabledAsSubagent,
+  )
+
+  return {
+    id: `${options.idPrefix || 'file'}:${name}`,
+    name,
+    label: label.slice(0, 80),
+    description: String(firstString(metadata.description) || '').slice(0, 500),
+    systemPrompt: parsed.body,
+    allowedTools,
+    maxRuntimeMs: normalizeRuntime(metadata['max-runtime-ms'] ?? metadata.max_runtime_ms ?? metadata.maxRuntimeMs),
+    maxToolCalls: normalizeToolCalls(metadata['max-tool-calls'] ?? metadata.max_tool_calls ?? metadata.maxToolCalls),
+    enabledAsSubagent: enabledAsSubagent === undefined ? true : enabledAsSubagent,
+    builtin: false,
+    source: options.source || 'file',
+    readonly: true,
+    filePath: file,
+    relativePath: options.relativePath || path.basename(file),
+    allowFileMutations: hasMutationTool(allowedTools),
+    createdAt: 'file',
+    updatedAt: 'file',
+  }
+}
+
+async function listAgentFilesFromDirectory(dir, options = {}) {
+  if (!dir || !existsSync(dir)) return []
+  let entries
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true })
+  } catch (error) {
+    if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR' || error?.code === 'EACCES' || error?.code === 'EPERM') return []
+    throw error
+  }
+
+  const profiles = []
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.toLowerCase().endsWith('.md')) continue
+    const file = path.join(dir, entry.name)
+    try {
+      const relativePath = options.relativeRoot
+        ? `${options.relativeRoot}/${entry.name}`.replace(/\\/g, '/')
+        : entry.name
+      const profile = agentProfileFromMarkdown(file, await fs.readFile(file, 'utf8'), {
+        ...options,
+        relativePath,
+      })
+      if (profile) profiles.push(profile)
+    } catch (error) {
+      console.warn(`Failed to load agent profile ${file}:`, error.message || error)
+    }
+  }
+  return profiles
+}
+
+function projectClaudeAgentsDir(workspaceRoot) {
+  return workspaceRoot ? path.join(path.resolve(workspaceRoot), '.claude', 'agents') : ''
+}
+
+function projectQuickForgeAgentsDir(workspaceRoot) {
+  return workspaceRoot ? path.join(path.resolve(workspaceRoot), '.quickforge', 'agents') : ''
+}
+
+export async function loadUserAgentProfiles(options = {}) {
+  const byName = new Map()
+  const sources = [
+    { dir: claudeUserAgentsDir, source: 'user-claude', relativeRoot: '~/.claude/agents', idPrefix: 'user-claude' },
+    { dir: userAgentsDir, source: 'user', relativeRoot: '~/.quickforge/agents', idPrefix: 'user' },
+  ]
+  for (const source of sources) {
+    for (const profile of await listAgentFilesFromDirectory(source.dir, { ...options, ...source })) {
+      byName.set(profile.name, profile)
+    }
+  }
+  return [...byName.values()]
+}
+
+export async function loadProjectAgentProfiles(workspaceRoot, options = {}) {
+  if (!workspaceRoot) return []
+  const byName = new Map()
+  const sources = [
+    { dir: projectClaudeAgentsDir(workspaceRoot), source: 'project-claude', relativeRoot: '.claude/agents', idPrefix: 'project-claude' },
+    { dir: projectQuickForgeAgentsDir(workspaceRoot), source: 'project', relativeRoot: '.quickforge/agents', idPrefix: 'project' },
+  ]
+  for (const source of sources) {
+    for (const profile of await listAgentFilesFromDirectory(source.dir, { ...options, ...source })) {
+      byName.set(profile.name, profile)
+    }
+  }
+  return [...byName.values()]
+}
+
+export async function loadFileAgentProfiles(workspaceRoot, options = {}) {
+  const byName = new Map()
+  for (const profile of await loadUserAgentProfiles(options)) byName.set(profile.name, profile)
+  for (const profile of await loadProjectAgentProfiles(workspaceRoot, options)) byName.set(profile.name, profile)
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name))
+}
+
+export const agentProfileSearchPaths = {
+  global: ['~/.claude/agents', '~/.quickforge/agents'],
+  project: ['<project>/.claude/agents', '<project>/.quickforge/agents'],
+}

package/server/agent-profiles.mjs

@@ -2,6 +2,8 @@ import { randomUUID } from 'node:crypto'
 import { readStore, atomicUpdate } from './storage.mjs'
 import { subagentDefinitions } from './subagents.mjs'
 import { workspaceTools } from './tools/definitions.mjs'
+import { defaultGlobalWorkspaceContext, projectContextFromId } from './project-config.mjs'
+import { loadFileAgentProfiles } from './agent-profile-files.mjs'
 
 const STORE = 'custom-agents'
 const RESERVED_NAMES = new Set(subagentDefinitions.map((definition) => definition.name))
@@ -56,6 +58,9 @@ function builtinProfileFromSubagent(definition) {
     maxToolCalls: definition.maxToolCalls || DEFAULT_MAX_TOOL_CALLS,
     enabledAsSubagent: true,
     builtin: true,
+    source: 'builtin',
+    readonly: true,
+    allowFileMutations: definition.allowFileMutations === true,
     createdAt: 'builtin',
     updatedAt: 'builtin',
   }
@@ -92,6 +97,9 @@ function normalizeProfileInput(input, existing = null, { creating = false } = {}
     maxToolCalls: normalizeOptionalPositiveInteger(input?.maxToolCalls ?? existing?.maxToolCalls, DEFAULT_MAX_TOOL_CALLS, 300),
     enabledAsSubagent: input?.enabledAsSubagent === undefined ? Boolean(existing?.enabledAsSubagent ?? true) : input.enabledAsSubagent === true,
     builtin: false,
+    source: 'store',
+    readonly: false,
+    allowFileMutations: allowedTools.some((toolName) => toolName === 'write_file' || toolName === 'edit_file'),
     createdAt: existing?.createdAt || now,
     updatedAt: now,
   }
@@ -102,20 +110,61 @@ async function readCustomAgentMap() {
   return data && typeof data === 'object' ? data : {}
 }
 
+async function resolveWorkspaceRoot(options = {}) {
+  if (options.workspaceRoot) return options.workspaceRoot
+  if (options.projectId) {
+    try {
+      return (await projectContextFromId(options.projectId))?.workspaceRoot || null
+    } catch {
+      return null
+    }
+  }
+  return defaultGlobalWorkspaceContext()?.workspaceRoot || null
+}
+
+function mergeProfiles({ builtin = [], file = [], custom = [] }) {
+  const reservedNames = new Set(builtin.map((profile) => profile.name))
+  const byName = new Map()
+
+  for (const profile of builtin) {
+    byName.set(profile.name, profile)
+  }
+  for (const profile of file) {
+    if (!profile?.name || reservedNames.has(profile.name)) continue
+    byName.set(profile.name, profile)
+  }
+  for (const profile of custom) {
+    if (!profile?.id) continue
+    if (!reservedNames.has(profile.name) && !byName.has(profile.name)) byName.set(profile.name, profile)
+  }
+
+  return [...byName.values()].sort((a, b) => {
+    if (a.builtin && !b.builtin) return -1
+    if (!a.builtin && b.builtin) return 1
+    return a.name.localeCompare(b.name)
+  })
+}
+
 export async function listAgentProfiles(options = {}) {
   const custom = Object.values(await readCustomAgentMap())
-  const profiles = [...listBuiltinAgentProfiles(), ...custom]
+  const workspaceRoot = await resolveWorkspaceRoot(options)
+  const file = await loadFileAgentProfiles(workspaceRoot, { reservedNames: RESERVED_NAMES })
+  const profiles = mergeProfiles({ builtin: listBuiltinAgentProfiles(), file, custom })
   return options.includeDisabled ? profiles : profiles.filter((profile) => profile.enabledAsSubagent || profile.builtin || profile.enabledAsSubagent === false)
 }
 
-export async function listSubagentProfiles() {
-  return (await listAgentProfiles({ includeDisabled: true })).filter((profile) => profile.enabledAsSubagent)
+export async function listSubagentProfiles(options = {}) {
+  return (await listAgentProfiles({ ...options, includeDisabled: true })).filter((profile) => profile.enabledAsSubagent)
 }
 
-export async function getAgentProfile(idOrName) {
+export async function getAgentProfile(idOrName, options = {}) {
   const key = String(idOrName || '').trim().toLowerCase()
   if (!key) return null
-  return (await listAgentProfiles({ includeDisabled: true })).find((profile) => profile.id === key || profile.name === key) || null
+  const profiles = await listAgentProfiles({ ...options, includeDisabled: true })
+  const byName = profiles.find((profile) => profile.name === key)
+  if (byName) return byName
+  const custom = Object.values(await readCustomAgentMap())
+  return custom.find((profile) => profile?.id === key) || profiles.find((profile) => profile.id === key) || null
 }
 
 export async function createCustomAgentProfile(input) {
@@ -167,7 +216,12 @@ export function agentProfileSnapshot(profile) {
     allowedTools: [...profile.allowedTools],
     maxRuntimeMs: profile.maxRuntimeMs,
     maxToolCalls: profile.maxToolCalls,
+    enabledAsSubagent: profile.enabledAsSubagent === true,
     builtin: profile.builtin === true,
+    source: profile.source || (profile.builtin ? 'builtin' : 'store'),
+    readonly: profile.readonly === true || profile.builtin === true,
+    filePath: profile.filePath,
+    relativePath: profile.relativePath,
   }
 }
 

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'
 }
@@ -215,16 +151,104 @@ export function buildAutoCompactLoopMessages(session, messages) {
   return [summaryMessage, ...source.slice(compactedUpToIndex)]
 }
 
+export async function compactSessionInPlace({
+  session,
+  messages,
+  keepRecentTurns = DEFAULT_AUTO_COMPACT_SETTINGS.keepRecentTurns,
+  minSourceChars = DEFAULT_AUTO_COMPACT_SETTINGS.minSourceChars,
+  usage,
+  thresholdPercent,
+  emitSessionEvent,
+  persistSession,
+  reason = 'manual_compact',
+  summaryIntro = 'The previous conversation has been compacted. Treat the following summary as the authoritative replacement for earlier history. If information is missing, ask for clarification instead of guessing.',
+  onBeforePersist,
+}) {
+  const source = Array.isArray(messages) ? messages : []
+  const normalizedKeepRecentTurns = clampNumber(keepRecentTurns, DEFAULT_AUTO_COMPACT_SETTINGS.keepRecentTurns, 1, 20)
+  const normalizedMinSourceChars = clampNumber(minSourceChars, DEFAULT_AUTO_COMPACT_SETTINGS.minSourceChars, 0, 200000)
+  const tailStart = tailStartForRecentTurns(source, normalizedKeepRecentTurns)
+  const sourceMessages = buildCompactionSourceMessages(session, source, tailStart)
+  if (sourceMessages.length < 2 || estimateMessagesChars(sourceMessages) < normalizedMinSourceChars) {
+    return { compacted: false, usage, reason: 'not_enough_history' }
+  }
+
+  const result = await compactConversation({
+    messages: sourceMessages,
+    model: session.model,
+    thinkingLevel: session.thinkingLevel,
+    getApiKey: session.getApiKey,
+    keepTurns: 0,
+  })
+
+  if (result.skipped) return { compacted: false, usage, reason: result.reason || 'skipped' }
+
+  await saveCompactBackup(session.sessionId, sourceMessages)
+  const summaryMessage = userTextMessage([
+    summaryIntro,
+    '',
+    '<compact_summary>',
+    result.summary,
+    '</compact_summary>',
+  ].join('\n'))
+  session.contextCompaction = {
+    summaryMessage,
+    compactedUpToIndex: tailStart,
+    compactedAt: new Date().toISOString(),
+    keepRecentTurns: normalizedKeepRecentTurns,
+    sourceMessageCount: source.length,
+    usageBefore: usage,
+    thresholdPercent,
+  }
+  onBeforePersist?.({ result, sourceMessages, tailStart, summaryMessage })
+  await persistSession?.(session)
+  const contextUsage = estimateSessionContextUsage(session, source)
+  emitSessionEvent?.(session, {
+    type: 'auto_compact_completed',
+    reason,
+    usage,
+    thresholdPercent,
+    contextCompaction: session.contextCompaction,
+    contextUsage,
+  })
+  emitSessionEvent?.(session, {
+    type: 'messages_replaced',
+    reason,
+    messages: source,
+    contextCompaction: session.contextCompaction,
+    contextUsage,
+  })
+  return { compacted: true, usage, result, sourceMessages, tailStart }
+}
+
 export function estimateSessionContextUsage(session, messages = session?.agent?.state?.messages ?? []) {
   if (!session?.agent?.state) return null
   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. estimateContextUsage() scans every message with a
-  // tokenizer regex (O(n)) and JSON-stringifies the full tools array, but its
+  // 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
@@ -255,14 +279,18 @@ export function estimateSessionContextUsage(session, messages = session?.agent?.
   }
 
   const loopMessages = buildAutoCompactLoopMessages(session, sourceMessages)
-  const knownInputTokens = latestKnownInputTokens(sourceMessages, latestCompactTimestampMs(session))
   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
@@ -275,16 +303,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()
@@ -318,50 +344,23 @@ export async function maybeAutoCompactSession({ session, messages, signal, emitS
 
   session.autoCompacting = true
   try {
-    const result = await compactConversation({
-      messages: sourceMessages,
-      model: session.model,
-      thinkingLevel: session.thinkingLevel,
-      getApiKey: session.getApiKey,
-      keepTurns: 0,
-    })
-
-    if (result.skipped) return { compacted: false, usage, reason: result.reason || 'skipped' }
-
-    await saveCompactBackup(session.sessionId, sourceMessages)
-    const summaryMessage = userTextMessage([
-      'The previous conversation has been automatically compacted. Treat the following summary as the authoritative replacement for earlier history. If information is missing, ask for clarification instead of guessing.',
-      '',
-      '<compact_summary>',
-      result.summary,
-      '</compact_summary>',
-    ].join('\n'))
-    session.contextCompaction = {
-      summaryMessage,
-      compactedUpToIndex: tailStart,
-      compactedAt: new Date().toISOString(),
+    const result = await compactSessionInPlace({
+      session,
+      messages,
       keepRecentTurns: settings.keepRecentTurns,
-      sourceMessageCount: messages.length,
-      usageBefore: usage,
-      thresholdPercent: settings.thresholdPercent,
-    }
-    clearAutoCompactRejected(session)
-    session.lastAutoCompactAt = now
-    await persistSession(session)
-    emitSessionEvent(session, {
-      type: 'auto_compact_completed',
+      minSourceChars: settings.minSourceChars,
       usage,
       thresholdPercent: settings.thresholdPercent,
-      contextCompaction: session.contextCompaction,
-      contextUsage: estimateSessionContextUsage(session, messages),
-    })
-    emitSessionEvent(session, {
-      type: 'messages_replaced',
+      emitSessionEvent,
+      persistSession,
       reason: 'auto_compact',
-      messages,
-      contextCompaction: session.contextCompaction,
-      contextUsage: estimateSessionContextUsage(session, messages),
+      summaryIntro: 'The previous conversation has been automatically compacted. Treat the following summary as the authoritative replacement for earlier history. If information is missing, ask for clarification instead of guessing.',
+      onBeforePersist: () => {
+        clearAutoCompactRejected(session)
+        session.lastAutoCompactAt = now
+      },
     })
+    if (!result.compacted) return result
     return { compacted: true, usage }
   } catch (error) {
     logger?.warn?.(`Auto compact failed for session ${session.sessionId}:`, error?.message || error, { sessionId: session.sessionId })