@shawnstack/quickforge 1.7.4 → 1.7.6

package/server/agent-manager.mjs

@@ -8,11 +8,13 @@ import { loadSkillToolContext, abortRunningCommand } from './tools/index.mjs'
 import { createSkillTools, globalMemoryTool, workspaceTools } from './tools/definitions.mjs'
 import { createMcpToolDefinitions, isMcpToolName } from './mcp/registry.mjs'
 import { createPluginToolDefinitions, isPluginToolName } from './plugins/registry.mjs'
+import { createOpenCodeAcpAgent } from './opencode-acp-agent.mjs'
 import {
   composeSubagentSystemPrompt,
   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,
@@ -147,6 +149,10 @@ async function createServerTools(projectId, projectContext, skillsContext, inclu
 }
 
 async function rebuildSessionTools(session) {
+  if (session.harness === AGENT_HARNESS_OPENCODE) {
+    session.agent.state.tools = []
+    return
+  }
   const profileToolNames = Array.isArray(session.agentProfile?.allowedTools) ? session.agentProfile.allowedTools : null
   session.agent.state.tools = await createServerTools(
     session.projectId,
@@ -179,6 +185,25 @@ const agentSessions = new Map()
 
 const AGENT_ACCESS_MODE_DEFAULT = 'default'
 const AGENT_ACCESS_MODE_FULL_ACCESS = 'full-access'
+const AGENT_HARNESS_QUICKFORGE = 'quickforge'
+const AGENT_HARNESS_OPENCODE = 'opencode'
+
+export function normalizeAgentHarness(value, fallback = AGENT_HARNESS_QUICKFORGE) {
+  if (value === AGENT_HARNESS_QUICKFORGE || value === AGENT_HARNESS_OPENCODE) return value
+  if (fallback !== value) return normalizeAgentHarness(fallback, AGENT_HARNESS_QUICKFORGE)
+  return AGENT_HARNESS_QUICKFORGE
+}
+
+export function validateAgentHarness(value) {
+  if (value === undefined || value === null || value === '') return AGENT_HARNESS_QUICKFORGE
+  if (value === 'claude-code') {
+    throw Object.assign(new Error('Claude Code Harness is not available yet.'), { statusCode: 400 })
+  }
+  if (value !== AGENT_HARNESS_QUICKFORGE && value !== AGENT_HARNESS_OPENCODE) {
+    throw Object.assign(new Error(`Unsupported Harness: ${value}`), { statusCode: 400 })
+  }
+  return value
+}
 
 function normalizeAccessMode(value, fallback = AGENT_ACCESS_MODE_DEFAULT) {
   if (value === AGENT_ACCESS_MODE_DEFAULT || value === AGENT_ACCESS_MODE_FULL_ACCESS) return value
@@ -200,7 +225,7 @@ function hasFullAccess(session) {
 
 const IDLE_TIMEOUT_MS = 30 * 60 * 1000 // 30 minutes
 const ABORT_IDLE_WAIT_TIMEOUT_MS = 3000
-const SUBAGENT_DEFAULT_TIMEOUT_MS = 30 * 60 * 1000
+const SUBAGENT_DEFAULT_TIMEOUT_MS = 60 * 60 * 1000
 const SUBAGENT_TRACE_THROTTLE_MS = 150
 
 /**
@@ -278,6 +303,58 @@ function createApprovalPromise(session, toolCallId, toolName, args, source) {
   })
 }
 
+function createAcpApprovalPromise(session, request) {
+  return new Promise((resolve, reject) => {
+    let settled = false
+    const requestedAt = Date.now()
+    const expiresAt = requestedAt + APPROVAL_TIMEOUT_MS
+    const timeout = setTimeout(() => {
+      if (settled) return
+      settled = true
+      pendingApprovals.delete(request.toolCallId)
+      resolve({ outcome: { outcome: 'cancelled' } })
+    }, APPROVAL_TIMEOUT_MS)
+
+    const cleanup = () => {
+      clearTimeout(timeout)
+      if (settled) return
+      settled = true
+      pendingApprovals.delete(request.toolCallId)
+    }
+    const allowOption = request.options.find((option) => option.kind === 'allow_once' || option.kind === 'allow_always')
+    const rejectOption = request.options.find((option) => option.kind === 'reject_once' || option.kind === 'reject_always')
+
+    pendingApprovals.set(request.toolCallId, {
+      resolve: (approved) => {
+        cleanup()
+        const option = approved ? allowOption : rejectOption
+        resolve(option
+          ? { outcome: { outcome: 'selected', optionId: option.optionId } }
+          : { outcome: { outcome: 'cancelled' } })
+      },
+      reject: (error) => {
+        cleanup()
+        reject(error)
+      },
+      sessionId: session.sessionId,
+      toolName: request.toolName,
+      args: request.args,
+      source: 'opencode',
+      requestedAt,
+      expiresAt,
+    })
+
+    emitSessionEvent(session, {
+      type: 'tool_approval_required',
+      sessionId: session.sessionId,
+      toolCallId: request.toolCallId,
+      toolName: request.toolName,
+      args: request.args,
+      source: 'opencode',
+    })
+  })
+}
+
 function createAutoCompactApprovalPromise(session, details = {}) {
   if (!session) return Promise.resolve(false)
   const approvalId = randomUUID()
@@ -376,6 +453,24 @@ function userTextMessage(text, details) {
   }
 }
 
+function assistantErrorMessage(text, model) {
+  return {
+    ...assistantTextMessage('', model),
+    stopReason: 'error',
+    errorMessage: text,
+    timestamp: Date.now(),
+  }
+}
+
+export function appendAssistantErrorMessageOnce(messages, errorMessage, model) {
+  const current = Array.isArray(messages) ? messages : []
+  const lastMessage = current[current.length - 1]
+  const errorAlreadyShown = lastMessage?.role === 'assistant'
+    && lastMessage?.stopReason === 'error'
+    && lastMessage?.errorMessage
+  return errorAlreadyShown ? current : [...current, assistantErrorMessage(errorMessage, model)]
+}
+
 function compactedSessionTitle(title) {
   const base = typeof title === 'string' && title.trim() ? title.trim() : 'New chat'
   if (base === 'New chat') return 'Compacted chat'
@@ -515,6 +610,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
@@ -532,6 +658,9 @@ function finishManualSessionRun(session, status, errorMessage) {
 }
 
 async function summarySession(session, initialUserMessage, summaryOptions) {
+  if (session.harness === AGENT_HARNESS_OPENCODE) {
+    throw Object.assign(new Error('OpenCode Harness does not support QuickForge summary derivation yet.'), { statusCode: 409 })
+  }
   if (session.agent.state.isStreaming) {
     session.agent.state.messages = [
       ...session.agent.state.messages,
@@ -625,8 +754,13 @@ async function summarySession(session, initialUserMessage, summaryOptions) {
       scope: session.scope,
       projectId: session.projectId,
       accessMode: session.accessMode,
+      harness: session.harness,
+      sourceHarnessSessionId: session.harness === AGENT_HARNESS_OPENCODE ? session.agent.harnessSessionId : null,
       yoloMode: session.yoloMode,
       model: session.model,
+      modelRef: session.modelRef,
+      modelAccessContext: session.modelAccessContext,
+      resolvePersistedModel: true,
       thinkingLevel: session.thinkingLevel,
       messages: compactedMessages,
       title: compactedTitle,
@@ -1081,7 +1215,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}
@@ -1135,10 +1269,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()
@@ -1511,6 +1650,9 @@ export async function createAgent(sessionId, config = {}) {
     accessMode: rawAccessMode,
     yoloMode = false,
     model = null,
+    modelRef = null,
+    modelAccessContext = null,
+    resolvePersistedModel = false,
     thinkingLevel = 'off',
     messages = [],
     systemPrompt = null,
@@ -1519,12 +1661,17 @@ export async function createAgent(sessionId, config = {}) {
     createdAt = new Date().toISOString(),
     lastModified = null,
     contextCompaction = null,
+    harness: rawHarness,
+    harnessSessionId = null,
+    sourceHarnessSessionId = null,
+    openCodeUsage = null,
     agentProfile = null,
     idleRetention = null,
     stateVersion = 0,
   } = config
   const accessMode = normalizeAccessMode(rawAccessMode, yoloMode)
   const resolvedYoloMode = yoloModeFromAccessMode(accessMode)
+  const harness = normalizeAgentHarness(rawHarness)
 
   // Resolve project context for tool calls. Project conversations resolve to
   // their directory; global conversations (no projectId) and any fallback fall
@@ -1539,8 +1686,8 @@ export async function createAgent(sessionId, config = {}) {
   }
   projectContext ??= defaultGlobalWorkspaceContext()
 
-  // Build system prompt
-  const projectConfig = await readProjectConfig()
+  // Build system prompt and tools only for the native QuickForge runtime.
+  const projectConfig = harness === AGENT_HARNESS_QUICKFORGE ? await readProjectConfig() : { projects: [], globalSkills: [] }
   const configuredProject = projectId
     ? projectConfig.projects.find((project) => project.id === projectId)
     : null
@@ -1549,61 +1696,82 @@ export async function createAgent(sessionId, config = {}) {
     projectSkillNames: configuredProject?.skills,
   }
   const profileSystemPrompt = agentProfileSystemPrompt(agentProfile)
-  const resolvedSystemPrompt = systemPrompt ?? `${await buildSystemPrompt(projectId)}${profileSystemPrompt}`
+  const resolvedSystemPrompt = harness === AGENT_HARNESS_QUICKFORGE
+    ? systemPrompt ?? `${await buildSystemPrompt(projectId)}${profileSystemPrompt}`
+    : ''
+  if (harness === AGENT_HARNESS_OPENCODE && messages.length > 0 && !harnessSessionId && !sourceHarnessSessionId) {
+    throw Object.assign(new Error('OpenCode history requires a persisted ACP session ID or an ACP fork source.'), { statusCode: 400 })
+  }
 
   let resolvedAgentProfile = agentProfile
 
-  // Resolve model
+  // OpenCode owns its login, model, tools and context. QuickForge runtime keeps
+  // the existing model resolution path unchanged.
   let resolvedModel = model
-  if (!resolvedModel) {
-    // Try to load from storage
+  let resolvedModelRef = modelRef
+  if (!resolvedModel && harness === AGENT_HARNESS_QUICKFORGE) {
+    // 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 = harness === AGENT_HARNESS_QUICKFORGE && 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
 
-  // Build skills tools for enabled skills, plus workspace tools when a project is available.
+  // Build native tools only for QuickForge. OpenCode uses its own tools and
+  // must not receive QuickForge MCP, Skills, Memory or workspace definitions.
   const profileToolNames = Array.isArray(agentProfile?.allowedTools) ? agentProfile.allowedTools : null
-  const tools = await createServerTools(
-    projectId,
-    projectContext,
-    skillsContext,
-    !!projectContext,
-    (toolName) => {
-      if (profileToolNames && !profileToolNames.includes(toolName)) return `Agent profile ${agentProfile.name} is not allowed to use ${toolName}.`
-      const session = agentSessions.get(sessionId)
-      return session ? createCommandToolPermissions(session)(toolName) : null
-    },
-    agentProfile
-      ? {
-          allowedToolNames: profileToolNames,
-          includeSubagentTool: false,
-          includeMcpTools: false,
-          parentSessionId: sessionId,
-          sessionId,
-          scope,
-        }
-      : {
-          parentSessionId: sessionId,
-          sessionId,
-          scope,
+  const tools = harness === AGENT_HARNESS_QUICKFORGE
+    ? await createServerTools(
+        projectId,
+        projectContext,
+        skillsContext,
+        !!projectContext,
+        (toolName) => {
+          if (profileToolNames && !profileToolNames.includes(toolName)) return `Agent profile ${agentProfile.name} is not allowed to use ${toolName}.`
+          const session = agentSessions.get(sessionId)
+          return session ? createCommandToolPermissions(session)(toolName) : null
         },
-  )
+        agentProfile
+          ? {
+              allowedToolNames: profileToolNames,
+              includeSubagentTool: false,
+              includeMcpTools: false,
+              parentSessionId: sessionId,
+              sessionId,
+              scope,
+            }
+          : {
+              parentSessionId: sessionId,
+              sessionId,
+              scope,
+            },
+      )
+    : []
 
   // Resolve API key
   const getApiKey = async (provider) => {
@@ -1615,10 +1783,21 @@ export async function createAgent(sessionId, config = {}) {
     }
   }
 
-  const initialMemoryEnabled = await isGlobalMemoryEnabled()
+  const initialMemoryEnabled = harness === AGENT_HARNESS_QUICKFORGE ? await isGlobalMemoryEnabled() : false
   const initialMemoryRevision = initialMemoryEnabled ? await getGlobalMemoryRevision() : null
   let session
-  const agent = new Agent({
+  const agent = harness === AGENT_HARNESS_OPENCODE
+    ? await createOpenCodeAcpAgent({
+        sessionId,
+        cwd: projectContext.workspaceRoot,
+        messages,
+        harnessSessionId,
+        sourceHarnessSessionId,
+        restoredUsage: openCodeUsage,
+        logger,
+        requestPermission: (request) => createAcpApprovalPromise(session, request),
+      })
+    : new Agent({
     initialState: {
       systemPrompt: resolvedSystemPrompt,
       model: resolvedModel,
@@ -1674,6 +1853,8 @@ export async function createAgent(sessionId, config = {}) {
   session = {
     sessionId,
     agent,
+    harness,
+    harnessSessionId: agent.harnessSessionId || null,
     projectContext,
     projectId,
     source: typeof source === 'string' && source.trim() ? source.trim() : null,
@@ -1682,6 +1863,9 @@ export async function createAgent(sessionId, config = {}) {
     accessMode,
     yoloMode: resolvedYoloMode,
     model: resolvedModel,
+    modelRef: resolvedBinding.modelRef,
+    modelAccessContext: modelAccessContext || null,
+    resolvePersistedModel: resolvePersistedModel === true || Boolean(resolvedBinding.modelRef),
     thinkingLevel: resolvedThinkingLevel,
     scope,
     title,
@@ -1743,6 +1927,15 @@ export async function createAgent(sessionId, config = {}) {
       : undefined
     if (timedEvent.type === 'agent_end') {
       markLatestAssistantProcessFinished(agent.state.messages)
+      // Ensure a failed run is visible in the conversation. Most failures emit
+      // an assistant error message through the agent loop (handleRunFailure),
+      // but a few paths (e.g. concurrent-run rejection) only set
+      // `state.errorMessage`. Append an error message so the user sees the
+      // reason at the end of the transcript instead of only a toast.
+      const runError = session.agent.state.errorMessage
+      if (runError) {
+        agent.state.messages = appendAssistantErrorMessageOnce(agent.state.messages, runError, session.model)
+      }
     }
     const forwardEvent = timedEvent.type === 'agent_end'
       ? {
@@ -1758,6 +1951,12 @@ export async function createAgent(sessionId, config = {}) {
       emitSessionEvent(session, forwardEvent)
     }
 
+    // OpenCode runtime usage snapshots are authoritative and lightweight; the
+    // debounced write keeps the latest usage durable without blocking the run.
+    if (event.type === 'acp_session_usage_update') {
+      scheduleSessionPersist(session)
+    }
+
     // Track status
     if (event.type === 'agent_start') {
       session.abortEndEmitted = false
@@ -1789,22 +1988,23 @@ 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 && (event.isInitialUserMessage === true || 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 })
             }
-            scheduleSessionTitleGeneration(session, event.message)
+            if (session.harness === AGENT_HARNESS_QUICKFORGE) 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
@@ -1848,7 +2048,7 @@ function sessionLastModifiedFromMessages(messages, fallback) {
  * Persist session data to storage.
  */
 async function persistSessionUnlocked(session) {
-  const { sessionId, agent, scope, projectId, source, channelId, channelName, title, titleSource, createdAt, lastModified: storedLastModified, status, startedAt, finishedAt, model, thinkingLevel, accessMode, yoloMode, contextCompaction } = session
+  const { sessionId, agent, harness, harnessSessionId, 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) {
@@ -1870,7 +2070,11 @@ async function persistSessionUnlocked(session) {
     id: sessionId,
     title,
     titleSource,
+    harness,
+    harnessSessionId: agent.harnessSessionId || harnessSessionId || undefined,
+    openCodeUsage: harness === AGENT_HARNESS_OPENCODE && agent.state.acpSession?.usage ? agent.state.acpSession.usage : undefined,
     model,
+    modelRef: modelRef || undefined,
     thinkingLevel,
     accessMode,
     yoloMode,
@@ -1930,6 +2134,8 @@ async function persistSessionUnlocked(session) {
     messageCount: messages.length,
     usage,
     thinkingLevel,
+    harness,
+    harnessSessionId: agent.harnessSessionId || harnessSessionId || undefined,
     accessMode,
     yoloMode,
     preview,
@@ -2063,7 +2269,13 @@ 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',
+    })
+  }
+  if (session.harness === AGENT_HARNESS_OPENCODE) {
+    throw Object.assign(new Error('OpenCode does not support rollback from a message position. This action is unavailable for OpenCode conversations.'), { statusCode: 409 })
   }
 
   const messages = Array.isArray(session.agent.state.messages) ? session.agent.state.messages : []
@@ -2074,7 +2286,14 @@ export async function rollbackSessionMessages(sessionId, rollbackMessageIndex) {
 
   const nextMessages = messages.slice(0, rollbackIndex)
   updateSessionMessages(session, nextMessages)
-  resetSessionCompaction(session)
+  const compactedUpToIndex = Number(session.contextCompaction?.compactedUpToIndex) || 0
+  if (rollbackIndex < compactedUpToIndex) {
+    // 撤回越过压缩点，摘要覆盖的历史被截断，压缩失效
+    resetSessionCompaction(session)
+  } else {
+    // 撤回发生在压缩点之后，摘要仍然有效，保留压缩上下文
+    session.lastTransformedContextMessages = null
+  }
   session.status = 'idle'
   session.finishedAt = new Date().toISOString()
   await persistSession(session)
@@ -2127,29 +2346,59 @@ 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, transientContextPrompt = null) {
+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
+  if (session.harness === AGENT_HARNESS_QUICKFORGE) await refreshSessionModelBinding(session)
 
   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 })
+    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)
+  if (session.harness === AGENT_HARNESS_QUICKFORGE) await refreshMemoryState(session)
   resetIdleTimer(session)
 
   // Build user message
   const initialUserMessage = typeof message === 'string'
     ? { role: 'user', content: message, timestamp: new Date().toISOString() }
     : message
-  const commandState = await resolveCommandState(session, initialUserMessage, promptCommand)
-  const userMessage = commandState.userMessage ?? initialUserMessage
+  const commandState = session.harness === AGENT_HARNESS_QUICKFORGE
+    ? await resolveCommandState(session, initialUserMessage, promptCommand)
+    : { userMessage: initialUserMessage }
+  const resolvedUserMessage = commandState.userMessage ?? initialUserMessage
+
+  if (session.harness === AGENT_HARNESS_OPENCODE) {
+    session.agent.validatePrompt(resolvedUserMessage)
+  }
 
   if (commandState.textResponse) {
     session.agent.state.messages = [
@@ -2176,6 +2425,10 @@ export async function runPrompt(sessionId, message, selectedCapabilities = [], p
     return compactSession(session, initialUserMessage, commandState.compact)
   }
 
+  const userMessage = session.harness === AGENT_HARNESS_QUICKFORGE
+    ? prepareCloudUserMessage(session, resolvedUserMessage)
+    : 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') {
@@ -2197,11 +2450,26 @@ export async function runPrompt(sessionId, message, selectedCapabilities = [], p
   // Fire and forget — events come through eventBus
   session.agent.prompt(userMessage).catch((err) => {
     logger.error(`Agent prompt error for session ${sessionId}:`, err, { sessionId })
-    const event = {
-      type: 'error',
-      error: err.message || 'Unknown error',
-    }
-    emitSessionEvent(session, event)
+    if (session.harness === AGENT_HARNESS_OPENCODE) return
+    const errorMessage = err.message || 'Unknown error'
+    // Surface the failure at the end of the conversation itself so the user
+    // sees the reason in the transcript, not only via toast/notification.
+    session.agent.state.messages = appendAssistantErrorMessageOnce(
+      session.agent.state.messages,
+      errorMessage,
+      session.model,
+    )
+    session.agent.state.errorMessage = errorMessage
+    session.agent.state.isStreaming = false
+    session.status = 'error'
+    session.finishedAt = new Date().toISOString()
+    const messages = session.agent.state.messages
+    emitSessionEvent(session, { type: 'message_end', messages })
+    emitSessionEvent(session, { type: 'error', error: errorMessage })
+    emitSessionEvent(session, { type: 'agent_end', messages, errorMessage, status: 'error' })
+    flushSessionPersist(session).catch((persistErr) =>
+      logger.error(`Failed to persist session ${sessionId} after prompt error:`, persistErr, { sessionId }),
+    )
   }).finally(() => {
     session.activeCommandName = null
     session.activeCommandPermissions = null
@@ -2221,14 +2489,22 @@ 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 (session.harness === AGENT_HARNESS_OPENCODE) {
+    throw Object.assign(new Error('OpenCode does not support retry from a message position. This action is unavailable for OpenCode conversations.'), { statusCode: 409 })
   }
+  if (modelAccessContext) session.modelAccessContext = modelAccessContext
+  await refreshSessionModelBinding(session)
 
   const messages = Array.isArray(session.agent.state.messages) ? session.agent.state.messages : []
 
@@ -2246,10 +2522,20 @@ 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)
+  const compactedUpToIndex = Number(session.contextCompaction?.compactedUpToIndex) || 0
+  if (lastUserIndex < compactedUpToIndex) {
+    // 重试点越过压缩点，摘要覆盖的历史被截断，压缩失效
+    resetSessionCompaction(session)
+  } else {
+    // 重试点位于压缩点之后，摘要仍然有效，保留压缩上下文
+    session.lastTransformedContextMessages = null
+  }
+  if (isManagedCloudModel(session.model) && logicalMessageId(continuedUserMessage)) {
+    await flushSessionPersist(session)
+  }
 
   resetIdleTimer(session)
   session.activeCommandName = commandState.commandName ?? null
@@ -2334,9 +2620,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 }
@@ -2351,9 +2637,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 }
@@ -2439,10 +2725,13 @@ export function getSessionState(sessionId) {
     source: session.source || undefined,
     channelId: session.channelId || undefined,
     channelName: session.channelName || undefined,
+    harness: session.harness,
+    harnessSessionId: session.agent.harnessSessionId || session.harnessSessionId || 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,
@@ -2459,6 +2748,7 @@ export function getSessionState(sessionId) {
     contextUsage: getSessionContextUsage(session),
     pendingToolApproval: getPendingApprovalForSession(session.sessionId),
     pendingAutoCompactApproval: getPendingAutoCompactApprovalForSession(session.sessionId),
+    acpSession: session.harness === AGENT_HARNESS_OPENCODE ? session.agent.state.acpSession : undefined,
     isStreaming: session.abortPending ? false : session.agent.state.isStreaming,
     errorMessage: session.agent.state.errorMessage,
   }
@@ -2477,6 +2767,8 @@ export function getSessionStatus(sessionId) {
     sessionId: session.sessionId,
     scope: session.scope,
     projectId: session.projectId,
+    harness: session.harness,
+    harnessSessionId: session.agent.harnessSessionId || session.harnessSessionId || undefined,
     source: session.source || undefined,
     channelId: session.channelId || undefined,
     channelName: session.channelName || undefined,
@@ -2548,6 +2840,7 @@ export async function destroyAgent(sessionId) {
 
   try {
     session.agent.abort()
+    if (session.harness === AGENT_HARNESS_OPENCODE) await session.agent.dispose?.()
   } catch {
     // ignore
   }
@@ -2597,6 +2890,8 @@ export async function restoreAgent(sessionId) {
       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',
@@ -2604,11 +2899,15 @@ export async function restoreAgent(sessionId) {
       createdAt: sessionData.createdAt,
       lastModified: sessionData.lastModified,
       contextCompaction: sessionData.contextCompaction || null,
+      harness: normalizeAgentHarness(sessionData.harness),
+      harnessSessionId: typeof sessionData.harnessSessionId === 'string' ? sessionData.harnessSessionId : null,
+      openCodeUsage: sessionData.openCodeUsage || null,
       idleRetention: sessionData.idleRetention || null,
       stateVersion: sessionData.stateVersion,
     })
   } catch (err) {
     logger.error(`Failed to restore agent ${sessionId}:`, err, { sessionId })
+    if (err?.statusCode === 503 || err?.errorCode === 'OPENCODE_UNAVAILABLE') throw err
     return null
   }
 }
@@ -2678,6 +2977,8 @@ export function listSessions() {
       scope: session.scope,
       status: session.status,
       title: session.title,
+      harness: session.harness,
+      harnessSessionId: session.agent.harnessSessionId || session.harnessSessionId || undefined,
       source: session.source || undefined,
       channelId: session.channelId || undefined,
       channelName: session.channelName || undefined,
@@ -2733,7 +3034,7 @@ export async function updateSessionAccessMode(sessionId, accessMode) {
 
   session.accessMode = normalizeAccessMode(accessMode, session.accessMode)
   session.yoloMode = yoloModeFromAccessMode(session.accessMode)
-  await rebuildSessionTools(session)
+  if (session.harness === AGENT_HARNESS_QUICKFORGE) await rebuildSessionTools(session)
   await persistSession(session)
 
   const state = getSessionState(sessionId)
@@ -2746,25 +3047,124 @@ export async function updateSessionYoloMode(sessionId, yoloMode) {
   return updateSessionAccessMode(sessionId, yoloMode ? AGENT_ACCESS_MODE_FULL_ACCESS : AGENT_ACCESS_MODE_DEFAULT)
 }
 
+function requireOpenCodeHarnessSession(sessionId) {
+  const session = agentSessions.get(sessionId)
+  if (!session) throw Object.assign(new Error('Session not found'), { statusCode: 404 })
+  if (session.harness !== AGENT_HARNESS_OPENCODE) {
+    throw Object.assign(new Error('Harness configuration is only available for OpenCode sessions.'), { statusCode: 409 })
+  }
+  return session
+}
+
+export async function updateSessionHarnessConfigOption(sessionId, configId, value) {
+  const session = requireOpenCodeHarnessSession(sessionId)
+  await session.agent.setConfigOption(configId, value)
+  const state = getSessionState(sessionId)
+  emitSessionEvent(session, { type: 'state', ...state })
+  return { sessionId, acpSession: state.acpSession }
+}
+
+export async function updateSessionHarnessMode(sessionId, modeId) {
+  const session = requireOpenCodeHarnessSession(sessionId)
+  await session.agent.setMode(modeId)
+  const state = getSessionState(sessionId)
+  emitSessionEvent(session, { type: 'state', ...state })
+  return { sessionId, acpSession: state.acpSession }
+}
+
+/**
+ * Fork the entire current OpenCode session into a new QuickForge session.
+ *
+ * OpenCode ACP only supports whole-session `session/fork` (no message-position
+ * fork), so the new agent is created with the full message history and
+ * `sourceHarnessSessionId` pointing at the current ACP session. The new session
+ * is persisted immediately and announced through the existing `session_forked`
+ * event so clients switch to it without a message-level fork semantic.
+ */
+export async function forkSession(sessionId) {
+  const session = requireOpenCodeHarnessSession(sessionId)
+  if (session.agent.state.isStreaming) {
+    throw Object.assign(new Error('Generation is still running. Stop it or wait until it finishes before forking the conversation.'), {
+      statusCode: 409,
+      errorCode: 'GENERATION_STILL_RUNNING_BEFORE_FORK',
+    })
+  }
+  const sourceHarnessSessionId = session.agent.harnessSessionId
+  if (!sourceHarnessSessionId) {
+    throw Object.assign(new Error('This OpenCode conversation has no ACP session to fork.'), { statusCode: 409 })
+  }
+  const messages = session.agent.state.messages
+  if (messages.length === 0) {
+    throw Object.assign(new Error('There is no conversation to fork yet.'), { statusCode: 400 })
+  }
+  const forkedSessionId = randomUUID()
+  const forkedSession = await createAgent(forkedSessionId, {
+    scope: session.scope,
+    projectId: session.projectId,
+    accessMode: session.accessMode,
+    yoloMode: session.yoloMode,
+    model: session.model,
+    modelRef: session.modelRef,
+    modelAccessContext: session.modelAccessContext,
+    resolvePersistedModel: true,
+    thinkingLevel: session.thinkingLevel,
+    messages,
+    title: session.title,
+    titleSource: session.titleSource === 'default' ? 'manual' : session.titleSource,
+    createdAt: new Date().toISOString(),
+    harness: session.harness,
+    sourceHarnessSessionId,
+    idleRetention: session.idleRetention || null,
+  })
+  updateSessionMessages(forkedSession, messages)
+  await persistSession(forkedSession)
+
+  emitSessionEvent(session, {
+    type: 'session_forked',
+    sourceSessionId: session.sessionId,
+    targetSessionId: forkedSessionId,
+    title: forkedSession.title,
+    createdAt: forkedSession.createdAt,
+    scope: forkedSession.scope,
+    projectId: forkedSession.projectId,
+    messages: forkedSession.agent.state.messages,
+  })
+  emitSessionEvent(forkedSession, { type: 'state', ...getSessionState(forkedSessionId) })
+  emitSessionEvent(forkedSession, { type: 'message_end', messages: forkedSession.agent.state.messages })
+  emitSessionEvent(forkedSession, { type: 'agent_end', messages: forkedSession.agent.state.messages })
+  return {
+    sessionId: forkedSessionId,
+    title: forkedSession.title,
+    createdAt: forkedSession.createdAt,
+    scope: forkedSession.scope,
+    projectId: forkedSession.projectId,
+  }
+}
+
 /**
  * Update the model for an existing session.
  * Syncs the model to both the session record (for persistence) and the agent state (for API calls).
  * 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 })
   }
+  if (session.harness === AGENT_HARNESS_OPENCODE) {
+    throw Object.assign(new Error('OpenCode manages its model natively.'), { statusCode: 409 })
+  }
   if (!model) {
     throw Object.assign(new Error('Missing model'), { statusCode: 400 })
   }
 
   session.model = model
+  session.modelRef = modelRef
+  session.resolvePersistedModel = true
   session.agent.state.model = model
 
-  return { sessionId, model }
+  return { sessionId, model, modelRef: modelRef || undefined }
 }
 
 /**
@@ -2775,6 +3175,9 @@ export function updateSessionThinkingLevel(sessionId, thinkingLevel) {
   if (!session) {
     throw Object.assign(new Error('Session not found'), { statusCode: 404 })
   }
+  if (session.harness === AGENT_HARNESS_OPENCODE) {
+    throw Object.assign(new Error('OpenCode manages its thinking level natively.'), { statusCode: 409 })
+  }
   if (!thinkingLevel) {
     throw Object.assign(new Error('Missing thinkingLevel'), { statusCode: 400 })
   }