@swarmclawai/swarmclaw 1.2.0 → 1.2.2

package/src/lib/chat/chat-streaming-state.test.ts

@@ -43,16 +43,17 @@ describe('chat-streaming-state', () => {
         localStreaming: true,
         hasLiveArtifacts: true,
         assistantRenderId: 'render-1',
+        showLiveRow: true,
+        syntheticAssistant: messages[1],
       } as StreamingAwareMessageListOptions),
       [
         { role: 'user', text: 'hello', time: 1 },
         {
           role: 'assistant',
-          text: 'final answer',
-          time: 0,
+          text: 'partial',
+          time: 2,
           kind: 'chat',
           streaming: true,
-          thinking: 'working...',
           clientRenderId: 'render-1',
         },
       ],
@@ -69,6 +70,7 @@ describe('chat-streaming-state', () => {
         localStreaming: true,
         hasLiveArtifacts: true,
         assistantRenderId: 'render-2',
+        showLiveRow: true,
       } as StreamingAwareMessageListOptions),
       [
         { role: 'user', text: 'hello', time: 1 },
@@ -84,6 +86,43 @@ describe('chat-streaming-state', () => {
     )
   })
 
+  it('can show a synthetic live row for server-driven runs using the latest persisted streaming artifact', () => {
+    const messages: Message[] = [
+      { role: 'user', text: 'queued follow-up', time: 1 },
+      {
+        role: 'assistant',
+        text: 'Drafting the handoff now.',
+        time: 2,
+        streaming: true,
+        thinking: 'Collecting the completion details',
+        toolEvents: [{ name: 'send_file', input: '{}', output: '/api/uploads/deck.pdf' }],
+      },
+    ]
+
+    assert.deepEqual(
+      buildStreamingAwareMessageList(messages, {
+        localStreaming: true,
+        hasLiveArtifacts: false,
+        assistantRenderId: 'render-server',
+        showLiveRow: true,
+        syntheticAssistant: messages[1],
+      }),
+      [
+        { role: 'user', text: 'queued follow-up', time: 1 },
+        {
+          role: 'assistant',
+          text: 'Drafting the handoff now.',
+          time: 2,
+          kind: 'chat',
+          streaming: true,
+          thinking: 'Collecting the completion details',
+          toolEvents: [{ name: 'send_file', input: '{}', output: '/api/uploads/deck.pdf' }],
+          clientRenderId: 'render-server',
+        },
+      ],
+    )
+  })
+
   it('replaces trailing streaming assistant messages with the completed assistant message', () => {
     const messages: Message[] = [
       { role: 'user', text: 'hello', time: 1 },

package/src/lib/chat/chat-streaming-state.ts

@@ -10,6 +10,8 @@ export interface StreamingAwareMessageListOptions {
   localStreaming: boolean
   hasLiveArtifacts: boolean
   assistantRenderId?: string | null
+  showLiveRow?: boolean
+  syntheticAssistant?: Partial<Message> | null
 }
 
 function isStreamingAssistantMessage(
@@ -27,13 +29,13 @@ function isStreamingAssistantMessage(
 
 export function shouldHidePersistedStreamingAssistantMessage(
   message: Message,
-  opts: { localStreaming: boolean; hasLiveArtifacts: boolean },
+  opts: { localStreaming: boolean; hasLiveArtifacts: boolean; showLiveRow?: boolean },
 ): boolean {
+  const showLiveRow = opts.showLiveRow ?? (opts.localStreaming && opts.hasLiveArtifacts)
   return (
-    opts.localStreaming
+    showLiveRow
     && message.role === 'assistant'
     && message.streaming === true
-    && opts.hasLiveArtifacts
   )
 }
 
@@ -41,22 +43,32 @@ export function buildStreamingAwareMessageList(
   messages: Message[],
   opts: StreamingAwareMessageListOptions,
 ): Message[] {
-  const nextMessages = opts.localStreaming && opts.hasLiveArtifacts
+  const showLiveRow = opts.showLiveRow ?? (opts.localStreaming && opts.hasLiveArtifacts)
+  const nextMessages = showLiveRow
     ? messages.filter((message) => !shouldHidePersistedStreamingAssistantMessage(message, opts))
     : messages
 
-  if (!opts.localStreaming || !opts.hasLiveArtifacts || !opts.assistantRenderId) {
+  if (!showLiveRow || !opts.assistantRenderId) {
     return nextMessages
   }
 
   const syntheticAssistantMessage: Message = {
     role: 'assistant',
-    text: '',
-    time: 0,
-    kind: 'chat',
+    text: typeof opts.syntheticAssistant?.text === 'string' ? opts.syntheticAssistant.text : '',
+    time: typeof opts.syntheticAssistant?.time === 'number' ? opts.syntheticAssistant.time : 0,
+    kind: opts.syntheticAssistant?.kind || 'chat',
     streaming: true,
     clientRenderId: opts.assistantRenderId,
   }
+  if (typeof opts.syntheticAssistant?.thinking === 'string') {
+    syntheticAssistantMessage.thinking = opts.syntheticAssistant.thinking
+  }
+  if (Array.isArray(opts.syntheticAssistant?.toolEvents)) {
+    syntheticAssistantMessage.toolEvents = opts.syntheticAssistant.toolEvents
+  }
+  if (opts.syntheticAssistant?.source) {
+    syntheticAssistantMessage.source = opts.syntheticAssistant.source
+  }
 
   return [
     ...nextMessages,

package/src/lib/chat/chat.ts

@@ -53,10 +53,26 @@ export async function streamChat(
   const reader = res.body.getReader()
   const decoder = new TextDecoder()
   let buf = ''
+  const STREAM_IDLE_TIMEOUT_MS = 300_000
 
   while (true) {
-    const { done, value } = await reader.read()
-    if (done) break
+    let timeoutId: ReturnType<typeof setTimeout> | undefined
+    let timedOut = false
+    const idleAbort = new Promise<{ done: true; value: undefined }>((resolve) => {
+      timeoutId = setTimeout(() => {
+        timedOut = true
+        resolve({ done: true, value: undefined })
+      }, STREAM_IDLE_TIMEOUT_MS)
+    })
+    const { done, value } = await Promise.race([reader.read(), idleAbort])
+    clearTimeout(timeoutId)
+    if (done) {
+      if (timedOut) {
+        onEvent?.({ t: 'err', text: 'Stream timed out (no data for 5 minutes)' })
+        reader.cancel().catch(() => {})
+      }
+      break
+    }
     buf += decoder.decode(value, { stream: true })
     const lines = buf.split('\n')
     buf = lines.pop() || ''

package/src/lib/chat/queued-message-queue.test.ts

@@ -27,7 +27,7 @@ describe('queued-message-queue', () => {
   it('replaces queued items only for the requested session', () => {
     const replaced = replaceQueuedMessagesForSession(queue, 'session-a', [
       { runId: 'q4', sessionId: 'session-a', text: 'replacement', queuedAt: 4, position: 1 },
-    ])
+    ], { activeRunId: null })
     assert.deepEqual(
       listQueuedMessagesForSession(replaced, 'session-a').map((item) => item.runId),
       ['q4'],
@@ -38,6 +38,28 @@ describe('queued-message-queue', () => {
     )
   })
 
+  it('keeps only the newly active run as a sending placeholder when it disappears from the queue snapshot', () => {
+    const replaced = replaceQueuedMessagesForSession(queue, 'session-a', [
+      { runId: 'q3', sessionId: 'session-a', text: 'second a', queuedAt: 3, position: 1 },
+    ], { activeRunId: 'q1' })
+
+    assert.deepEqual(
+      listQueuedMessagesForSession(replaced, 'session-a').map((item) => [item.runId, item.sending === true]),
+      [['q1', true], ['q3', false]],
+    )
+  })
+
+  it('drops missing stale queue rows that are not the active run', () => {
+    const replaced = replaceQueuedMessagesForSession(queue, 'session-a', [
+      { runId: 'q3', sessionId: 'session-a', text: 'second a', queuedAt: 3, position: 1 },
+    ], { activeRunId: 'run-other' })
+
+    assert.deepEqual(
+      listQueuedMessagesForSession(replaced, 'session-a').map((item) => item.runId),
+      ['q3'],
+    )
+  })
+
   it('removes queued items by stable id', () => {
     assert.deepEqual(removeQueuedMessageById(queue, 'q2').map((item) => item.runId), ['q1', 'q3'])
   })

package/src/lib/chat/queued-message-queue.ts

@@ -41,18 +41,27 @@ export function snapshotToQueuedMessages(snapshot: SessionQueueSnapshot): Queued
   return snapshot.items.map((item) => ({ ...item }))
 }
 
+interface ReplaceQueuedMessagesOptions {
+  activeRunId?: string | null
+}
+
 export function replaceQueuedMessagesForSession(
   queue: QueuedSessionMessage[],
   sessionId: string,
   nextItems: QueuedSessionMessage[],
+  options: ReplaceQueuedMessagesOptions = {},
 ): QueuedSessionMessage[] {
   const otherSessions = queue.filter((item) => item.sessionId !== sessionId)
   const previousForSession = queue.filter((item) => item.sessionId === sessionId && !item.sending)
   // Detect consumed messages: items in local state but not in server snapshot.
-  // Keep them visible as "sending" so they don't vanish from the UI.
+  // Keep only the run that actually became active visible as "sending" so it
+  // doesn't vanish from the UI before the transcript refresh catches up.
   const nextRunIds = new Set(nextItems.map((item) => item.runId))
+  const activeRunId = typeof options.activeRunId === 'string' && options.activeRunId.trim()
+    ? options.activeRunId
+    : null
   const consumed = previousForSession
-    .filter((item) => !item.optimistic && !nextRunIds.has(item.runId))
+    .filter((item) => !item.optimistic && !nextRunIds.has(item.runId) && activeRunId === item.runId)
     .map((item) => ({ ...item, sending: true }))
   return [
     ...otherSessions,

package/src/lib/providers/anthropic.ts

@@ -2,8 +2,11 @@ import fs from 'fs'
 import https from 'https'
 import type { StreamChatOptions } from './index'
 import { PROVIDER_DEFAULTS, IMAGE_EXTS, TEXT_EXTS, ANTHROPIC_MAX_TOKENS, MAX_HISTORY_MESSAGES, writeSSE } from './provider-defaults'
+import { log } from '@/lib/server/logger'
 import { resolveImagePath } from '@/lib/server/resolve-image'
 
+const TAG = 'provider-anthropic'
+
 async function fileToContentBlocks(filePath: string): Promise<Array<Record<string, unknown>>> {
   if (!filePath || !fs.existsSync(filePath)) return []
   if (IMAGE_EXTS.test(filePath)) {
@@ -71,7 +74,7 @@ export function streamAnthropicChat({ session, message, imagePath, apiKey, syste
         apiRes.on('data', (c: Buffer) => errBody += c)
         apiRes.on('end', () => {
           const msg = `Anthropic error ${apiRes.statusCode}: ${errBody.slice(0, 200)}`
-          console.error(`[${session.id}] ${msg}`)
+          log.error(TAG, `[${session.id}] ${msg}`)
           let errMsg = `Anthropic API error (${apiRes.statusCode})`
           try {
             const parsed = JSON.parse(errBody)
@@ -124,12 +127,12 @@ export function streamAnthropicChat({ session, message, imagePath, apiKey, syste
     active.set(session.id, { kill: () => { abortController.aborted = true; apiReq.destroy() } })
 
     apiReq.on('timeout', () => {
-      console.error(`[${session.id}] anthropic request timed out after 60s`)
+      log.error(TAG, `[${session.id}] anthropic request timed out after 60s`)
       apiReq.destroy(new Error('Request timed out after 60s'))
     })
 
     apiReq.on('error', (e) => {
-      console.error(`[${session.id}] anthropic request error:`, e.message)
+      log.error(TAG, `[${session.id}] anthropic request error:`, e.message)
       writeSSE(write, 'err', e.message)
       active.delete(session.id)
       reject(e)

package/src/lib/providers/claude-cli.ts

@@ -6,7 +6,9 @@ import type { StreamChatOptions } from './index'
 import { log } from '../server/logger'
 import { loadRuntimeSettings } from '@/lib/server/runtime/runtime-settings'
 import { getEnabledToolIds } from '@/lib/capability-selection'
-import { resolveCliBinary, buildCliEnv, probeCliAuth, attachAbortHandler } from './cli-utils'
+import { resolveCliBinary, buildCliEnv, probeCliAuth, attachAbortHandler, isStderrNoise } from './cli-utils'
+
+const TAG = 'provider-claude-cli'
 
 export function streamClaudeCliChat({ session, message, imagePath, systemPrompt, write, active, signal }: StreamChatOptions): Promise<string> {
   const processTimeoutMs = loadRuntimeSettings().cliProcessTimeoutMs
@@ -152,8 +154,12 @@ export function streamClaudeCliChat({ session, message, imagePath, systemPrompt,
     const text = chunk.toString()
     stderrText += text
     if (stderrText.length > 16_000) stderrText = stderrText.slice(-16_000)
-    log.warn('claude-cli', `stderr [${session.id}]`, text.slice(0, 500))
-    console.error(`[${session.id}] stderr:`, text.slice(0, 200))
+    if (isStderrNoise(text)) {
+      log.debug('claude-cli', `stderr noise [${session.id}]`, text.slice(0, 500))
+    } else {
+      log.warn('claude-cli', `stderr [${session.id}]`, text.slice(0, 500))
+      log.error(TAG, `[${session.id}] stderr:`, text.slice(0, 200))
+    }
   })
 
   return new Promise((resolve) => {

package/src/lib/providers/cli-utils.test.ts

@@ -0,0 +1,124 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { isStderrNoise, buildCliEnv, isCliProvider, CLI_PROVIDER_CAPABILITIES } from './cli-utils'
+
+// ---------------------------------------------------------------------------
+// isStderrNoise
+// ---------------------------------------------------------------------------
+
+describe('isStderrNoise', () => {
+  it('returns true for MallocStackLogging lines', () => {
+    assert.equal(isStderrNoise('MallocStackLogging: could not tag MSL'), true)
+  })
+
+  it('returns true for blank/whitespace lines', () => {
+    assert.equal(isStderrNoise(''), true)
+    assert.equal(isStderrNoise('   '), true)
+    assert.equal(isStderrNoise('\t'), true)
+  })
+
+  it('returns false for real error text', () => {
+    assert.equal(isStderrNoise('Error: connection refused'), false)
+    assert.equal(isStderrNoise('FATAL: segfault'), false)
+    assert.equal(isStderrNoise('Permission denied'), false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// buildCliEnv
+// ---------------------------------------------------------------------------
+
+describe('buildCliEnv', () => {
+  it('strips SWARMCLAW_ prefixed vars from env', () => {
+    const orig = process.env.SWARMCLAW_TEST_VAR
+    process.env.SWARMCLAW_TEST_VAR = 'should_be_stripped'
+    try {
+      const env = buildCliEnv()
+      assert.equal(env.SWARMCLAW_TEST_VAR, undefined)
+    } finally {
+      if (orig === undefined) delete process.env.SWARMCLAW_TEST_VAR
+      else process.env.SWARMCLAW_TEST_VAR = orig
+    }
+  })
+
+  it('deletes MallocStackLogging', () => {
+    const orig = process.env.MallocStackLogging
+    process.env.MallocStackLogging = '1'
+    try {
+      const env = buildCliEnv()
+      assert.equal(env.MallocStackLogging, undefined)
+    } finally {
+      if (orig === undefined) delete process.env.MallocStackLogging
+      else process.env.MallocStackLogging = orig
+    }
+  })
+
+  it('injects provided key-value pairs', () => {
+    const env = buildCliEnv({ inject: { MY_CUSTOM_KEY: 'hello' } })
+    assert.equal(env.MY_CUSTOM_KEY, 'hello')
+  })
+
+  it('preserves unrelated user env vars', () => {
+    const env = buildCliEnv()
+    assert.equal(env.PATH, process.env.PATH)
+  })
+
+  it('supports custom stripPrefixes', () => {
+    const orig = process.env.CUSTOM_PREFIX_VAR
+    process.env.CUSTOM_PREFIX_VAR = 'should_be_stripped'
+    try {
+      const env = buildCliEnv({ stripPrefixes: ['CUSTOM_PREFIX_'] })
+      assert.equal(env.CUSTOM_PREFIX_VAR, undefined)
+    } finally {
+      if (orig === undefined) delete process.env.CUSTOM_PREFIX_VAR
+      else process.env.CUSTOM_PREFIX_VAR = orig
+    }
+  })
+
+  it('sets TERM=dumb and NO_COLOR=1', () => {
+    const env = buildCliEnv()
+    assert.equal(env.TERM, 'dumb')
+    assert.equal(env.NO_COLOR, '1')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// isCliProvider
+// ---------------------------------------------------------------------------
+
+describe('isCliProvider', () => {
+  it('returns true for known CLI providers', () => {
+    assert.equal(isCliProvider('claude-cli'), true)
+    assert.equal(isCliProvider('codex-cli'), true)
+    assert.equal(isCliProvider('opencode-cli'), true)
+    assert.equal(isCliProvider('gemini-cli'), true)
+  })
+
+  it('returns false for non-CLI providers', () => {
+    assert.equal(isCliProvider('openai'), false)
+    assert.equal(isCliProvider('anthropic'), false)
+    assert.equal(isCliProvider(''), false)
+    assert.equal(isCliProvider('google'), false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// CLI_PROVIDER_CAPABILITIES
+// ---------------------------------------------------------------------------
+
+describe('CLI_PROVIDER_CAPABILITIES', () => {
+  it('has entries for all 4 CLI providers', () => {
+    assert.ok('claude-cli' in CLI_PROVIDER_CAPABILITIES)
+    assert.ok('codex-cli' in CLI_PROVIDER_CAPABILITIES)
+    assert.ok('opencode-cli' in CLI_PROVIDER_CAPABILITIES)
+    assert.ok('gemini-cli' in CLI_PROVIDER_CAPABILITIES)
+  })
+
+  it('each entry is a non-empty string', () => {
+    for (const [key, value] of Object.entries(CLI_PROVIDER_CAPABILITIES)) {
+      assert.equal(typeof value, 'string', `${key} should be a string`)
+      assert.ok(value.length > 0, `${key} should be non-empty`)
+    }
+  })
+})

package/src/lib/providers/cli-utils.ts

@@ -106,6 +106,8 @@ export function buildCliEnv(opts?: {
     }
   }
 
+  delete (env as Record<string, unknown>).MallocStackLogging
+
   if (opts?.inject) {
     for (const [key, value] of Object.entries(opts.inject)) {
       env[key] = value
@@ -115,6 +117,19 @@ export function buildCliEnv(opts?: {
   return env
 }
 
+// ---------------------------------------------------------------------------
+// Stderr Noise Filter
+// ---------------------------------------------------------------------------
+
+const STDERR_NOISE_PATTERNS: RegExp[] = [
+  /MallocStackLogging/,
+  /^\s*$/,
+]
+
+export function isStderrNoise(text: string): boolean {
+  return STDERR_NOISE_PATTERNS.some((re) => re.test(text))
+}
+
 // ---------------------------------------------------------------------------
 // Auth Probing
 // ---------------------------------------------------------------------------

package/src/lib/providers/codex-cli.ts

@@ -5,7 +5,9 @@ import { spawn } from 'child_process'
 import type { StreamChatOptions } from './index'
 import { log } from '../server/logger'
 import { loadRuntimeSettings } from '@/lib/server/runtime/runtime-settings'
-import { resolveCliBinary, buildCliEnv, probeCliAuth, attachAbortHandler, symlinkConfigFiles } from './cli-utils'
+import { resolveCliBinary, buildCliEnv, probeCliAuth, attachAbortHandler, symlinkConfigFiles, isStderrNoise } from './cli-utils'
+
+const TAG = 'provider-codex'
 
 function codexModelRequiresReasoningDowngrade(model: string | null | undefined): boolean {
   const value = String(model || '').trim().toLowerCase()
@@ -196,8 +198,12 @@ export function streamCodexCliChat({ session, message, imagePath, systemPrompt,
     const text = chunk.toString()
     stderrText += text
     if (stderrText.length > 16_000) stderrText = stderrText.slice(-16_000)
-    log.warn('codex-cli', `stderr [${session.id}]`, text.slice(0, 500))
-    console.error(`[${session.id}] codex stderr:`, text.slice(0, 200))
+    if (isStderrNoise(text)) {
+      log.debug('codex-cli', `stderr noise [${session.id}]`, text.slice(0, 500))
+    } else {
+      log.warn('codex-cli', `stderr [${session.id}]`, text.slice(0, 500))
+      log.error(TAG, `[${session.id}] codex stderr:`, text.slice(0, 200))
+    }
   })
 
   return new Promise((resolve) => {

package/src/lib/providers/gemini-cli.ts

@@ -2,7 +2,7 @@ import { spawn } from 'child_process'
 import type { StreamChatOptions } from './index'
 import { log } from '../server/logger'
 import { loadRuntimeSettings } from '@/lib/server/runtime/runtime-settings'
-import { resolveCliBinary, buildCliEnv, probeCliAuth, attachAbortHandler } from './cli-utils'
+import { resolveCliBinary, buildCliEnv, probeCliAuth, attachAbortHandler, isStderrNoise } from './cli-utils'
 
 /**
  * Gemini CLI provider — spawns `gemini --prompt <message> --output-format stream-json --yolo`.
@@ -151,7 +151,11 @@ export function streamGeminiCliChat({ session, message, imagePath, systemPrompt,
     const text = chunk.toString()
     stderrText += text
     if (stderrText.length > 16_000) stderrText = stderrText.slice(-16_000)
-    log.warn('gemini-cli', `stderr [${session.id}]`, text.slice(0, 500))
+    if (isStderrNoise(text)) {
+      log.debug('gemini-cli', `stderr noise [${session.id}]`, text.slice(0, 500))
+    } else {
+      log.warn('gemini-cli', `stderr [${session.id}]`, text.slice(0, 500))
+    }
   })
 
   return new Promise((resolve) => {

package/src/lib/providers/index.ts

@@ -8,8 +8,11 @@ import { streamAnthropicChat } from './anthropic'
 import { streamOpenClawChat } from './openclaw'
 import { errorMessage, sleep, jitteredBackoff } from '@/lib/shared-utils'
 import { classifyProviderError } from './error-classification'
+import { log } from '@/lib/server/logger'
 import type { ProviderInfo, ProviderConfig as CustomProviderConfig, ProviderType } from '../../types'
 
+const TAG = 'providers'
+
 export interface ProviderHandler {
   streamChat: (opts: StreamChatOptions) => Promise<string>
 }
@@ -439,7 +442,7 @@ export async function streamChatWithFailover(
       if (classified.reason === 'auth_permanent') throw err
 
       if (i < credentialIds.length - 1) {
-        console.log(`[failover] Credential ${credId} failed (${classified.reason}: ${errMessage?.slice(0, 80)}), trying fallback...`)
+        log.info(TAG, `Credential ${credId} failed (${classified.reason}: ${errMessage?.slice(0, 80)}), trying fallback...`)
         opts.write(`data: ${JSON.stringify({
           t: 'md',
           text: JSON.stringify({ failover: { from: credId, reason: errMessage?.slice(0, 100) } }),

package/src/lib/providers/ollama.ts

@@ -3,9 +3,12 @@ import http from 'http'
 import https from 'https'
 import type { StreamChatOptions } from './index'
 import { IMAGE_EXTS, TEXT_EXTS, MAX_HISTORY_MESSAGES, writeSSE } from './provider-defaults'
+import { log } from '@/lib/server/logger'
 import { resolveOllamaRuntimeConfig } from '@/lib/server/ollama-runtime'
 import { resolveImagePath } from '@/lib/server/resolve-image'
 
+const TAG = 'provider-ollama'
+
 export function streamOllamaChat({ session, message, imagePath, apiKey, write, active, loadHistory, onUsage, signal }: StreamChatOptions): Promise<string> {
   return new Promise((resolve, reject) => {
     const messages = buildMessages(session, message, imagePath, loadHistory)
@@ -69,7 +72,7 @@ export function streamOllamaChat({ session, message, imagePath, apiKey, write, a
         apiRes.on('data', (c: Buffer) => errBody += c)
         apiRes.on('end', () => {
           const msg = `Ollama error ${apiRes.statusCode}: ${errBody.slice(0, 200)}`
-          console.error(`[${session.id}] ${msg}`)
+          log.error(TAG, `[${session.id}] ${msg}`)
           writeSSE(write, 'err', msg.slice(0, 120))
           active.delete(session.id)
           reject(new Error(msg))
@@ -114,7 +117,7 @@ export function streamOllamaChat({ session, message, imagePath, apiKey, write, a
     active.set(session.id, { kill: () => { abortController.aborted = true; apiReq.destroy() } })
 
     apiReq.on('error', (e: NodeJS.ErrnoException) => {
-      console.error(`[${session.id}] ollama request error:`, e.message)
+      log.error(TAG, `[${session.id}] ollama request error:`, e.message)
       let errMsg = e.message
       if (e.code === 'ECONNREFUSED') {
         errMsg = `Cannot connect to Ollama at ${endpoint}. Is Ollama running?`

package/src/lib/providers/openai.ts

@@ -1,8 +1,11 @@
 import fs from 'fs'
 import type { StreamChatOptions } from './index'
 import { PROVIDER_DEFAULTS, IMAGE_EXTS, TEXT_EXTS, PDF_MAX_CHARS, MAX_HISTORY_MESSAGES, writeSSE } from './provider-defaults'
+import { log } from '@/lib/server/logger'
 import { resolveImagePath } from '@/lib/server/resolve-image'
 
+const TAG = 'provider-openai'
+
 async function fileToContentParts(filePath: string): Promise<Array<Record<string, unknown>>> {
   if (!filePath || !fs.existsSync(filePath)) return []
   const name = filePath.split('/').pop() || 'file'
@@ -108,7 +111,7 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
       const resContentType = res.headers.get('content-type') || ''
       if (resContentType.includes('text/html')) {
         const msg = 'Received HTML instead of API response. The endpoint may be misconfigured or returning a landing page.'
-        console.error(`[${session.id}] received HTML instead of API response from ${baseUrl} (provider: ${session.provider})`)
+        log.error(TAG, `[${session.id}] received HTML instead of API response from ${baseUrl} (provider: ${session.provider})`)
         writeSSE(write, 'err', msg)
         active.delete(session.id)
         reject(new Error(msg))
@@ -117,7 +120,7 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
 
       if (!res.ok) {
         const errBody = await res.text().catch(() => '')
-        console.error(`[${session.id}] openai error ${res.status}:`, errBody.slice(0, 200))
+        log.error(TAG, `[${session.id}] openai error ${res.status}:`, errBody.slice(0, 200))
         let errMsg = `API error (${res.status})`
         try {
           const parsed = JSON.parse(errBody)
@@ -133,7 +136,7 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
 
       if (!res.body) {
         const msg = `No response body from ${baseUrl}`
-        console.error(`[${session.id}] ${msg}`)
+        log.error(TAG, `[${session.id}] ${msg}`)
         active.delete(session.id)
         reject(new Error(msg))
         return
@@ -175,12 +178,12 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
       }
 
       if (!fullResponse) {
-        console.error(`[${session.id}] openai stream ended with no content (provider: ${session.provider}, endpoint: ${baseUrl})`)
+        log.error(TAG, `[${session.id}] openai stream ended with no content (provider: ${session.provider}, endpoint: ${baseUrl})`)
       }
     } catch (err: unknown) {
       const errObj = err as { name?: string; message?: string }
       if (errObj.name !== 'AbortError') {
-        console.error(`[${session.id}] openai request error:`, errObj.message)
+        log.error(TAG, `[${session.id}] openai request error:`, errObj.message)
         writeSSE(write, 'err', `Connection failed: ${errObj.message}`)
       }
       active.delete(session.id)

package/src/lib/providers/opencode-cli.ts

@@ -2,7 +2,7 @@ import { spawn } from 'child_process'
 import type { StreamChatOptions } from './index'
 import { log } from '../server/logger'
 import { loadRuntimeSettings } from '@/lib/server/runtime/runtime-settings'
-import { resolveCliBinary, buildCliEnv, probeCliAuth, attachAbortHandler } from './cli-utils'
+import { resolveCliBinary, buildCliEnv, probeCliAuth, attachAbortHandler, isStderrNoise } from './cli-utils'
 
 /**
  * OpenCode CLI provider — spawns `opencode run <message> --format json` for non-interactive usage.
@@ -120,7 +120,11 @@ export function streamOpenCodeCliChat({ session, message, imagePath, systemPromp
     const text = chunk.toString()
     stderrText += text
     if (stderrText.length > 16_000) stderrText = stderrText.slice(-16_000)
-    log.warn('opencode-cli', `stderr [${session.id}]`, text.slice(0, 500))
+    if (isStderrNoise(text)) {
+      log.debug('opencode-cli', `stderr noise [${session.id}]`, text.slice(0, 500))
+    } else {
+      log.warn('opencode-cli', `stderr [${session.id}]`, text.slice(0, 500))
+    }
   })
 
   return new Promise((resolve) => {

package/src/lib/server/activity/activity-log.ts

@@ -0,0 +1,21 @@
+import { loadActivity as loadStoredActivity, logActivity as writeActivityLog } from '@/lib/server/storage'
+import { perf } from '@/lib/server/runtime/perf'
+
+export function loadActivity() {
+  return perf.measureSync('repository', 'activity.list', () => loadStoredActivity())
+}
+
+export function logActivity(entry: {
+  entityType: string
+  entityId: string
+  action: string
+  actor: string
+  actorId?: string
+  summary: string
+  detail?: Record<string, unknown>
+}) {
+  perf.measureSync('repository', 'activity.log', () => writeActivityLog(entry), {
+    entityType: entry.entityType,
+    action: entry.action,
+  })
+}