@shawnstack/quickforge 1.7.3 → 1.7.5

package/server/agent-manager.mjs

@@ -13,6 +13,7 @@ import {
   formatSubagentTask,
 } from './subagents.mjs'
 import { agentProfileSnapshot, getAgentProfile } from './agent-profiles.mjs'
+import { modelBindingFromModel, resolveImplicitModelPreference, resolveModelBinding } from './model-catalog.mjs'
 import { agentProfileFromMarkdown } from './agent-profile-files.mjs'
 import {
   applyCapabilityPolicy,
@@ -28,6 +29,7 @@ import {
 import { projectContextFromId, defaultGlobalWorkspaceContext, readProjectConfig } from './project-config.mjs'
 import { ensureStorage, readStore, atomicUpdate, atomicSessionMetadataUpdate, readSessionValue, writeSessionValue, deleteSessionValue, tempAgentsDir } from './storage.mjs'
 import { logger } from './utils/logger.mjs'
+import { publishChannelSessionChanged } from './channels/event-relay.mjs'
 import { withSessionPersistenceLock } from './session-persistence-lock.mjs'
 import { getGlobalMemoryRevision, isGlobalMemoryEnabled } from './global-memory.mjs'
 import { buildSystemPrompt, generateAiTitle, generateTitle } from './session-utils.mjs'
@@ -198,7 +200,8 @@ function hasFullAccess(session) {
 /** @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
+const ABORT_IDLE_WAIT_TIMEOUT_MS = 3000
+const SUBAGENT_DEFAULT_TIMEOUT_MS = 60 * 60 * 1000
 const SUBAGENT_TRACE_THROTTLE_MS = 150
 
 /**
@@ -429,6 +432,71 @@ function addToolTimingToEvent(session, event) {
   return event
 }
 
+function isRecord(value) {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value))
+}
+
+function updateRuntimeToolExecution(session, event) {
+  if (!event?.toolCallId) return
+  if (event.type !== 'tool_execution_start' && event.type !== 'tool_execution_update' && event.type !== 'tool_execution_end') return
+
+  const existing = session.runtimeToolExecutions?.get(event.toolCallId)
+  const toolName = event.toolName ?? existing?.toolName
+  if (!toolName) return
+  const result = event.type === 'tool_execution_end' ? event.result : event.partialResult
+  const existingDetails = isRecord(existing?.details) ? existing.details : {}
+  const resultDetails = isRecord(result?.details) ? result.details : {}
+  const quickforgeTiming = event.quickforgeTiming || resultDetails.quickforgeTiming || existingDetails.quickforgeTiming
+  const details = {
+    ...existingDetails,
+    ...resultDetails,
+    ...(quickforgeTiming ? { quickforgeTiming } : {}),
+    sessionId: resultDetails.sessionId ?? existingDetails.sessionId ?? session.sessionId,
+    toolCallId: resultDetails.toolCallId ?? existingDetails.toolCallId ?? event.toolCallId,
+  }
+
+  session.runtimeToolExecutions?.set(event.toolCallId, {
+    role: 'toolResult',
+    toolCallId: event.toolCallId,
+    toolName,
+    content: result?.content ?? existing?.content ?? [],
+    details,
+    isError: event.type === 'tool_execution_end' ? Boolean(event.isError) : false,
+    timestamp: existing?.timestamp ?? Date.now(),
+    pending: event.type !== 'tool_execution_end',
+  })
+}
+
+function messagesWithRuntimeToolExecutions(session) {
+  const messages = session.agent.state.messages || []
+  if (!session.runtimeToolExecutions?.size) return messages
+
+  const authoritativeToolCallIds = new Set(
+    messages
+      .filter((message) => message?.role === 'toolResult' && typeof message.toolCallId === 'string')
+      .map((message) => message.toolCallId),
+  )
+  const runtimeMessages = []
+  for (const [toolCallId, snapshot] of session.runtimeToolExecutions) {
+    if (authoritativeToolCallIds.has(toolCallId)) {
+      session.runtimeToolExecutions.delete(toolCallId)
+    } else {
+      const { pending: _pending, ...message } = snapshot
+      runtimeMessages.push(message)
+    }
+  }
+  return runtimeMessages.length > 0 ? [...messages, ...runtimeMessages] : messages
+}
+
+function runtimePendingToolCalls(session) {
+  const pending = new Set(session.agent.state.pendingToolCalls || [])
+  for (const [toolCallId, snapshot] of session.runtimeToolExecutions || []) {
+    if (snapshot.pending) pending.add(toolCallId)
+    else pending.delete(toolCallId)
+  }
+  return Array.from(pending)
+}
+
 export function markLatestAssistantProcessFinished(messages, finishedAt = Date.now()) {
   if (!Array.isArray(messages)) return false
   for (let index = messages.length - 1; index >= 0; index--) {
@@ -448,6 +516,37 @@ function updateSessionMessages(session, messages) {
   session.agent.state.messages = messages
 }
 
+const CLIENT_MESSAGE_ID_FIELD = 'quickforgeClientMessageId'
+
+function isManagedCloudModel(model) {
+  return model?.provider === 'quickforge-cloud' && model?.quickforgeModelSource === 'cloud'
+}
+
+function objectMetadata(message) {
+  const metadata = message?.metadata
+  return metadata && typeof metadata === 'object' && !Array.isArray(metadata) ? metadata : {}
+}
+
+function logicalMessageId(message) {
+  const value = objectMetadata(message)[CLIENT_MESSAGE_ID_FIELD]
+  return typeof value === 'string' && /^[A-Za-z0-9._:-]{1,128}$/.test(value) ? value : undefined
+}
+
+function messageWithLogicalId(message) {
+  if (!message || typeof message !== 'object' || logicalMessageId(message)) return message
+  return {
+    ...message,
+    metadata: {
+      ...objectMetadata(message),
+      [CLIENT_MESSAGE_ID_FIELD]: `qfcm_${randomUUID()}`,
+    },
+  }
+}
+
+function prepareCloudUserMessage(session, message) {
+  return isManagedCloudModel(session?.model) ? messageWithLogicalId(message) : message
+}
+
 function resetSessionCompaction(session) {
   session.contextCompaction = null
   session.lastAutoCompactAt = null
@@ -560,6 +659,9 @@ async function summarySession(session, initialUserMessage, summaryOptions) {
       accessMode: session.accessMode,
       yoloMode: session.yoloMode,
       model: session.model,
+      modelRef: session.modelRef,
+      modelAccessContext: session.modelAccessContext,
+      resolvePersistedModel: true,
       thinkingLevel: session.thinkingLevel,
       messages: compactedMessages,
       title: compactedTitle,
@@ -1014,7 +1116,7 @@ model:
   modelId: ${frontmatterString(spec.model.modelId)}${spec.model.api ? `
   api: ${frontmatterString(spec.model.api)}` : ''}${spec.model.baseUrl ? `
   baseUrl: ${frontmatterString(spec.model.baseUrl)}` : ''}` : ''}
-max-runtime-ms: ${Math.max(1000, Math.min(Number(spec.maxRuntimeMs || SUBAGENT_DEFAULT_TIMEOUT_MS), 30 * 60 * 1000))}
+max-runtime-ms: ${Math.max(1000, Math.min(Number(spec.maxRuntimeMs || SUBAGENT_DEFAULT_TIMEOUT_MS), 60 * 60 * 1000))}
 max-tool-calls: ${Math.max(1, Math.min(Number(spec.maxToolCalls || 300), 300))}
 ---
 ${spec.systemPrompt}
@@ -1068,10 +1170,15 @@ async function runSubagent(parentSession, params, parentSignal, onUpdate) {
     throw new Error('No active model is configured for the parent session.')
   }
 
-  const timeoutMs = Math.max(1000, Math.min(Number(definition.maxRuntimeMs || SUBAGENT_DEFAULT_TIMEOUT_MS), 30 * 60 * 1000))
+  const timeoutMs = Math.max(1000, Math.min(Number(definition.maxRuntimeMs || SUBAGENT_DEFAULT_TIMEOUT_MS), 60 * 60 * 1000))
   definition.capabilityPolicy ||= inferCapabilityPolicy(definition.allowedTools || [])
   definition.allowedTools = applyCapabilityPolicy(definition.allowedTools || [], definition.capabilityPolicy)
-  const { model: subagentModel, info: subagentModelInfo } = await resolveAgentProfileModel(definition, parentSession.model, readStore)
+  const { model: subagentModel, info: subagentModelInfo } = await resolveAgentProfileModel(
+    definition,
+    parentSession.model,
+    readStore,
+    parentSession.modelAccessContext || {},
+  )
   const subagentThinkingLevel = resolveAgentProfileThinkingLevel(definition, parentSession.thinkingLevel, subagentModel)
   const subagentSessionId = `${parentSession.sessionId}:subagent:${definition.name}:${randomUUID()}`
   const startedAt = Date.now()
@@ -1319,6 +1426,12 @@ function applyActiveCapabilityPrompt(messages, capabilityPrompt) {
   return messages
 }
 
+function activeTurnContextPrompt(session) {
+  return [session?.activeTransientContextPrompt, session?.activeCapabilityPrompt]
+    .filter((prompt) => typeof prompt === 'string' && prompt.trim())
+    .join('\n\n') || null
+}
+
 function compactSummaryIndex(messages) {
   for (let index = messages.length - 1; index >= 0; index--) {
     if (isCompactSummaryMessage(messages[index])) return index
@@ -1352,7 +1465,7 @@ async function transformSessionContext(session, messages, signal) {
   session.lastTransformedContextMessages = transformedMessages
   return applyActiveCapabilityPrompt(
     applyActiveCommandPrompt(compactedContextMessages(transformedMessages), session?.activeCommandPrompt),
-    session?.activeCapabilityPrompt,
+    activeTurnContextPrompt(session),
   )
 }
 
@@ -1432,9 +1545,15 @@ export async function createAgent(sessionId, config = {}) {
   const {
     scope = 'global',
     projectId = null,
+    source = null,
+    channelId = null,
+    channelName = null,
     accessMode: rawAccessMode,
     yoloMode = false,
     model = null,
+    modelRef = null,
+    modelAccessContext = null,
+    resolvePersistedModel = false,
     thinkingLevel = 'off',
     messages = [],
     systemPrompt = null,
@@ -1479,24 +1598,36 @@ export async function createAgent(sessionId, config = {}) {
 
   // Resolve model
   let resolvedModel = model
+  let resolvedModelRef = modelRef
   if (!resolvedModel) {
-    // Try to load from storage
+    // Try to load the active preference from storage. A stale/hidden implicit
+    // preference may fall back, while an explicit session binding never does.
     try {
       const settings = await readStore('settings')
       const raw = settings?.['active-model']
-      if (raw) resolvedModel = typeof raw === 'string' ? JSON.parse(raw) : raw
+      resolvedModel = await resolveImplicitModelPreference(raw, modelAccessContext || {})
     } catch {
       // ignore
     }
   }
   if (agentProfile?.model?.mode === 'fixed') {
-    resolvedModel = (await resolveAgentProfileModel(agentProfile, resolvedModel, readStore)).model
+    const profileBinding = await resolveAgentProfileModel(agentProfile, resolvedModel, readStore, modelAccessContext || {})
+    resolvedModel = profileBinding.model
+    resolvedModelRef = profileBinding.modelRef || null
     resolvedAgentProfile = {
       ...agentProfile,
       model: modelReferenceSnapshot(agentProfile.model),
     }
   }
   if (resolvedAgentProfile && !resolvedModel) throw new Error('No active model is configured for the agent session.')
+  const resolvedBinding = resolvedModel
+    ? (resolvedModelRef
+        ? { model: resolvedModel, modelRef: resolvedModelRef }
+        : model
+          ? { model: resolvedModel, modelRef: null }
+          : await modelBindingFromModel(resolvedModel))
+    : { model: resolvedModel, modelRef: null }
+  resolvedModel = resolvedBinding.model
   const resolvedThinkingLevel = agentProfile
     ? resolveAgentProfileThinkingLevel(agentProfile, thinkingLevel, resolvedModel)
     : thinkingLevel
@@ -1600,9 +1731,15 @@ export async function createAgent(sessionId, config = {}) {
     agent,
     projectContext,
     projectId,
+    source: typeof source === 'string' && source.trim() ? source.trim() : null,
+    channelId: typeof channelId === 'string' && channelId.trim() ? channelId.trim() : null,
+    channelName: typeof channelName === 'string' && channelName.trim() ? channelName.trim() : null,
     accessMode,
     yoloMode: resolvedYoloMode,
     model: resolvedModel,
+    modelRef: resolvedBinding.modelRef,
+    modelAccessContext: modelAccessContext || null,
+    resolvePersistedModel: resolvePersistedModel === true || Boolean(resolvedBinding.modelRef),
     thinkingLevel: resolvedThinkingLevel,
     scope,
     title,
@@ -1617,6 +1754,8 @@ export async function createAgent(sessionId, config = {}) {
     activeCommandName: null,
     activeCommandPermissions: null,
     activeCommandPrompt: null,
+    activeCapabilityPrompt: null,
+    activeTransientContextPrompt: null,
     eventBus,
     idleTimer: null,
     persistTimer: null,
@@ -1625,6 +1764,7 @@ export async function createAgent(sessionId, config = {}) {
     titleGenerationPromiseId: null,
     sessionCreatedEmitted: messages.length > 0,
     toolTimings: new Map(),
+    runtimeToolExecutions: new Map(),
     getApiKey,
     contextCompaction,
     agentProfile: resolvedAgentProfile ? agentProfileSnapshot(resolvedAgentProfile) : null,
@@ -1640,6 +1780,8 @@ export async function createAgent(sessionId, config = {}) {
     /** Track active SSE connections. Only one SSE stream allowed per session to prevent
      *  connection-pool exhaustion when two browser tabs load the same session. */
     sseConnected: false,
+    abortPending: false,
+    abortEndEmitted: false,
   }
 
   // Subscribe to agent lifecycle events and forward to eventBus
@@ -1649,6 +1791,7 @@ export async function createAgent(sessionId, config = {}) {
     // complete session history.  Replace with the authoritative full state
     // before forwarding to clients.
     const timedEvent = addToolTimingToEvent(session, event)
+    updateRuntimeToolExecution(session, timedEvent)
     const eventEndStatus = event.type === 'agent_end'
       ? session.agent.signal?.aborted
         ? 'aborted'
@@ -1668,11 +1811,14 @@ export async function createAgent(sessionId, config = {}) {
         }
       : timedEvent
 
-    // Forward all events to the session event bus and the global bus.
-    emitSessionEvent(session, forwardEvent)
+    const shouldForwardEvent = !(timedEvent.type === 'agent_end' && session.abortEndEmitted)
+    if (shouldForwardEvent) {
+      emitSessionEvent(session, forwardEvent)
+    }
 
     // Track status
     if (event.type === 'agent_start') {
+      session.abortEndEmitted = false
       session.status = 'running'
       session.startedAt = session.startedAt ?? new Date().toISOString()
       session.finishedAt = null
@@ -1687,6 +1833,8 @@ export async function createAgent(sessionId, config = {}) {
     }
 
     if (event.type === 'agent_end') {
+      session.abortPending = false
+      session.abortEndEmitted = false
       session.status = eventEndStatus || (session.agent.state.errorMessage ? 'error' : 'idle')
       session.finishedAt = new Date().toISOString()
       session.toolTimings?.clear()
@@ -1699,14 +1847,15 @@ export async function createAgent(sessionId, config = {}) {
     }
 
     if (event.type === 'message_end') {
-      const isInitialUserMessage = (event.message?.role === 'user' || event.message?.role === 'user-with-attachments')
-        && session.agent.state.messages.length === 1
-      if (isInitialUserMessage) {
-        // Persist the first user message before announcing the session or
-        // starting the asynchronous AI title request.
+      const isUserMessage = event.message?.role === 'user' || event.message?.role === 'user-with-attachments'
+      const isInitialUserMessage = isUserMessage && session.agent.state.messages.length === 1
+      const requiresDurableCloudMessage = isUserMessage && isManagedCloudModel(session.model) && Boolean(logicalMessageId(event.message))
+      if (isInitialUserMessage || requiresDurableCloudMessage) {
+        // Persist every managed Cloud user message before the provider stream starts,
+        // so its logical ID survives a process restart and resolves to the same private key.
         try {
           const metadata = await flushSessionPersist(session)
-          if (metadata) {
+          if (metadata && isInitialUserMessage) {
             if (!session.sessionCreatedEmitted) {
               session.sessionCreatedEmitted = true
               emitSessionEvent(session, { type: 'session_created', metadata })
@@ -1714,7 +1863,7 @@ export async function createAgent(sessionId, config = {}) {
             scheduleSessionTitleGeneration(session, event.message)
           }
         } catch (err) {
-          logger.error(`Failed to persist initial user message for session ${sessionId}:`, err, { sessionId })
+          logger.error(`Failed to persist user message for session ${sessionId}:`, err, { sessionId })
         }
       } else {
         // Debounced persist for crash recovery; coalesces the many message_end
@@ -1758,7 +1907,7 @@ function sessionLastModifiedFromMessages(messages, fallback) {
  * Persist session data to storage.
  */
 async function persistSessionUnlocked(session) {
-  const { sessionId, agent, scope, projectId, title, titleSource, createdAt, lastModified: storedLastModified, status, startedAt, finishedAt, model, thinkingLevel, accessMode, yoloMode, contextCompaction } = session
+  const { sessionId, agent, scope, projectId, source, channelId, channelName, title, titleSource, createdAt, lastModified: storedLastModified, status, startedAt, finishedAt, model, modelRef, thinkingLevel, accessMode, yoloMode, contextCompaction } = session
   const messages = agent.state.messages
 
   if (messages.length === 0) {
@@ -1781,6 +1930,7 @@ async function persistSessionUnlocked(session) {
     title,
     titleSource,
     model,
+    modelRef: modelRef || undefined,
     thinkingLevel,
     accessMode,
     yoloMode,
@@ -1789,6 +1939,9 @@ async function persistSessionUnlocked(session) {
     lastModified,
     scope,
     projectId: scope === 'project' ? projectId : undefined,
+    source: source || undefined,
+    channelId: channelId || undefined,
+    channelName: channelName || undefined,
     taskStatus: status,
     taskStartedAt: startedAt,
     taskFinishedAt: finishedAt,
@@ -1842,6 +1995,9 @@ async function persistSessionUnlocked(session) {
     preview,
     scope,
     projectId: scope === 'project' ? projectId : undefined,
+    source: source || undefined,
+    channelId: channelId || undefined,
+    channelName: channelName || undefined,
     taskStatus: status,
     taskStartedAt: startedAt,
     taskFinishedAt: finishedAt,
@@ -1856,30 +2012,45 @@ async function persistSessionUnlocked(session) {
   }
 
   // Write to storage atomically (read-modify-write within queue)
+  let persistedMetadata
   try {
     await writeSessionValue(sessionId, sessionData)
-    let archivedAt
     await atomicSessionMetadataUpdate(scope, projectId, (data) => {
       const existingMetadata = data[sessionId]
-      archivedAt = existingMetadata?.archivedAt
+      const archivedAt = existingMetadata?.archivedAt
       // Merge onto the existing record so storage-only fields the in-memory
       // session does not own (pinnedAt, archivedAt, …) survive the rebuild.
-      data[sessionId] = {
+      persistedMetadata = {
         ...existingMetadata,
         ...metadata,
         ...(archivedAt ? { archivedAt } : {}),
       }
+      data[sessionId] = persistedMetadata
       return data
     })
-    if (archivedAt) {
-      await writeSessionValue(sessionId, { ...sessionData, archivedAt })
+    if (persistedMetadata?.archivedAt) {
+      await writeSessionValue(sessionId, { ...sessionData, archivedAt: persistedMetadata.archivedAt })
     }
   } catch (err) {
     logger.error(`Failed to persist session ${sessionId}:`, err, { sessionId })
     return null
   }
 
-  return metadata
+  if (source === 'acp' && channelId && persistedMetadata) {
+    void publishChannelSessionChanged({
+      channelId,
+      channelName: channelName || undefined,
+      sessionId,
+      projectId: scope === 'project' ? projectId : null,
+      workspace: scope === 'project'
+        ? { id: projectId, kind: 'project' }
+        : { id: 'default', kind: 'default' },
+      change: 'upsert',
+      metadata: persistedMetadata,
+    })
+  }
+
+  return persistedMetadata || metadata
 }
 
 async function persistSession(session) {
@@ -1952,7 +2123,10 @@ export async function rollbackSessionMessages(sessionId, rollbackMessageIndex) {
     throw Object.assign(new Error('Session not found'), { statusCode: 404 })
   }
   if (session.agent.state.isStreaming) {
-    throw Object.assign(new Error('Generation is still running. Stop it or wait until it finishes before rolling back.'), { statusCode: 409 })
+    throw Object.assign(new Error('Generation is still running. Stop it or wait until it finishes before rolling back.'), {
+      statusCode: 409,
+      errorCode: 'GENERATION_STILL_RUNNING_BEFORE_ROLLBACK',
+    })
   }
 
   const messages = Array.isArray(session.agent.state.messages) ? session.agent.state.messages : []
@@ -2016,21 +2190,42 @@ function scheduleSessionTitleGeneration(session, userMessage) {
   session.titleGenerationPromiseId = generationId
 }
 
+async function refreshSessionModelBinding(session) {
+  if (!session?.model || (!session.modelRef && session.resolvePersistedModel !== true)) return session
+  const binding = await resolveModelBinding(
+    session.modelRef ? { modelRef: session.modelRef } : { model: session.model },
+    {
+      context: session.modelAccessContext || {},
+      currentModel: session.model,
+      allowCurrentHidden: true,
+      forExecution: true,
+      legacySnapshot: session.model,
+    },
+  )
+  session.model = binding.model
+  session.modelRef = binding.modelRef
+  session.resolvePersistedModel = true
+  session.agent.state.model = binding.model
+  return session
+}
+
 /**
  * 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 = [], promptCommand = null) {
-  let session = agentSessions.get(sessionId)
-  if (!session) {
-    session = await restoreAgent(sessionId)
-  }
+export async function runPrompt(sessionId, message, selectedCapabilities = [], promptCommand = null, transientContextPrompt = null, modelAccessContext = null) {
+  let session = await syncSessionFromStorage(sessionId)
   if (!session) {
     throw Object.assign(new Error('Session not found'), { statusCode: 404 })
   }
+  if (modelAccessContext) session.modelAccessContext = modelAccessContext
+  await refreshSessionModelBinding(session)
 
-  if (session.agent.state.isStreaming) {
-    throw Object.assign(new Error('Generation is still running. Stop it or wait until it finishes.'), { statusCode: 409 })
+  if (session.agent.state.isStreaming || session.abortPending) {
+    throw Object.assign(new Error('Generation is still running. Stop it or wait until it finishes.'), {
+      statusCode: 409,
+      errorCode: 'GENERATION_ALREADY_RUNNING',
+    })
   }
 
   await refreshMemoryState(session)
@@ -2041,7 +2236,7 @@ export async function runPrompt(sessionId, message, selectedCapabilities = [], p
     ? { role: 'user', content: message, timestamp: new Date().toISOString() }
     : message
   const commandState = await resolveCommandState(session, initialUserMessage, promptCommand)
-  const userMessage = commandState.userMessage ?? initialUserMessage
+  const resolvedUserMessage = commandState.userMessage ?? initialUserMessage
 
   if (commandState.textResponse) {
     session.agent.state.messages = [
@@ -2068,6 +2263,8 @@ export async function runPrompt(sessionId, message, selectedCapabilities = [], p
     return compactSession(session, initialUserMessage, commandState.compact)
   }
 
+  const userMessage = prepareCloudUserMessage(session, resolvedUserMessage)
+
   // Set a meaningful fallback immediately. The AI title request starts only
   // after the first user message has been persisted by the message_end handler.
   if (session.titleSource === 'default' && session.title === 'New chat') {
@@ -2082,6 +2279,9 @@ export async function runPrompt(sessionId, message, selectedCapabilities = [], p
   session.activeCommandPermissions = commandState.permissions ?? null
   session.activeCommandPrompt = commandState.commandPrompt ?? null
   session.activeCapabilityPrompt = selectedCapabilityPrompt(selectedCapabilities)
+  session.activeTransientContextPrompt = typeof transientContextPrompt === 'string' && transientContextPrompt.trim()
+    ? transientContextPrompt
+    : null
 
   // Fire and forget — events come through eventBus
   session.agent.prompt(userMessage).catch((err) => {
@@ -2096,6 +2296,7 @@ export async function runPrompt(sessionId, message, selectedCapabilities = [], p
     session.activeCommandPermissions = null
     session.activeCommandPrompt = null
     session.activeCapabilityPrompt = null
+    session.activeTransientContextPrompt = null
   })
 
   return { sessionId, status: session.status }
@@ -2109,14 +2310,19 @@ export async function runPrompt(sessionId, message, selectedCapabilities = [], p
  * Trims messages to keep up to and including the last user message,
  * removing the assistant response that follows it.
  */
-export async function continueSession(sessionId) {
+export async function continueSession(sessionId, modelAccessContext = null) {
   const session = agentSessions.get(sessionId)
   if (!session) {
     throw Object.assign(new Error('Session not found'), { statusCode: 404 })
   }
   if (session.agent.state.isStreaming) {
-    throw Object.assign(new Error('Generation is still running. Stop it or wait until it finishes.'), { statusCode: 409 })
+    throw Object.assign(new Error('Generation is still running. Stop it or wait until it finishes.'), {
+      statusCode: 409,
+      errorCode: 'GENERATION_ALREADY_RUNNING',
+    })
   }
+  if (modelAccessContext) session.modelAccessContext = modelAccessContext
+  await refreshSessionModelBinding(session)
 
   const messages = Array.isArray(session.agent.state.messages) ? session.agent.state.messages : []
 
@@ -2134,10 +2340,13 @@ export async function continueSession(sessionId) {
 
   const lastUserMessage = messages[lastUserIndex]
   const commandState = await resolveCommandState(session, lastUserMessage)
-  const continuedUserMessage = commandState.userMessage ?? lastUserMessage
+  const continuedUserMessage = prepareCloudUserMessage(session, commandState.userMessage ?? lastUserMessage)
   const trimmedMessages = messages.slice(0, lastUserIndex).concat(continuedUserMessage)
   updateSessionMessages(session, trimmedMessages)
   resetSessionCompaction(session)
+  if (isManagedCloudModel(session.model) && logicalMessageId(continuedUserMessage)) {
+    await flushSessionPersist(session)
+  }
 
   resetIdleTimer(session)
   session.activeCommandName = commandState.commandName ?? null
@@ -2181,7 +2390,19 @@ export async function abortRun(sessionId) {
   }
 
   session.agent.abort()
-  await session.agent.waitForIdle()
+  let idleWaitTimer
+  const becameIdle = await Promise.race([
+    session.agent.waitForIdle().then(() => true),
+    new Promise((resolve) => {
+      idleWaitTimer = setTimeout(() => resolve(false), ABORT_IDLE_WAIT_TIMEOUT_MS)
+      idleWaitTimer.unref?.()
+    }),
+  ])
+  clearTimeout(idleWaitTimer)
+  if (!becameIdle) {
+    session.abortPending = true
+    logger.warn(`Agent ${sessionId} did not become idle within ${ABORT_IDLE_WAIT_TIMEOUT_MS}ms after abort`, { sessionId })
+  }
 
   if (session.status === 'running') {
     session.status = 'aborted'
@@ -2189,6 +2410,7 @@ export async function abortRun(sessionId) {
     persistSession(session).catch((err) =>
       logger.error(`Failed to persist aborted session ${sessionId}:`, err, { sessionId }),
     )
+    session.abortEndEmitted = true
     const event = {
       type: 'agent_end',
       status: 'aborted',
@@ -2209,9 +2431,9 @@ export function steerAgent(sessionId, message) {
     throw Object.assign(new Error('Session not found'), { statusCode: 404 })
   }
 
-  const agentMessage = typeof message === 'string'
+  const agentMessage = prepareCloudUserMessage(session, typeof message === 'string'
     ? { role: 'user', content: message, timestamp: Date.now() }
-    : message
+    : message)
 
   session.agent.steer(agentMessage)
   return { sessionId, steered: true }
@@ -2226,9 +2448,9 @@ export function followUpAgent(sessionId, message) {
     throw Object.assign(new Error('Session not found'), { statusCode: 404 })
   }
 
-  const agentMessage = typeof message === 'string'
+  const agentMessage = prepareCloudUserMessage(session, typeof message === 'string'
     ? { role: 'user', content: message, timestamp: Date.now() }
-    : message
+    : message)
 
   session.agent.followUp(agentMessage)
   return { sessionId, followUp: true }
@@ -2243,6 +2465,62 @@ function getSessionContextUsage(session) {
   }
 }
 
+function storedMessagesExtendLocalHistory(localMessages, storedMessages) {
+  if (!Array.isArray(localMessages) || !Array.isArray(storedMessages) || storedMessages.length <= localMessages.length) return false
+  return localMessages.every((message, index) => {
+    const local = { ...message }
+    const stored = { ...storedMessages[index] }
+    delete local.processFinishedAt
+    delete stored.processFinishedAt
+    return JSON.stringify(local) === JSON.stringify(stored)
+  })
+}
+
+export async function syncSessionFromStorage(sessionId) {
+  let session = agentSessions.get(sessionId)
+  if (!session) return restoreAgent(sessionId)
+  if (session.agent.state.isStreaming) return session
+
+  try {
+    const stored = await readSessionValue(sessionId)
+    if (!stored || !Array.isArray(stored.messages)) return session
+
+    const localMessages = Array.isArray(session.agent.state.messages) ? session.agent.state.messages : []
+    const storedStateVersion = Number.isFinite(stored.stateVersion) ? stored.stateVersion : 0
+    const localStateVersion = Number.isFinite(session.stateVersion) ? session.stateVersion : 0
+    const storedLastModified = Date.parse(stored.lastModified || '')
+    const localLastModified = Date.parse(session.lastModified || '')
+    const hasNewerVersion = storedStateVersion > localStateVersion
+    const storedExtendsLocalHistory = storedMessagesExtendLocalHistory(localMessages, stored.messages)
+    const hasMoreMessages = storedExtendsLocalHistory
+    const hasNewerActivityAtSameVersion = storedStateVersion === localStateVersion
+      && stored.messages.length === localMessages.length
+      && Number.isFinite(storedLastModified)
+      && (!Number.isFinite(localLastModified) || storedLastModified > localLastModified)
+
+    if (!hasNewerVersion && !hasMoreMessages && !hasNewerActivityAtSameVersion) return session
+
+    session.agent.state.messages = stored.messages
+    session.title = stored.title || session.title
+    session.titleSource = stored.titleSource || session.titleSource
+    session.source = stored.source || session.source
+    session.channelId = stored.channelId || session.channelId
+    session.channelName = stored.channelName || session.channelName
+    session.lastModified = stored.lastModified || session.lastModified
+    session.status = stored.taskStatus || 'idle'
+    session.startedAt = stored.taskStartedAt || null
+    session.finishedAt = stored.taskFinishedAt || null
+    session.contextCompaction = stored.contextCompaction || null
+    session.stateVersion = Math.max(localStateVersion, storedStateVersion)
+    session.runtimeToolExecutions?.clear()
+    resetIdleTimer(session)
+    return session
+  } catch (error) {
+    logger.warn(`Failed to sync session ${sessionId} from storage:`, error?.message || error, { sessionId })
+    return session
+  }
+}
+
 /**
  * Get the current state of a session (for page refresh recovery).
  */
@@ -2250,14 +2528,19 @@ export function getSessionState(sessionId) {
   const session = agentSessions.get(sessionId)
   if (!session) return null
 
+  const messages = messagesWithRuntimeToolExecutions(session)
   return {
     sessionId: session.sessionId,
     scope: session.scope,
     projectId: session.projectId,
+    source: session.source || undefined,
+    channelId: session.channelId || undefined,
+    channelName: session.channelName || undefined,
     accessMode: session.accessMode,
     yoloMode: session.yoloMode,
     systemPrompt: session.agent.state.systemPrompt,
     model: session.model,
+    modelRef: session.modelRef || undefined,
     thinkingLevel: session.thinkingLevel,
     title: session.title,
     titleSource: session.titleSource,
@@ -2268,12 +2551,13 @@ export function getSessionState(sessionId) {
     startedAt: session.startedAt,
     finishedAt: session.finishedAt,
     tools: session.agent.state.tools,
-    messages: session.agent.state.messages,
+    messages,
+    pendingToolCalls: runtimePendingToolCalls(session),
     contextCompaction: session.contextCompaction,
     contextUsage: getSessionContextUsage(session),
     pendingToolApproval: getPendingApprovalForSession(session.sessionId),
     pendingAutoCompactApproval: getPendingAutoCompactApprovalForSession(session.sessionId),
-    isStreaming: session.agent.state.isStreaming,
+    isStreaming: session.abortPending ? false : session.agent.state.isStreaming,
     errorMessage: session.agent.state.errorMessage,
   }
 }
@@ -2291,6 +2575,9 @@ export function getSessionStatus(sessionId) {
     sessionId: session.sessionId,
     scope: session.scope,
     projectId: session.projectId,
+    source: session.source || undefined,
+    channelId: session.channelId || undefined,
+    channelName: session.channelName || undefined,
     title: session.title,
     createdAt: session.createdAt,
     lastModified: session.lastModified,
@@ -2298,7 +2585,7 @@ export function getSessionStatus(sessionId) {
     status: session.status,
     startedAt: session.startedAt,
     finishedAt: session.finishedAt,
-    isStreaming: session.agent.state.isStreaming,
+    isStreaming: session.abortPending ? false : session.agent.state.isStreaming,
     errorMessage: session.agent.state.errorMessage,
     messageCount: messages.length,
     lastMessageTimestamp: lastMessage?.timestamp ?? null,
@@ -2402,9 +2689,14 @@ export async function restoreAgent(sessionId) {
     return await createAgent(sessionId, {
       scope: sessionData.scope || 'global',
       projectId: sessionData.projectId || null,
+      source: sessionData.source || null,
+      channelId: sessionData.channelId || null,
+      channelName: sessionData.channelName || null,
       accessMode: normalizeAccessMode(sessionData.accessMode, sessionData.yoloMode),
       yoloMode: sessionData.yoloMode || false,
       model: sessionData.model,
+      modelRef: sessionData.modelRef || null,
+      resolvePersistedModel: true,
       thinkingLevel: sessionData.thinkingLevel || 'off',
       messages: sessionData.messages || [],
       title: sessionData.title || 'New chat',
@@ -2486,6 +2778,9 @@ export function listSessions() {
       scope: session.scope,
       status: session.status,
       title: session.title,
+      source: session.source || undefined,
+      channelId: session.channelId || undefined,
+      channelName: session.channelName || undefined,
       idleRetention: session.idleRetention || undefined,
     })
   }
@@ -2557,7 +2852,7 @@ export async function updateSessionYoloMode(sessionId, yoloMode) {
  * Does NOT force persistence — normal lifecycle events (message_end, agent_end) will persist
  * the updated model.
  */
-export function updateSessionModel(sessionId, model) {
+export function updateSessionModel(sessionId, model, modelRef = null) {
   const session = agentSessions.get(sessionId)
   if (!session) {
     throw Object.assign(new Error('Session not found'), { statusCode: 404 })
@@ -2567,9 +2862,11 @@ export function updateSessionModel(sessionId, model) {
   }
 
   session.model = model
+  session.modelRef = modelRef
+  session.resolvePersistedModel = true
   session.agent.state.model = model
 
-  return { sessionId, model }
+  return { sessionId, model, modelRef: modelRef || undefined }
 }
 
 /**