@shawnstack/quickforge 1.7.3 → 1.7.4

package/server/agent-manager.mjs

@@ -28,6 +28,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,6 +199,7 @@ 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 ABORT_IDLE_WAIT_TIMEOUT_MS = 3000
 const SUBAGENT_DEFAULT_TIMEOUT_MS = 30 * 60 * 1000
 const SUBAGENT_TRACE_THROTTLE_MS = 150
 
@@ -429,6 +431,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--) {
@@ -1319,6 +1386,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 +1425,7 @@ async function transformSessionContext(session, messages, signal) {
   session.lastTransformedContextMessages = transformedMessages
   return applyActiveCapabilityPrompt(
     applyActiveCommandPrompt(compactedContextMessages(transformedMessages), session?.activeCommandPrompt),
-    session?.activeCapabilityPrompt,
+    activeTurnContextPrompt(session),
   )
 }
 
@@ -1432,6 +1505,9 @@ export async function createAgent(sessionId, config = {}) {
   const {
     scope = 'global',
     projectId = null,
+    source = null,
+    channelId = null,
+    channelName = null,
     accessMode: rawAccessMode,
     yoloMode = false,
     model = null,
@@ -1600,6 +1676,9 @@ 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,
@@ -1617,6 +1696,8 @@ export async function createAgent(sessionId, config = {}) {
     activeCommandName: null,
     activeCommandPermissions: null,
     activeCommandPrompt: null,
+    activeCapabilityPrompt: null,
+    activeTransientContextPrompt: null,
     eventBus,
     idleTimer: null,
     persistTimer: null,
@@ -1625,6 +1706,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 +1722,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 +1733,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 +1753,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 +1775,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()
@@ -1758,7 +1848,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, thinkingLevel, accessMode, yoloMode, contextCompaction } = session
   const messages = agent.state.messages
 
   if (messages.length === 0) {
@@ -1789,6 +1879,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 +1935,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 +1952,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) {
@@ -2020,16 +2131,13 @@ function scheduleSessionTitleGeneration(session, userMessage) {
  * 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) {
+  let session = await syncSessionFromStorage(sessionId)
   if (!session) {
     throw Object.assign(new Error('Session not found'), { statusCode: 404 })
   }
 
-  if (session.agent.state.isStreaming) {
+  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 })
   }
 
@@ -2082,6 +2190,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 +2207,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 }
@@ -2181,7 +2293,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 +2313,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',
@@ -2243,6 +2368,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,10 +2431,14 @@ 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,
@@ -2268,12 +2453,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 +2477,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 +2487,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,6 +2591,9 @@ 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,
@@ -2486,6 +2678,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,
     })
   }

package/server/ai-http-logger.mjs

@@ -3,7 +3,10 @@ import path from 'node:path'
 import { AsyncLocalStorage } from 'node:async_hooks'
 import { randomUUID } from 'node:crypto'
 import { streamSimple } from '@earendil-works/pi-ai/compat'
-import { withDefaultAiProviderOptions } from './ai-provider-options.mjs'
+import {
+  DEFAULT_AI_STREAM_DEADLINE_MS,
+  withDefaultAiProviderOptions,
+} from './ai-provider-options.mjs'
 import { logsDir } from './storage.mjs'
 
 const PATCH_MARKER = Symbol.for('quickforge.aiHttpLogger.fetchPatched')
@@ -206,18 +209,72 @@ export function installAiHttpLogger() {
   globalThis[PATCH_MARKER] = true
 }
 
+function combineAbortSignals(parentSignal, deadlineSignal) {
+  if (!parentSignal) return deadlineSignal
+  if (typeof AbortSignal.any === 'function') return AbortSignal.any([parentSignal, deadlineSignal])
+
+  const controller = new AbortController()
+  const abort = () => controller.abort()
+  if (parentSignal.aborted || deadlineSignal.aborted) {
+    controller.abort()
+  } else {
+    parentSignal.addEventListener('abort', abort, { once: true })
+    deadlineSignal.addEventListener('abort', abort, { once: true })
+  }
+  return controller.signal
+}
+
+function wrapStreamWithDeadline(stream, deadlineController, deadlineMs) {
+  let timer
+  const deadlinePromise = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      deadlineController.abort()
+      reject(new Error(`AI stream timed out after ${deadlineMs}ms`))
+    }, deadlineMs)
+    timer.unref?.()
+  })
+  const resultPromise = Promise.race([stream.result(), deadlinePromise])
+    .finally(() => clearTimeout(timer))
+  resultPromise.catch(() => {})
+
+  return {
+    result: () => resultPromise,
+    [Symbol.asyncIterator]() {
+      const iterator = stream[Symbol.asyncIterator]()
+      return {
+        next: () => Promise.race([iterator.next(), deadlinePromise]),
+        return: async () => {
+          clearTimeout(timer)
+          if (typeof iterator.return === 'function') return iterator.return()
+          return { value: undefined, done: true }
+        },
+      }
+    },
+  }
+}
+
 export function streamSimpleWithAiHttpLogging(model, context, options = {}) {
   const providerOptions = withDefaultAiProviderOptions(options)
-  if (!aiHttpLogEnabled) return streamSimple(model, context, providerOptions)
-
-  const traceContext = {
-    traceId: randomUUID(),
-    sessionId: providerOptions.sessionId,
-    purpose: providerOptions.metadata?.quickforgePurpose || 'chat',
-    provider: model?.provider,
-    api: model?.api,
-    model: model?.id,
+  const deadlineMs = Number.isFinite(providerOptions.deadlineMs)
+    ? Math.max(1, providerOptions.deadlineMs)
+    : DEFAULT_AI_STREAM_DEADLINE_MS
+  const deadlineController = new AbortController()
+  const effectiveOptions = {
+    ...providerOptions,
+    signal: combineAbortSignals(providerOptions.signal, deadlineController.signal),
   }
+  delete effectiveOptions.deadlineMs
+
+  const stream = aiHttpLogEnabled
+    ? aiHttpContext.run({
+        traceId: randomUUID(),
+        sessionId: effectiveOptions.sessionId,
+        purpose: effectiveOptions.metadata?.quickforgePurpose || 'chat',
+        provider: model?.provider,
+        api: model?.api,
+        model: model?.id,
+      }, () => streamSimple(model, context, effectiveOptions))
+    : streamSimple(model, context, effectiveOptions)
 
-  return aiHttpContext.run(traceContext, () => streamSimple(model, context, providerOptions))
+  return wrapStreamWithDeadline(stream, deadlineController, deadlineMs)
 }

package/server/ai-provider-options.mjs

@@ -1,8 +1,11 @@
 export const DEFAULT_AI_MAX_RETRIES = 3
+export const DEFAULT_AI_HTTP_TIMEOUT_MS = 2 * 60 * 1000
+export const DEFAULT_AI_STREAM_DEADLINE_MS = 5 * 60 * 1000
 
 export function withDefaultAiProviderOptions(options = {}) {
   return {
     maxRetries: DEFAULT_AI_MAX_RETRIES,
+    timeoutMs: DEFAULT_AI_HTTP_TIMEOUT_MS,
     ...options,
   }
 }

package/server/channels/channel-logs.mjs

@@ -0,0 +1,13 @@
+import path from 'node:path'
+
+function safeChannelId(channelId) {
+  const safeId = String(channelId || '')
+    .trim()
+    .replace(/[^a-zA-Z0-9_-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+  return safeId || 'channel'
+}
+
+export function channelLogsDirectory(logsDir, channelId) {
+  return path.join(path.resolve(logsDir), 'channels', safeChannelId(channelId))
+}

package/server/channels/event-relay.mjs

@@ -0,0 +1,33 @@
+const CHANNEL_EVENTS_URL_ENV = 'QUICKFORGE_CHANNEL_EVENTS_URL'
+const CHANNEL_EVENT_ACTION = 'channel-event'
+const RELAY_TIMEOUT_MS = 3000
+
+export async function publishChannelSessionChanged(event) {
+  const url = process.env[CHANNEL_EVENTS_URL_ENV]
+  if (!url) return false
+
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), RELAY_TIMEOUT_MS)
+  timer.unref?.()
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'x-quickforge-action': CHANNEL_EVENT_ACTION,
+      },
+      body: JSON.stringify({
+        ...event,
+        type: 'sessions-changed',
+        timestamp: event.timestamp || new Date().toISOString(),
+      }),
+      signal: controller.signal,
+    })
+    return response.ok
+  } catch {
+    return false
+  } finally {
+    clearTimeout(timer)
+  }
+}

package/server/channels/process-channel.mjs

@@ -1,7 +1,11 @@
 /* eslint-disable no-control-regex -- ANSI escape matching intentionally includes ESC. */
 import { spawn } from 'node:child_process'
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
 import { EventEmitter } from 'node:events'
 import { setTimeout as delay } from 'node:timers/promises'
+import { channelLogsDirectory } from './channel-logs.mjs'
+import { logger } from '../utils/logger.mjs'
 
 const DEFAULT_LOG_LIMIT = 300
 const STOP_TIMEOUT_MS = 5000
@@ -55,6 +59,9 @@ export class ProcessChannelProvider extends EventEmitter {
     super()
     this.definition = definition
     this.logLimit = options.logLimit || DEFAULT_LOG_LIMIT
+    this.logsDir = options.logsDir
+    this.logWriteErrorReported = false
+    this.logWritePromise = Promise.resolve()
     this.status = 'stopped'
     this.process = null
     this.pid = null
@@ -118,6 +125,27 @@ export class ProcessChannelProvider extends EventEmitter {
     this.emitEvent('status', { status, snapshot: this.snapshot() })
   }
 
+  persistLog(entry) {
+    if (!this.logsDir) return
+    const directory = channelLogsDirectory(this.logsDir, this.definition.id)
+    const filePath = path.join(directory, `channel-${entry.time.slice(0, 10)}.log`)
+    const line = `${JSON.stringify({ time: entry.time, stream: entry.stream, text: entry.text })}\n`
+    this.logWritePromise = this.logWritePromise
+      .then(() => fs.mkdir(directory, { recursive: true }))
+      .then(() => fs.appendFile(filePath, line, 'utf8'))
+      .then(() => {
+        this.logWriteErrorReported = false
+      })
+      .catch((error) => {
+        if (this.logWriteErrorReported) return
+        this.logWriteErrorReported = true
+        logger.warn('Failed to persist channel log.', {
+          channelId: this.definition.id,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      })
+  }
+
   addLog(stream, text) {
     if (!text) return
     const entry = {
@@ -131,6 +159,7 @@ export class ProcessChannelProvider extends EventEmitter {
       this.logs.splice(0, this.logs.length - this.logLimit)
     }
     this.emitEvent('log', { log: entry })
+    this.persistLog(entry)
   }
 
   addProcessText(stream, text) {