@shawnstack/quickforge 1.4.0 → 1.5.0

package/server/agent-manager.mjs

@@ -11,7 +11,7 @@ import {
   formatSubagentTask,
 } from './subagents.mjs'
 import { agentProfileSnapshot, getAgentProfile } from './agent-profiles.mjs'
-import { projectContextFromId, readProjectConfig } from './project-config.mjs'
+import { projectContextFromId, defaultGlobalWorkspaceContext, readProjectConfig } from './project-config.mjs'
 import { readStore, atomicUpdate, atomicSessionMetadataUpdate, readSessionValue, writeSessionValue, deleteSessionValue } from './storage.mjs'
 import { logger } from './utils/logger.mjs'
 import { buildSystemPrompt, generateAiTitle, generateTitle } from './session-utils.mjs'
@@ -23,8 +23,11 @@ import {
 } from './conversation-compaction.mjs'
 import {
   buildAutoCompactLoopMessages,
+  compactSessionInPlace,
+  DEFAULT_AUTO_COMPACT_SETTINGS,
   estimateSessionContextUsage,
   maybeAutoCompactSession,
+  readAutoCompactSettings,
 } from './auto-compaction.mjs'
 import {
   handleInternalCommand,
@@ -35,7 +38,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,
@@ -93,7 +95,7 @@ async function createServerTools(projectId, projectContext, skillsContext, inclu
     .filter(isAllowed)
     .map((definition) => wrapToolDefinition(definition, toolContext, toolPermissions))
 
-  if (includeWorkspaceTools && projectId && projectContext) {
+  if (includeWorkspaceTools && projectContext) {
     const definitions = workspaceTools.filter((definition) => includeSubagentTool || definition.name !== 'run_subagent')
     tools.push(...definitions
       .filter(isAllowed)
@@ -118,7 +120,7 @@ async function rebuildSessionTools(session) {
     session.projectId,
     session.projectContext,
     sessionSkillsContext(session),
-    !!(session.projectId && session.projectContext),
+    !!session.projectContext,
     createCommandToolPermissions(session),
     { parentSessionId: session.sessionId },
   )
@@ -130,7 +132,26 @@ async function rebuildSessionTools(session) {
 
 const agentSessions = new Map()
 
-/** @typedef {{ agent: Agent, projectContext: object|null, projectId: string|null, yoloMode: boolean, model: object, thinkingLevel: string, scope: string, title: string, createdAt: string, status: string, startedAt: string|null, finishedAt: string|null, listeners: Set<function>, idleTimer: NodeJS.Timeout|null, eventBus: EventEmitter }} AgentSession */
+const AGENT_ACCESS_MODE_DEFAULT = 'default'
+const AGENT_ACCESS_MODE_FULL_ACCESS = 'full-access'
+
+function normalizeAccessMode(value, fallback = AGENT_ACCESS_MODE_DEFAULT) {
+  if (value === AGENT_ACCESS_MODE_DEFAULT || value === AGENT_ACCESS_MODE_FULL_ACCESS) return value
+  if (value === true || value === 'true') return AGENT_ACCESS_MODE_FULL_ACCESS
+  if (value === false || value === 'false') return AGENT_ACCESS_MODE_DEFAULT
+  if (fallback !== value) return normalizeAccessMode(fallback, AGENT_ACCESS_MODE_DEFAULT)
+  return AGENT_ACCESS_MODE_DEFAULT
+}
+
+function yoloModeFromAccessMode(accessMode) {
+  return normalizeAccessMode(accessMode) === AGENT_ACCESS_MODE_FULL_ACCESS
+}
+
+function hasFullAccess(session) {
+  return normalizeAccessMode(session?.accessMode, session?.yoloMode) === AGENT_ACCESS_MODE_FULL_ACCESS
+}
+
+/** @typedef {{ agent: Agent, projectContext: object|null, projectId: string|null, accessMode: string, yoloMode: boolean, model: object, thinkingLevel: string, scope: string, title: string, createdAt: string, status: string, startedAt: string|null, finishedAt: string|null, listeners: Set<function>, idleTimer: NodeJS.Timeout|null, eventBus: EventEmitter }} AgentSession */
 
 const IDLE_TIMEOUT_MS = 30 * 60 * 1000 // 30 minutes
 const SUBAGENT_DEFAULT_TIMEOUT_MS = 30 * 60 * 1000
@@ -371,12 +392,12 @@ function finishManualSessionRun(session, status, errorMessage) {
   session.agent.state.errorMessage = errorMessage
 }
 
-async function compactSession(session, initialUserMessage, compactOptions) {
+async function summarySession(session, initialUserMessage, summaryOptions) {
   if (session.agent.state.isStreaming) {
     session.agent.state.messages = [
       ...session.agent.state.messages,
       initialUserMessage,
-      assistantTextMessage('Cannot compact while a generation is still running. Stop it or wait until it finishes, then run /compact again.', session.model),
+      assistantTextMessage('Cannot summarize while a generation is still running. Stop it or wait until it finishes, then run /summary again.', session.model),
     ]
     await persistSession(session)
     const messages = session.agent.state.messages
@@ -400,13 +421,13 @@ async function compactSession(session, initialUserMessage, compactOptions) {
 
   try {
     const originalMessages = session.agent.state.messages.slice()
-    const options = parseCompactArgs(compactOptions?.args || '')
+    const options = parseCompactArgs(summaryOptions?.args || '')
 
     if (options.unsupported?.length) {
       session.agent.state.messages = [
         ...originalMessages,
         initialUserMessage,
-        assistantTextMessage(`Unsupported /compact option(s): ${options.unsupported.join(', ')}\n\nSupported usage: /compact or /compact keep=0`, session.model),
+        assistantTextMessage(`Unsupported /summary option(s): ${options.unsupported.join(', ')}\n\nSupported usage: /summary or /summary keep=0`, session.model),
       ]
       finishManualSessionRun(session, 'idle')
       await persistSession(session)
@@ -428,7 +449,7 @@ async function compactSession(session, initialUserMessage, compactOptions) {
       session.agent.state.messages = [
         ...originalMessages,
         initialUserMessage,
-        assistantTextMessage('Not enough earlier history to compact. Continue chatting and run /compact again later.', session.model),
+        assistantTextMessage('Not enough earlier history to summarize. Continue chatting and run /summary again later.', session.model),
       ]
       finishManualSessionRun(session, 'idle')
       await persistSession(session)
@@ -464,6 +485,7 @@ async function compactSession(session, initialUserMessage, compactOptions) {
     const compactedSession = await createAgent(compactedSessionId, {
       scope: session.scope,
       projectId: session.projectId,
+      accessMode: session.accessMode,
       yoloMode: session.yoloMode,
       model: session.model,
       thinkingLevel: session.thinkingLevel,
@@ -513,6 +535,97 @@ async function compactSession(session, initialUserMessage, compactOptions) {
   }
 }
 
+async function compactSession(session, initialUserMessage, compactOptions) {
+  if (session.agent.state.isStreaming) {
+    session.agent.state.messages = [
+      ...session.agent.state.messages,
+      initialUserMessage,
+      assistantTextMessage('Cannot compact while a generation is still running. Stop it or wait until it finishes, then run /compact again.', session.model),
+    ]
+    await persistSession(session)
+    const messages = session.agent.state.messages
+    emitSessionEvent(session, { type: 'message_end', messages })
+    emitSessionEvent(session, { type: 'agent_end', messages })
+    return { sessionId: session.sessionId, status: session.status }
+  }
+
+  const args = String(compactOptions?.args || '').trim()
+  if (args) {
+    session.agent.state.messages = [
+      ...session.agent.state.messages,
+      initialUserMessage,
+      assistantTextMessage('Unsupported /compact option(s). Supported usage: /compact', session.model),
+    ]
+    session.status = 'idle'
+    session.finishedAt = new Date().toISOString()
+    await persistSession(session)
+    const messages = session.agent.state.messages
+    emitSessionEvent(session, { type: 'message_end', messages })
+    emitSessionEvent(session, { type: 'agent_end', messages })
+    return { sessionId: session.sessionId, status: session.status }
+  }
+
+  resetIdleTimer(session)
+  session.status = 'running'
+  session.startedAt = session.startedAt ?? new Date().toISOString()
+  session.finishedAt = null
+  session.agent.state.isStreaming = true
+  session.agent.state.errorMessage = undefined
+  emitSessionEvent(session, { type: 'agent_start' })
+
+  try {
+    const messages = session.agent.state.messages.slice()
+    const settings = await readAutoCompactSettings().catch(() => DEFAULT_AUTO_COMPACT_SETTINGS)
+    const usage = getSessionContextUsage(session)
+    const result = await compactSessionInPlace({
+      session,
+      messages,
+      keepRecentTurns: settings.keepRecentTurns,
+      minSourceChars: settings.minSourceChars,
+      usage,
+      thresholdPercent: settings.thresholdPercent,
+      emitSessionEvent,
+      persistSession,
+      reason: 'manual_compact',
+      onBeforePersist: () => {
+        finishManualSessionRun(session, 'idle')
+      },
+    })
+
+    if (!result.compacted) {
+      session.agent.state.messages = [
+        ...messages,
+        initialUserMessage,
+        assistantTextMessage('Not enough earlier history to compact. Continue chatting and run /compact again later.', session.model),
+      ]
+      finishManualSessionRun(session, 'idle')
+      await persistSession(session)
+      const nextMessages = session.agent.state.messages
+      emitSessionEvent(session, { type: 'message_end', messages: nextMessages })
+      emitSessionEvent(session, { type: 'agent_end', messages: nextMessages })
+      return { sessionId: session.sessionId, status: session.status }
+    }
+
+    const nextMessages = session.agent.state.messages
+    emitSessionEvent(session, { type: 'message_end', messages: nextMessages })
+    emitSessionEvent(session, { type: 'agent_end', messages: nextMessages })
+    return { sessionId: session.sessionId, status: session.status }
+  } catch (err) {
+    const errorMessage = err?.message || 'Conversation compaction failed'
+    session.agent.state.messages = [
+      ...session.agent.state.messages,
+      initialUserMessage,
+      assistantTextMessage(`Conversation compaction failed: ${errorMessage}`, session.model),
+    ]
+    finishManualSessionRun(session, 'error', errorMessage)
+    await persistSession(session)
+    const messages = session.agent.state.messages
+    emitSessionEvent(session, { type: 'error', error: errorMessage })
+    emitSessionEvent(session, { type: 'agent_end', messages, errorMessage })
+    return { sessionId: session.sessionId, status: session.status }
+  }
+}
+
 async function clearSession(session) {
   if (session.agent.state.isStreaming) {
     session.agent.state.messages = [
@@ -545,22 +658,68 @@ 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,
   )
   if (typeof internalResponse === 'string') return { textResponse: internalResponse }
   if (internalResponse?.clear) return { clear: internalResponse }
+  if (internalResponse?.summary) return { summary: 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 {
@@ -571,7 +730,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,
@@ -645,7 +819,7 @@ ${scopeText}
 }
 
 async function runSubagent(parentSession, params, parentSignal, onUpdate) {
-  const profile = await getAgentProfile(params?.subagent)
+  const profile = await getAgentProfile(params?.subagent, { workspaceRoot: parentSession.projectContext?.workspaceRoot })
   if (!profile || !profile.enabledAsSubagent) {
     const error = new Error(`Unknown or disabled subagent: ${params?.subagent || ''}`)
     error.statusCode = 400
@@ -769,7 +943,7 @@ async function runSubagent(parentSession, params, parentSignal, onUpdate) {
       }
       const commandPermissionError = commandToolPermissionError(parentSession, toolName)
       if (commandPermissionError) return { block: true, reason: commandPermissionError }
-      if (!parentSession.yoloMode) {
+      if (!hasFullAccess(parentSession)) {
         if (safeReadTools.has(toolName)) return undefined
         return createApprovalPromise(parentSession, context.toolCall?.id, toolName, context.args, {
           type: 'subagent',
@@ -950,8 +1124,15 @@ async function transformSessionContext(session, messages, signal) {
 export const agentEvents = new EventEmitter()
 agentEvents.setMaxListeners(100)
 
+function isIdleRetainedSession(session) {
+  return session?.idleRetention === 'always'
+}
+
 function resetIdleTimer(session) {
   if (session.idleTimer) clearTimeout(session.idleTimer)
+  session.idleTimer = null
+  if (isIdleRetainedSession(session)) return
+
   session.idleTimer = setTimeout(() => {
     if (session.status === 'running') {
       logger.info(`Session ${session.sessionId} idle timer fired but still running, resetting...`, { sessionId: session.sessionId, status: session.status })
@@ -986,6 +1167,7 @@ export function touchSession(sessionId) {
 export async function createAgent(sessionId, config = {}) {
   const existing = agentSessions.get(sessionId)
   if (existing) {
+    if (config.idleRetention !== undefined) existing.idleRetention = config.idleRetention
     resetIdleTimer(existing)
     return existing
   }
@@ -993,6 +1175,7 @@ export async function createAgent(sessionId, config = {}) {
   const {
     scope = 'global',
     projectId = null,
+    accessMode: rawAccessMode,
     yoloMode = false,
     model = null,
     thinkingLevel = 'off',
@@ -1003,17 +1186,23 @@ export async function createAgent(sessionId, config = {}) {
     lastModified = null,
     contextCompaction = null,
     agentProfile = null,
+    idleRetention = null,
   } = config
+  const accessMode = normalizeAccessMode(rawAccessMode, yoloMode)
+  const resolvedYoloMode = yoloModeFromAccessMode(accessMode)
 
-  // Resolve project context for tool calls
+  // Resolve project context for tool calls. Project conversations resolve to
+  // their directory; global conversations (no projectId) and any fallback fall
+  // back to a synthetic default workspace context so file tools stay available.
   let projectContext = null
   if (projectId) {
     try {
       projectContext = await projectContextFromId(projectId)
     } catch {
-      // project not found — run without tools
+      // project not found — fall back to the default workspace below
     }
   }
+  projectContext ??= defaultGlobalWorkspaceContext()
 
   // Build system prompt
   const projectConfig = await readProjectConfig()
@@ -1046,7 +1235,7 @@ export async function createAgent(sessionId, config = {}) {
     projectId,
     projectContext,
     skillsContext,
-    !!(projectId && projectContext),
+    !!projectContext,
     (toolName) => {
       if (profileToolNames && !profileToolNames.includes(toolName)) return `Agent profile ${agentProfile.name} is not allowed to use ${toolName}.`
       const session = agentSessions.get(sessionId)
@@ -1100,14 +1289,14 @@ export async function createAgent(sessionId, config = {}) {
       if (profileToolNames && !profileToolNames.includes(toolName)) return { block: true, reason: `Agent profile ${agentProfile.name} is not allowed to use ${toolName}.` }
       if (toolName === 'run_subagent') return undefined
       if (isMcpToolName(toolName) || isPluginToolName(toolName)) {
-        if (!currentSession?.yoloMode) return createApprovalPromise(currentSession, toolCallId, toolName, context.args)
+        if (!hasFullAccess(currentSession)) return createApprovalPromise(currentSession, toolCallId, toolName, context.args)
         return undefined
       }
-      if (!projectContext) {
+      if (!projectContext?.workspaceRoot) {
         return { block: true, reason: 'No active project. Select a project to use tools.' }
       }
-      if (!currentSession?.yoloMode) {
-        // YOLO OFF: safe reads auto-pass, dangerous writes require approval
+      if (!hasFullAccess(currentSession)) {
+        // Default access: safe reads auto-pass, state-changing or external tools require approval
         if (safeReadTools.has(toolName)) return undefined
         return createApprovalPromise(currentSession, toolCallId, toolName, context.args)
       }
@@ -1123,7 +1312,8 @@ export async function createAgent(sessionId, config = {}) {
     agent,
     projectContext,
     projectId,
-    yoloMode,
+    accessMode,
+    yoloMode: resolvedYoloMode,
     model: resolvedModel,
     thinkingLevel,
     scope,
@@ -1146,6 +1336,7 @@ export async function createAgent(sessionId, config = {}) {
     getApiKey,
     contextCompaction,
     agentProfile: agentProfile ? agentProfileSnapshot(agentProfile) : null,
+    idleRetention,
     lastTransformedContextMessages: null,
     autoCompacting: false,
     stateVersion: 0,
@@ -1157,7 +1348,7 @@ export async function createAgent(sessionId, config = {}) {
   }
 
   // Subscribe to agent lifecycle events and forward to eventBus
-  agent.subscribe((event) => {
+  agent.subscribe(async (event) => {
     // The pi-agent-core agent loop emits agent_end with `messages` that only
     // contains messages generated during THIS run (newMessages), not the
     // complete session history.  Replace with the authoritative full state
@@ -1187,10 +1378,14 @@ export async function createAgent(sessionId, config = {}) {
       session.status = 'running'
       session.startedAt = session.startedAt ?? new Date().toISOString()
       session.finishedAt = null
-      // Persist running state immediately so a browser refresh still shows the green dot
-      persistSession(session).catch((err) =>
-        logger.error(`Failed to persist session on start ${sessionId}:`, err, { sessionId }),
-      )
+      // Persist running state immediately so a browser refresh still shows the green dot.
+      // Brand-new runs have no messages until the first user message_end; persisting
+      // here would only trigger the empty-session cleanup path.
+      if (session.agent.state.messages.length > 0) {
+        persistSession(session).catch((err) =>
+          logger.error(`Failed to persist session on start ${sessionId}:`, err, { sessionId }),
+        )
+      }
     }
 
     if (event.type === 'agent_end') {
@@ -1206,15 +1401,28 @@ export async function createAgent(sessionId, config = {}) {
     }
 
     if (event.type === 'message_end') {
-      // Debounced persist for crash recovery; coalesces the many message_end
-      // events within a single run into infrequent full-session writes.
-      scheduleSessionPersist(session)
+      const isInitialUserMessage = (event.message?.role === 'user' || event.message?.role === 'user-with-attachments')
+        && session.agent.state.messages.length === 1
+      if (isInitialUserMessage) {
+        // External ACP channels run in a separate process from the web UI. Persist
+        // the first user message immediately so the session becomes visible on
+        // disk before a long/failed agent run can exit or be restarted.
+        try {
+          await flushSessionPersist(session)
+        } catch (err) {
+          logger.error(`Failed to persist initial user message for session ${sessionId}:`, err, { sessionId })
+        }
+      } else {
+        // Debounced persist for crash recovery; coalesces the many message_end
+        // events within a single run into infrequent full-session writes.
+        scheduleSessionPersist(session)
+      }
     }
   })
 
   agentSessions.set(sessionId, session)
   resetIdleTimer(session)
-  logger.info(`Created session ${sessionId} (scope: ${scope}, project: ${projectId || 'none'}, yolo: ${yoloMode})`, { sessionId, scope, projectId: projectId || undefined, yoloMode })
+  logger.info(`Created session ${sessionId} (scope: ${scope}, project: ${projectId || 'none'}, access: ${accessMode})`, { sessionId, scope, projectId: projectId || undefined, accessMode, yoloMode: resolvedYoloMode, idleRetention: idleRetention || undefined })
   return session
 }
 
@@ -1246,7 +1454,7 @@ function sessionLastModifiedFromMessages(messages, fallback) {
  * Persist session data to storage.
  */
 async function persistSession(session) {
-  const { sessionId, agent, scope, projectId, title, createdAt, lastModified: storedLastModified, status, startedAt, finishedAt, model, thinkingLevel, yoloMode, contextCompaction } = session
+  const { sessionId, agent, scope, projectId, title, createdAt, lastModified: storedLastModified, status, startedAt, finishedAt, model, thinkingLevel, accessMode, yoloMode, contextCompaction } = session
   const messages = agent.state.messages
 
   if (messages.length === 0) {
@@ -1269,6 +1477,7 @@ async function persistSession(session) {
     title,
     model,
     thinkingLevel,
+    accessMode,
     yoloMode,
     messages,
     createdAt: createdAt || now,
@@ -1279,6 +1488,7 @@ async function persistSession(session) {
     taskStartedAt: startedAt,
     taskFinishedAt: finishedAt,
     contextCompaction: contextCompaction || undefined,
+    idleRetention: session.idleRetention || undefined,
   }
   session.lastModified = lastModified
 
@@ -1320,6 +1530,7 @@ async function persistSession(session) {
     messageCount: messages.length,
     usage,
     thinkingLevel,
+    accessMode,
     yoloMode,
     preview,
     scope,
@@ -1334,6 +1545,7 @@ async function persistSession(session) {
       thresholdPercent: contextCompaction.thresholdPercent,
       usageBefore: contextCompaction.usageBefore,
     } : undefined,
+    idleRetention: session.idleRetention || undefined,
   }
 
   // Write to storage atomically (read-modify-write within queue)
@@ -1452,7 +1664,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)
@@ -1471,7 +1683,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) {
@@ -1491,6 +1703,10 @@ export async function runPrompt(sessionId, message, selectedCapabilities = []) {
     return clearSession(session)
   }
 
+  if (commandState.summary) {
+    return summarySession(session, initialUserMessage, commandState.summary)
+  }
+
   if (commandState.compact) {
     return compactSession(session, initialUserMessage, commandState.compact)
   }
@@ -1569,14 +1785,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' }
@@ -1678,6 +1907,7 @@ export function getSessionState(sessionId) {
     sessionId: session.sessionId,
     scope: session.scope,
     projectId: session.projectId,
+    accessMode: session.accessMode,
     yoloMode: session.yoloMode,
     systemPrompt: session.agent.state.systemPrompt,
     model: session.model,
@@ -1822,6 +2052,7 @@ export async function restoreAgent(sessionId) {
     return await createAgent(sessionId, {
       scope: sessionData.scope || 'global',
       projectId: sessionData.projectId || null,
+      accessMode: normalizeAccessMode(sessionData.accessMode, sessionData.yoloMode),
       yoloMode: sessionData.yoloMode || false,
       model: sessionData.model,
       thinkingLevel: sessionData.thinkingLevel || 'off',
@@ -1830,6 +2061,7 @@ export async function restoreAgent(sessionId) {
       createdAt: sessionData.createdAt,
       lastModified: sessionData.lastModified,
       contextCompaction: sessionData.contextCompaction || null,
+      idleRetention: sessionData.idleRetention || null,
     })
   } catch (err) {
     logger.error(`Failed to restore agent ${sessionId}:`, err, { sessionId })
@@ -1902,6 +2134,7 @@ export function listSessions() {
       scope: session.scope,
       status: session.status,
       title: session.title,
+      idleRetention: session.idleRetention || undefined,
     })
   }
   return result
@@ -1923,20 +2156,25 @@ export async function refreshAllSessionTools() {
   return result
 }
 
-export async function updateSessionYoloMode(sessionId, yoloMode) {
+export async function updateSessionAccessMode(sessionId, accessMode) {
   const session = agentSessions.get(sessionId)
   if (!session) {
     throw Object.assign(new Error('Session not found'), { statusCode: 404 })
   }
 
-  session.yoloMode = Boolean(yoloMode)
+  session.accessMode = normalizeAccessMode(accessMode, session.accessMode)
+  session.yoloMode = yoloModeFromAccessMode(session.accessMode)
   await rebuildSessionTools(session)
   await persistSession(session)
 
   const state = getSessionState(sessionId)
   emitSessionEvent(session, { type: 'state', ...state })
 
-  return { sessionId, yoloMode: session.yoloMode }
+  return { sessionId, accessMode: session.accessMode, yoloMode: session.yoloMode }
+}
+
+export async function updateSessionYoloMode(sessionId, yoloMode) {
+  return updateSessionAccessMode(sessionId, yoloMode ? AGENT_ACCESS_MODE_FULL_ACCESS : AGENT_ACCESS_MODE_DEFAULT)
 }
 
 /**