@gotcos/glasses-server 6.2.1 → 6.5.0

package/server/lib/archive.ts

@@ -1,5 +1,5 @@
 // Daily archive system — persists conversation history beyond session TTL
-// Archives are stored as JSON files per day in server/data/archive/
+// Archives are stored as JSON files per day in ~/.cos-glasses/data/archive/
 // Each day's archive contains one or more "chats" (split by context breaks)
 // Summaries are generated via `claude -p --model sonnet`, budget-capped per day.
 
@@ -11,11 +11,11 @@ import { promisify } from 'node:util'
 import { logTokenAudit } from './token-audit.js'
 import { atomicWriteFileSync, loadJsonOrQuarantine } from './atomic-fs.js'
 import { consumeArchiveLLMBudget } from './archive-budget.js'
+import { mergeMediaAttachmentRefs, type MediaAttachmentRef } from '../../shared/media-attachment.js'
 
 const execAsync = promisify(exec)
 import type { Exchange } from './conversation.js'
 
-const __dirname = dirname(fileURLToPath(import.meta.url))
 import { dataPath } from './data-dir.js'
 const ARCHIVE_DIR = dataPath('archive')
 
@@ -87,7 +87,12 @@ export function loadArchive(date: string): DailyArchive | null {
     return null
   }
   if (result.status === 'missing') return null
-  return result.data
+  // Defense: a valid-JSON but wrong-shape day file (no chats[]) would make the
+  // readers throw 500 AND drop listArchiveDates into its catch → the whole
+  // Message History list vanishes on one bad file. Coerce to an empty day.
+  const data = result.data
+  if (data && !Array.isArray(data.chats)) data.chats = []
+  return data
 }
 
 function saveArchive(archive: DailyArchive): void {
@@ -344,20 +349,30 @@ export function getArchiveChats(date: string): ArchiveChatSummary[] {
   }))
 }
 
-/** Get paired Q&A messages for a specific chat within a day */
-export function getArchiveChatMessages(date: string, chatIndex: number): Array<{ query: string; text: string; timestamp: number }> {
+/** Get paired Q&A messages for a specific chat within a day. Request refs on
+ * the user turn and model-output refs on the assistant turn surface together. */
+export function getArchiveChatMessages(
+  date: string,
+  chatIndex: number,
+): Array<{ query: string; text: string; timestamp: number; attachments?: MediaAttachmentRef[] }> {
   const archive = loadArchive(date)
   if (!archive) return []
   const chat = archive.chats.find(c => c.id === chatIndex)
   if (!chat) return []
 
-  const messages: Array<{ query: string; text: string; timestamp: number }> = []
+  const messages: Array<{ query: string; text: string; timestamp: number; attachments?: MediaAttachmentRef[] }> = []
   for (let i = 0; i < chat.exchanges.length; i++) {
     const ex = chat.exchanges[i]
     if (ex.role === 'user') {
       const next = chat.exchanges[i + 1]
       if (next && next.role === 'assistant') {
-        messages.push({ query: ex.content, text: next.content, timestamp: next.timestamp })
+        const attachments = mergeMediaAttachmentRefs(ex.attachments, next.attachments)
+        messages.push({
+          query: ex.content,
+          text: next.content,
+          timestamp: next.timestamp,
+          ...(attachments.length > 0 ? { attachments } : {}),
+        })
         i++ // skip assistant
       }
     }
@@ -370,23 +385,26 @@ export function getArchiveChatMessages(date: string, chatIndex: number): Array<{
  *  (sessionId, timestamp) instead of bare timestamp (collision-prone). */
 export function getArchiveDayMessages(
   date: string,
-): Array<{ query: string; text: string; timestamp: number; chatIndex: number; sessionId: string }> {
+): Array<{ query: string; text: string; timestamp: number; chatIndex: number; sessionId: string; no?: number; attachments?: MediaAttachmentRef[] }> {
   const archive = loadArchive(date)
   if (!archive) return []
 
-  const messages: Array<{ query: string; text: string; timestamp: number; chatIndex: number; sessionId: string }> = []
+  const messages: Array<{ query: string; text: string; timestamp: number; chatIndex: number; sessionId: string; no?: number; attachments?: MediaAttachmentRef[] }> = []
   for (const chat of archive.chats) {
     for (let i = 0; i < chat.exchanges.length; i++) {
       const ex = chat.exchanges[i]
       if (ex.role === 'user') {
         const next = chat.exchanges[i + 1]
         if (next && next.role === 'assistant') {
+          const attachments = mergeMediaAttachmentRefs(ex.attachments, next.attachments)
           messages.push({
             query: ex.content,
             text: next.content,
             timestamp: next.timestamp,
             chatIndex: chat.id,
             sessionId: chat.sessionId,
+            ...((ex.globalMsgNum ?? next.globalMsgNum) != null ? { no: ex.globalMsgNum ?? next.globalMsgNum } : {}),
+            ...(attachments.length > 0 ? { attachments } : {}),
           })
           i++
         }

package/server/lib/claude-bridge.ts

@@ -8,26 +8,49 @@
 
 import { spawn } from 'node:child_process'
 import { writeFileSync, readFileSync, unlinkSync, existsSync } from 'node:fs'
-import { join } from 'node:path'
 import { appendFileSync } from 'node:fs'
-import crypto from 'node:crypto'
 import { COS_SCRIPTS_DIR } from './python-bridge.js'
+import { cleanupModelImageInputs, type ModelImageInput } from './model-image-input.js'
 import { cosBrainDir } from './launch-dir.js'
 import { logTokenAudit } from './token-audit.js'
 import { buildSystemPrompt, buildLightweightSystemPrompt, buildPrewarmSystemPrompt, getCachedContextInstant } from './context-builder.js'
-import { getHistory, addExchange, formatHistoryForPrompt, getOrCreateSession, isNewSession, markSessionNotified, getSessionModel, getSessionRaw, replaceLastExchangeWithSummary, type ModelPreference, type PromptReference } from './conversation.js'
+import { getHistory, addExchange, setExchangeAttachments, removeExchange, formatHistoryForPrompt, getOrCreateSession, isNewSession, markSessionNotified, getSessionModel, getSessionRaw, replaceLastExchangeWithSummary, type ModelPreference, type PromptReference } from './conversation.js'
 import { notifySessionStart, notifyExchange } from './telegram-notify.js'
-import { isClaudeModel, DEFAULT_MODEL, type ClaudeModelPreference } from '../../shared/model-preference.js'
+import {
+  isClaudeModel,
+  DEFAULT_MODEL,
+  resolveClaudeCliModelId,
+  resolveCliEffortFlag,
+  ULTRACODE_KEYWORD,
+  type ClaudeModelPreference,
+  type EffortPreference,
+} from '../../shared/model-preference.js'
 import {
   finishClaudeRun,
   getClaudeEffortLevel,
   startClaudeRun,
   updateClaudeRun,
+  type ClaudeRunStatus,
 } from './claude-run-ledger.js'
+import {
+  claudeToolInputPreview,
+  claudeToolResultPreviewLines,
+  type ActivityPreviewLine,
+} from './activity-preview.js'
+import {
+  createRunOutputImagePublisher,
+  isRunOutputImagePublisherCommand,
+  type RunOutputImageCollectionStats,
+} from './run-output-images.js'
+import {
+  MAX_ATTACHMENTS_PER_PROMPT,
+  type MediaAttachmentRef,
+} from '../../shared/media-attachment.js'
 
 // Inactivity = no stdout data for this long → kill (catches stalls)
 const INACTIVITY_BY_MODEL: Record<ClaudeModelPreference, number> = {
   opus: 180_000,    // 3 minutes — Opus can gap during tool use (WebSearch, reasoning)
+  fable: 180_000,   // 3 minutes — premium thinker, same gap tolerance as Opus
   sonnet: 30_000,   // 30 seconds
   haiku: 15_000,    // 15 seconds
 }
@@ -35,10 +58,12 @@ const INACTIVITY_BY_MODEL: Record<ClaudeModelPreference, number> = {
 // Wall clock max = absolute cap even if actively streaming
 const WALL_MAX_BY_MODEL: Record<ClaudeModelPreference, number> = {
   opus: 600_000,    // 10 minutes
+  fable: 900_000,   // 15 minutes — deepest model, longest single-turn runs
   sonnet: 120_000,  // 2 minutes
   haiku: 60_000,    // 1 minute
 }
 const WALL_MAX_EXTENDED_MS = 900_000     // 15 minutes for slash commands / heavy queries
+const WALL_MAX_DEEP_EFFORT_MS = 1_200_000 // 20 minutes for max/ultracode
 
 // Heartbeat = emit progress status during silence so client knows we're alive
 const HEARTBEAT_INTERVAL_MS = 6_000    // Every 6 seconds
@@ -166,7 +191,7 @@ export function logLatency(entry: LatencyEntry): void {
 }
 
 /**
- * Pre-warm the Claude CLI by running a minimal Haiku query at server boot.
+ * Pre-warm the Claude CLI by running a minimal default-model query at boot.
  * Captures the CLI session ID so the first real query can use --resume.
  * Called from index.ts alongside prewarmContext().
  */
@@ -183,7 +208,7 @@ export async function preWarmCLI(): Promise<void> {
 
     const proc = spawn('claude', [
       '-p',
-      '--model', DEFAULT_MODEL,  // Must match default query model — --resume inherits session model
+      '--model', resolveClaudeCliModelId(DEFAULT_MODEL),
       '--effort', getClaudeEffortLevel(),
       '--output-format', 'stream-json',
       '--verbose',
@@ -207,7 +232,7 @@ export async function preWarmCLI(): Promise<void> {
         if (!trimmed) continue
         try {
           const event = JSON.parse(trimmed)
-          if (event.type === 'result' && event.session_id) {
+          if (event.type === 'result' && event.session_id && !claudeResultErrorMessage(event)) {
             preWarmedCliSessionId = event.session_id
             scheduleCliSessionSave()
             const elapsed = Date.now() - start
@@ -222,7 +247,7 @@ export async function preWarmCLI(): Promise<void> {
       const elapsed = Date.now() - start
       logTokenAudit({
         source: 'g2-prewarm',
-        model: 'opus',
+        model: DEFAULT_MODEL,
         inputChars: 500,  // system prompt + "ready"
         outputChars: 50,
         durationMs: elapsed,
@@ -268,6 +293,8 @@ function isExtendedQuery(query: string): boolean {
 export interface ModelRunMetadata {
   codexRunId?: string
   codexThreadId?: string
+  outputAttachments?: MediaAttachmentRef[]
+  outputImageStats?: RunOutputImageCollectionStats
 }
 
 export interface StreamCallbacks {
@@ -275,9 +302,23 @@ export interface StreamCallbacks {
   onDone: (fullText: string, model: ModelPreference, cliSessionId?: string, metadata?: ModelRunMetadata) => void
   onError: (error: string) => void
   onToolStatus?: (toolName: string) => void
+  onActivityLine?: (line: ActivityPreviewLine) => void
   onStart?: (model: ModelPreference, sessionId: string, cliSessionId?: string, metadata?: ModelRunMetadata) => void
 }
 
+/** Claude CLI can emit `subtype: success` with `is_error: true`; the boolean
+ * is authoritative and must win before session ids or result text are saved. */
+export function claudeResultErrorMessage(event: any): string | null {
+  if (event?.type !== 'result' || (event?.is_error !== true && event?.subtype !== 'error')) return null
+  const raw = typeof event?.result === 'string' ? event.result
+    : typeof event?.error === 'string' ? event.error
+    : typeof event?.error?.message === 'string' ? event.error.message
+      : typeof event?.message === 'string' ? event.message
+        : ''
+  const detail = raw.replace(/\s+/g, ' ').trim().slice(0, 240)
+  return detail ? `claude-bridge: ${detail}` : 'claude-bridge: Claude CLI returned an error result.'
+}
+
 type Phase = 'context' | 'thinking' | 'searching' | 'generating'
 
 const PHASE_LABELS: Record<Phase, string> = {
@@ -294,6 +335,7 @@ const PHASE_LABELS: Record<Phase, string> = {
 export interface CallOptions {
   lightweight?: boolean  // Skip async context fetch — use cached context instantly (G2 speed path)
   abortSignal?: AbortSignal
+  effort?: EffortPreference
 }
 
 export async function callClaudeStreaming(
@@ -301,7 +343,7 @@ export async function callClaudeStreaming(
   sessionId: string | undefined,
   callbacks: StreamCallbacks,
   model?: ClaudeModelPreference,
-  images?: string[],
+  images?: ModelImageInput[],
   reference?: PromptReference,
   globalMsgNum?: number,
   options?: CallOptions,
@@ -314,9 +356,12 @@ export async function callClaudeStreaming(
   const historyPrompt = formatHistoryForPrompt(history, contextBreaks, reference)
   const contextPrompt = historyPrompt
 
-  // Resolve model: per-message > session preference > opus default
+  // Resolve model: per-message > session preference > public-server default.
   const sessionModel = getSessionModel(sid)
-  const resolvedModel: ClaudeModelPreference = model ?? (sessionModel && isClaudeModel(sessionModel) ? sessionModel : 'opus')
+  const resolvedModel: ClaudeModelPreference = model
+    ?? (sessionModel && isClaudeModel(sessionModel) ? sessionModel : DEFAULT_MODEL)
+  const resolvedEffort = options?.effort
+  const cliEffortFlag = resolvedEffort ? resolveCliEffortFlag(resolvedEffort) : getClaudeEffortLevel()
 
   // Notify client immediately — model is known before any async work
   // Pass existing CLI session ID if resuming (new sessions get it after first result)
@@ -327,41 +372,55 @@ export async function callClaudeStreaming(
   // Phase: context loading (skipped in lightweight mode)
   let phase: Phase = 'context'
 
+  const imageInputs: ModelImageInput[] = images ?? []
+  const imagePaths = imageInputs.map(input => input.path)
+  const outputImageBudget = Math.max(0, MAX_ATTACHMENTS_PER_PROMPT - imageInputs.length)
+  let outputImagePublisher: ReturnType<typeof createRunOutputImagePublisher> | null = null
+  if (!options?.lightweight && outputImageBudget > 0) {
+    try {
+      outputImagePublisher = createRunOutputImagePublisher({
+        sessionId: sid,
+        globalMsgNum,
+        maxImages: outputImageBudget,
+      })
+    } catch (err) {
+      console.error('[claude-bridge] output image publisher unavailable:', err)
+    }
+  }
+
   let systemPrompt: string
-  if (options?.lightweight) {
-    // G2 speed path — minimal system prompt, context only when needed
-    systemPrompt = buildLightweightSystemPrompt(query, contextPrompt)
-  } else {
-    callbacks.onToolStatus?.('Loading context...')
-    // Full COS path — async context with Python subprocess calls
-    systemPrompt = await buildSystemPrompt(contextPrompt)
+  try {
+    if (options?.lightweight) {
+      // G2 speed path — minimal system prompt, context only when needed
+      systemPrompt = buildLightweightSystemPrompt(query, contextPrompt)
+    } else {
+      callbacks.onToolStatus?.('Loading context...')
+      // Full COS path — async context with Python subprocess calls
+      systemPrompt = await buildSystemPrompt(contextPrompt)
+    }
+  } catch (err) {
+    outputImagePublisher?.cleanup()
+    throw err
   }
+  if (outputImagePublisher) systemPrompt = `${systemPrompt}\n\n${outputImagePublisher.promptInstructions}`
 
   // Phase: thinking (waiting for Claude to start)
   phase = 'thinking'
   callbacks.onToolStatus?.('Thinking...')
 
-  // ── Vision: save temp image files if provided ──
-  const imagePaths: string[] = []
-  if (images && images.length > 0) {
-    for (const img of images) {
-      const id = crypto.randomUUID().slice(0, 8)
-      const p = join('/tmp', `cos-vision-${id}.jpg`)
-      writeFileSync(p, Buffer.from(img, 'base64'))
-      imagePaths.push(p)
-    }
-  }
-
   // Check if this is the first query in a new session (before adding exchange)
   const isFirstQuery = isNewSession(sid)
 
   // Record user message (with [Photo]/[N Photos] prefix for vision queries)
   const photoPrefix = imagePaths.length === 1 ? '[Photo]' : imagePaths.length > 1 ? `[${imagePaths.length} Photos]` : ''
   const historyQuery = photoPrefix ? `${photoPrefix} ${query || 'What do you see?'}` : query
-  addExchange(sid, 'user', historyQuery, globalMsgNum)
+  const pendingUserExchange = addExchange(sid, 'user', historyQuery, globalMsgNum)
 
   // Vision queries need the Read tool to see the image files
-  const tools = imagePaths.length > 0 ? 'WebSearch,WebFetch,Read' : 'WebSearch,WebFetch'
+  const baseTools = imagePaths.length > 0 ? 'WebSearch,WebFetch,Read' : 'WebSearch,WebFetch'
+  const tools = outputImagePublisher
+    ? `${baseTools},${outputImagePublisher.claudeAllowedTool}`
+    : baseTools
 
   // Prepend image instruction when photos are attached
   let fullQuery: string
@@ -376,8 +435,8 @@ export async function callClaudeStreaming(
 
   // Check if we have a prior CLI session for this COS session.
   // If not, use the pre-warmed session (eliminates 2-15s cold start on first query).
-  if (!existingCliSession && preWarmedCliSessionId && resolvedModel === 'opus') {
-    // Only Opus queries consume the pre-warmed session (pre-warmed with Opus).
+  if (!existingCliSession && preWarmedCliSessionId && resolvedModel === DEFAULT_MODEL) {
+    // Only the default model consumes the pre-warmed session.
     // Hey Even (Haiku) cold-starts its own session to avoid model contamination.
     existingCliSession = preWarmedCliSessionId
     // Consume the pre-warmed session — next new session will cold start
@@ -392,8 +451,8 @@ export async function callClaudeStreaming(
 
   const args = [
     '-p',
-    '--model', resolvedModel,
-    '--effort', getClaudeEffortLevel(),
+    '--model', resolveClaudeCliModelId(resolvedModel),
+    '--effort', cliEffortFlag,
     '--output-format', 'stream-json',
     '--verbose',  // Required: stream-json requires --verbose
     '--dangerously-skip-permissions',  // Required: headless CLI mode with no TTY for user prompts
@@ -420,10 +479,14 @@ export async function callClaudeStreaming(
   // Strip CLAUDECODE env var so claude -p doesn't think it's nested
   const env = { ...process.env }
   delete env.CLAUDECODE
+  if (outputImagePublisher) Object.assign(env, outputImagePublisher.env)
   const cliCwd = COS_SCRIPTS_DIR ?? cosBrainDir() ?? process.cwd()
   const inactivityMs = INACTIVITY_BY_MODEL[resolvedModel]
   const defaultWallMax = WALL_MAX_BY_MODEL[resolvedModel]
-  const wallMax = isExtendedQuery(query) ? WALL_MAX_EXTENDED_MS : defaultWallMax
+  const effortWallMax = resolvedEffort === 'max' || resolvedEffort === 'ultracode'
+    ? Math.max(defaultWallMax, WALL_MAX_DEEP_EFFORT_MS)
+    : defaultWallMax
+  const wallMax = isExtendedQuery(query) ? Math.max(WALL_MAX_EXTENDED_MS, effortWallMax) : effortWallMax
   const startTime = Date.now()
   const run = startClaudeRun({
     cosSessionId: sid,
@@ -434,6 +497,8 @@ export async function callClaudeStreaming(
     timeoutMs: inactivityMs,
     wallMaxMs: wallMax,
     query: fullQuery,
+    effortLevel: resolvedEffort ?? getClaudeEffortLevel(),
+    cliModelId: resolveClaudeCliModelId(resolvedModel),
   })
 
   const proc = spawn('claude', args, {
@@ -448,19 +513,50 @@ export async function callClaudeStreaming(
   let finalized = false        // Guard against double onDone/onError
   let lastActivity = Date.now() // Tracks last stdout data for inactivity timeout
   let receivedStreamEvents = false  // Track if CLI emits stream_event (vs older assistant-only format)
+  const toolInputs = new Map<number, { name: string; json: string }>()
 
   function cleanupImages() {
-    for (const p of imagePaths) {
-      try { unlinkSync(p) } catch { /* ignore */ }
-    }
+    cleanupModelImageInputs(imageInputs)
   }
 
-  function finalize(text: string) {
+  async function finalize(text: string) {
     if (finalized) return
     finalized = true
     cleanup()
     cleanupImages()
 
+    // Persist text before output-image normalization. A daemon crash during
+    // finalization cannot erase an otherwise successful answer.
+    const assistantExchange = addExchange(sid, 'assistant', text, globalMsgNum)
+    if (imagePaths.length > 0) {
+      replaceLastExchangeWithSummary(sid, query, text, imagePaths.length)
+    }
+
+    let outputAttachments: MediaAttachmentRef[] = []
+    let outputImageStats: RunOutputImageCollectionStats | undefined
+    if (outputImagePublisher) {
+      callbacks.onToolStatus?.('Preparing images...')
+      const preparingHeartbeat = setInterval(() => callbacks.onToolStatus?.('Preparing images...'), HEARTBEAT_INTERVAL_MS)
+      preparingHeartbeat.unref?.()
+      try {
+        outputAttachments = await outputImagePublisher.collect()
+      } catch (err) {
+        console.error('[claude-bridge] output image collection failed:', err)
+      } finally {
+        clearInterval(preparingHeartbeat)
+        outputImageStats = outputImagePublisher.stats
+        outputImagePublisher.cleanup()
+      }
+      if (outputAttachments.length > 0) {
+        setExchangeAttachments(sid, assistantExchange, outputAttachments)
+      }
+      if (outputImageStats && outputImageStats.rejected > 0) {
+        callbacks.onToolStatus?.(outputImageStats.attached > 0
+          ? 'Some images could not be attached'
+          : 'Image attachment unavailable')
+      }
+    }
+
     // Token audit — log every completed claude -p call
     const totalMs = Date.now() - startTime
     const inputEstimate = systemPrompt.length + fullQuery.length + contextPrompt.length
@@ -473,14 +569,6 @@ export async function callClaudeStreaming(
       caller: options?.lightweight ? 'voice_query' : 'full_query',
     })
 
-    addExchange(sid, 'assistant', text, globalMsgNum)
-
-    // Replace photo exchanges with condensed summaries to prevent context rot
-    // while preserving enough context for follow-up questions
-    if (imagePaths.length > 0) {
-      replaceLastExchangeWithSummary(sid, query, text, imagePaths.length)
-    }
-
     finishClaudeRun(run.runId, {
       status: 'completed',
       startedAtMs: startTime,
@@ -488,7 +576,10 @@ export async function callClaudeStreaming(
       exitCode: 0,
     })
 
-    callbacks.onDone(text, resolvedModel, cliSessionMap.get(resolvedCliKey))
+    callbacks.onDone(text, resolvedModel, cliSessionMap.get(resolvedCliKey), {
+      ...(outputAttachments.length > 0 ? { outputAttachments } : {}),
+      ...(outputImageStats && outputImageStats.published > 0 ? { outputImageStats } : {}),
+    })
 
     // Telegram notifications — fire and forget
     if (isFirstQuery) {
@@ -498,13 +589,23 @@ export async function callClaudeStreaming(
     notifyExchange(sid, query, text)
   }
 
-  function finalizeError(msg: string, exitCode?: number | null) {
+  function finalizeError(
+    msg: string,
+    exitCode?: number | null,
+    status: Exclude<ClaudeRunStatus, 'running'> = 'failed',
+  ) {
     if (finalized) return
     finalized = true
     cleanup()
     cleanupImages()
+    outputImagePublisher?.cleanup()
+    removeExchange(sid, pendingUserExchange)
+    // A failed/cancelled resumed CLI turn may already exist in Claude's own
+    // session transcript even though COS history was rolled back. Never resume
+    // that potentially contaminated CLI session on retry.
+    if (cliSessionMap.delete(resolvedCliKey)) scheduleCliSessionSave()
     finishClaudeRun(run.runId, {
-      status: 'failed',
+      status,
       startedAtMs: startTime,
       error: msg,
       exitCode,
@@ -512,6 +613,12 @@ export async function callClaudeStreaming(
     callbacks.onError(msg)
   }
 
+  function handleAbort() {
+    if (finalized) return
+    proc.kill('SIGTERM')
+    finalizeError('claude-bridge: client disconnected before Claude completed.', null, 'client_disconnected')
+  }
+
   // ─── Heartbeat: emit phase status during silence ───
 
   const heartbeat = setInterval(() => {
@@ -548,7 +655,7 @@ export async function callClaudeStreaming(
     proc.kill('SIGTERM')
     if (fullText) {
       // Got partial output — deliver what we have
-      finalize(fullText)
+      void finalize(fullText)
     } else {
       finalizeError(`Wall clock limit reached (${wallMax / 1000}s). Process killed.`)
     }
@@ -558,6 +665,7 @@ export async function callClaudeStreaming(
     clearInterval(heartbeat)
     clearTimeout(inactivityTimer)
     clearTimeout(wallTimer)
+    options?.abortSignal?.removeEventListener('abort', handleAbort)
   }
 
   // ─── Process stdout ───
@@ -577,7 +685,9 @@ export async function callClaudeStreaming(
       try {
         const event = JSON.parse(trimmed)
 
-        if (event.type === 'stream_event') {
+        if (event.type === 'system' && event.subtype === 'init' && typeof event.model === 'string') {
+          updateClaudeRun(run.runId, { resolvedModelId: event.model })
+        } else if (event.type === 'stream_event') {
           // Real-time token streaming — fires every few tokens during generation
           receivedStreamEvents = true
           const inner = event.event
@@ -590,6 +700,7 @@ export async function callClaudeStreaming(
             callbacks.onToolStatus?.('Reasoning...')
           } else if (inner?.type === 'content_block_start' && inner.content_block?.type === 'tool_use' && inner.content_block.name) {
             const toolName = inner.content_block.name
+            if (typeof inner.index === 'number') toolInputs.set(inner.index, { name: toolName, json: '' })
             if (toolName === 'WebSearch' || toolName === 'WebFetch') {
               phase = 'searching'
             }
@@ -597,6 +708,18 @@ export async function callClaudeStreaming(
             if (toolName === 'Read') {
               callbacks.onToolStatus?.('Analyzing photo...')
             }
+          } else if (inner?.type === 'content_block_delta' && inner.delta?.type === 'input_json_delta' && typeof inner.index === 'number') {
+            const current = toolInputs.get(inner.index)
+            if (current && typeof inner.delta.partial_json === 'string') current.json += inner.delta.partial_json
+          } else if (inner?.type === 'content_block_stop' && typeof inner.index === 'number') {
+            const current = toolInputs.get(inner.index)
+            if (current) {
+              if (!isRunOutputImagePublisherCommand(current.json)) {
+                const preview = claudeToolInputPreview(current.name, current.json)
+                if (preview) callbacks.onActivityLine?.(preview)
+              }
+              toolInputs.delete(inner.index)
+            }
           }
         } else if (event.type === 'assistant') {
           // Fallback: only used if CLI doesn't emit stream_events (older CLI compatibility)
@@ -626,7 +749,14 @@ export async function callClaudeStreaming(
               callbacks.onChunk(text)
             }
           }
+        } else if (event.type === 'user') {
+          for (const preview of claudeToolResultPreviewLines(event)) callbacks.onActivityLine?.(preview)
         } else if (event.type === 'result') {
+          const resultError = claudeResultErrorMessage(event)
+          if (resultError) {
+            finalizeError(resultError)
+            continue
+          }
           // Capture CLI session ID for future --resume (avoids cold start on next query)
           if (event.session_id) {
             cliSessionMap.set(resolvedCliKey, event.session_id)
@@ -634,7 +764,7 @@ export async function callClaudeStreaming(
             updateClaudeRun(run.runId, { cliSessionId: event.session_id })
           }
           // Final result — use accumulated text (more reliable than result.result)
-          finalize(fullText || event.result || '')
+          void finalize(fullText || event.result || '')
         }
         // tool_use/tool_result/other events still reset inactivity (we got stdout data)
       } catch {
@@ -655,7 +785,12 @@ export async function callClaudeStreaming(
       try {
         const event = JSON.parse(buffer.trim())
         if (event.type === 'result') {
-          finalize(fullText || event.result || '')
+          const resultError = claudeResultErrorMessage(event)
+          if (resultError) {
+            finalizeError(resultError, code)
+            return
+          }
+          void finalize(fullText || event.result || '')
           return
         }
       } catch { /* ignore */ }
@@ -665,19 +800,39 @@ export async function callClaudeStreaming(
       finalizeError(`claude-bridge: exit ${code} — ${stderr.trim().slice(0, 200)}`, code)
     } else if (fullText) {
       // If we got text but no explicit result event, still finalize
-      finalize(fullText)
+      void finalize(fullText)
     } else {
-      cleanup() // No output, no error — just clean up timers
+      finalizeError('claude-bridge: Claude completed without a response.', code)
     }
   })
 
   proc.on('error', (err) => {
     finalizeError(`claude-bridge: ${err.message}`, null)
   })
+  proc.stdin.on('error', (err) => {
+    finalizeError(`claude-bridge: stdin failed — ${err.message}`, null)
+  })
 
-  // Send query via stdin (fullQuery includes image instruction when vision)
-  proc.stdin.write(fullQuery)
-  proc.stdin.end()
+  if (options?.abortSignal) {
+    if (options.abortSignal.aborted) {
+      handleAbort()
+      return sid
+    }
+    options.abortSignal.addEventListener('abort', handleAbort, { once: true })
+  }
+
+  // Ultracode is a CLI-only orchestration keyword; history/chat keeps the
+  // original user text so the keyword never appears on the lens.
+  const cliQuery = resolvedEffort === 'ultracode'
+    ? `${fullQuery}\n\n${ULTRACODE_KEYWORD}`
+    : fullQuery
+  try {
+    proc.stdin.write(cliQuery)
+    proc.stdin.end()
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    finalizeError(`claude-bridge: stdin failed — ${message}`, null)
+  }
 
   return sid
 }

package/server/lib/claude-run-ledger.ts

@@ -33,7 +33,9 @@ export interface ClaudeRunRecord {
   updatedAt: string
   model: ClaudeModelPreference
   cliCommand: string
-  effortLevel: ClaudeEffortLevel
+  effortLevel: ClaudeEffortLevel | 'ultracode'
+  cliModelId?: string
+  resolvedModelId?: string
   cwd: string
   resumed: boolean
   trustMode: 'full-access'
@@ -211,6 +213,8 @@ export function startClaudeRun(input: {
   timeoutMs: number
   wallMaxMs: number
   query: string
+  effortLevel?: ClaudeEffortLevel | 'ultracode'
+  cliModelId?: string
 }): ClaudeRunRecord {
   const now = new Date().toISOString()
   const run: ClaudeRunRecord = {
@@ -222,7 +226,8 @@ export function startClaudeRun(input: {
     updatedAt: now,
     model: input.model,
     cliCommand: 'claude -p',
-    effortLevel: getClaudeEffortLevel(),
+    effortLevel: input.effortLevel ?? getClaudeEffortLevel(),
+    cliModelId: input.cliModelId,
     cwd: input.cwd,
     resumed: input.resumed,
     trustMode: 'full-access',