@swarmclawai/swarmclaw 1.2.0 → 1.2.2

package/src/lib/server/chat-execution/message-classifier.test.ts

@@ -0,0 +1,329 @@
+import assert from 'node:assert/strict'
+import { describe, it, before, after } from 'node:test'
+
+const originalEnv = {
+  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
+}
+
+let mod: typeof import('@/lib/server/chat-execution/message-classifier')
+
+before(async () => {
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  mod = await import('@/lib/server/chat-execution/message-classifier')
+})
+
+after(() => {
+  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
+})
+
+// ---------------------------------------------------------------------------
+// parseClassificationResponse
+// ---------------------------------------------------------------------------
+
+describe('parseClassificationResponse', () => {
+  const validJson = JSON.stringify({
+    isDeliverableTask: true,
+    isBroadGoal: false,
+    walletIntent: 'none',
+    hasHumanSignals: false,
+    hasSignificantEvent: false,
+    isResearchSynthesis: false,
+    explicitToolRequests: [],
+    confidence: 0.9,
+  })
+
+  it('parses valid JSON with all schema fields', () => {
+    const result = mod.parseClassificationResponse(validJson)
+    assert.ok(result)
+    assert.equal(result!.isDeliverableTask, true)
+    assert.equal(result!.isBroadGoal, false)
+    assert.equal(result!.walletIntent, 'none')
+    assert.equal(result!.confidence, 0.9)
+    assert.deepEqual(result!.explicitToolRequests, [])
+  })
+
+  it('returns null for malformed JSON', () => {
+    assert.equal(mod.parseClassificationResponse('not json at all'), null)
+    assert.equal(mod.parseClassificationResponse('{broken'), null)
+  })
+
+  it('returns null for JSON missing required keys', () => {
+    const partial = JSON.stringify({ isDeliverableTask: true })
+    assert.equal(mod.parseClassificationResponse(partial), null)
+  })
+
+  it('tolerates extra keys in JSON', () => {
+    const withExtra = JSON.stringify({
+      isDeliverableTask: true,
+      isBroadGoal: false,
+      walletIntent: 'none',
+      hasHumanSignals: false,
+      hasSignificantEvent: false,
+      isResearchSynthesis: false,
+      explicitToolRequests: ['shell'],
+      confidence: 0.85,
+      extraKey: 'should be ignored',
+    })
+    const result = mod.parseClassificationResponse(withExtra)
+    assert.ok(result)
+    assert.equal(result!.isDeliverableTask, true)
+  })
+
+  it('extracts embedded JSON from prose text', () => {
+    const prose = `Here is my classification:\n${validJson}\nEnd of classification.`
+    const result = mod.parseClassificationResponse(prose)
+    assert.ok(result)
+    assert.equal(result!.isDeliverableTask, true)
+  })
+
+  it('returns null for empty text', () => {
+    assert.equal(mod.parseClassificationResponse(''), null)
+    assert.equal(mod.parseClassificationResponse('   '), null)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// isDeliverableTask
+// ---------------------------------------------------------------------------
+
+describe('isDeliverableTask', () => {
+  it('uses classification value when provided', () => {
+    const cls = makeClassification({ isDeliverableTask: true })
+    assert.equal(mod.isDeliverableTask(cls, 'anything'), true)
+
+    const cls2 = makeClassification({ isDeliverableTask: false })
+    assert.equal(mod.isDeliverableTask(cls2, 'build me a landing page'), false)
+  })
+
+  it('falls back to regex when classification is null', () => {
+    // A message that looks like a deliverable task
+    const result = mod.isDeliverableTask(null, 'Create a detailed marketing report with competitor analysis and market sizing. Include charts and recommendations for Q3 strategy across all regions.')
+    assert.equal(typeof result, 'boolean')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// isBroadGoal
+// ---------------------------------------------------------------------------
+
+describe('isBroadGoal', () => {
+  it('uses classification value when provided', () => {
+    assert.equal(mod.isBroadGoal(makeClassification({ isBroadGoal: true }), ''), true)
+    assert.equal(mod.isBroadGoal(makeClassification({ isBroadGoal: false }), ''), false)
+  })
+
+  it('falls back to regex when classification is null', () => {
+    const result = mod.isBroadGoal(null, 'I want to build a complete e-commerce platform with user authentication, product catalog, shopping cart, and payment processing')
+    assert.equal(typeof result, 'boolean')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// hasWalletIntent
+// ---------------------------------------------------------------------------
+
+describe('hasWalletIntent', () => {
+  it('walletIntent none returns false', () => {
+    assert.equal(mod.hasWalletIntent(makeClassification({ walletIntent: 'none' }), ''), false)
+  })
+
+  it('walletIntent read_only returns true', () => {
+    assert.equal(mod.hasWalletIntent(makeClassification({ walletIntent: 'read_only' }), ''), true)
+  })
+
+  it('walletIntent transactional returns true', () => {
+    assert.equal(mod.hasWalletIntent(makeClassification({ walletIntent: 'transactional' }), ''), true)
+  })
+
+  it('falls back to regex when classification is null', () => {
+    const result = mod.hasWalletIntent(null, 'check my wallet balance')
+    assert.equal(typeof result, 'boolean')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// hasTransactionalWalletIntent
+// ---------------------------------------------------------------------------
+
+describe('hasTransactionalWalletIntent', () => {
+  it('only transactional returns true', () => {
+    assert.equal(mod.hasTransactionalWalletIntent(makeClassification({ walletIntent: 'transactional' }), ''), true)
+    assert.equal(mod.hasTransactionalWalletIntent(makeClassification({ walletIntent: 'read_only' }), ''), false)
+    assert.equal(mod.hasTransactionalWalletIntent(makeClassification({ walletIntent: 'none' }), ''), false)
+  })
+
+  it('falls back to regex when classification is null', () => {
+    const result = mod.hasTransactionalWalletIntent(null, 'swap 1 ETH for USDC')
+    assert.equal(typeof result, 'boolean')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// hasHumanSignals
+// ---------------------------------------------------------------------------
+
+describe('hasHumanSignals', () => {
+  it('uses classification value when provided', () => {
+    assert.equal(mod.hasHumanSignals(makeClassification({ hasHumanSignals: true }), ''), true)
+    assert.equal(mod.hasHumanSignals(makeClassification({ hasHumanSignals: false }), ''), false)
+  })
+
+  it('regex detects personal text', () => {
+    assert.equal(mod.hasHumanSignals(null, 'my birthday is next week'), true)
+  })
+
+  it('regex returns false for task-only text', () => {
+    assert.equal(mod.hasHumanSignals(null, 'deploy the app'), false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// hasSignificantEvent
+// ---------------------------------------------------------------------------
+
+describe('hasSignificantEvent', () => {
+  it('uses classification value when provided', () => {
+    assert.equal(mod.hasSignificantEvent(makeClassification({ hasSignificantEvent: true }), ''), true)
+    assert.equal(mod.hasSignificantEvent(makeClassification({ hasSignificantEvent: false }), ''), false)
+  })
+
+  it('regex detects significant events', () => {
+    assert.equal(mod.hasSignificantEvent(null, 'I just got promoted at work'), true)
+    assert.equal(mod.hasSignificantEvent(null, 'my graduation ceremony is on Friday'), true)
+  })
+
+  it('regex returns false for non-event text', () => {
+    assert.equal(mod.hasSignificantEvent(null, 'fix the login bug'), false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// isResearchSynthesis
+// ---------------------------------------------------------------------------
+
+describe('isResearchSynthesis', () => {
+  it('uses classification value when provided', () => {
+    assert.equal(mod.isResearchSynthesis(makeClassification({ isResearchSynthesis: true }), null), true)
+    assert.equal(mod.isResearchSynthesis(makeClassification({ isResearchSynthesis: false }), null), false)
+  })
+
+  it('falls back to routingIntent when classification is null', () => {
+    assert.equal(mod.isResearchSynthesis(null, 'research'), true)
+    assert.equal(mod.isResearchSynthesis(null, 'browsing'), true)
+    assert.equal(mod.isResearchSynthesis(null, 'coding'), false)
+    assert.equal(mod.isResearchSynthesis(null, null), false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// classifyMessage — with generateText override
+// ---------------------------------------------------------------------------
+
+describe('classifyMessage', () => {
+  it('returns valid classification from mock generateText', async () => {
+    const mockResponse = JSON.stringify({
+      isDeliverableTask: true,
+      isBroadGoal: false,
+      walletIntent: 'none',
+      hasHumanSignals: false,
+      hasSignificantEvent: false,
+      isResearchSynthesis: false,
+      explicitToolRequests: ['shell'],
+      confidence: 0.95,
+    })
+
+    const result = await mod.classifyMessage(
+      { sessionId: 'test-session', message: 'Build me a dashboard' },
+      { generateText: async () => mockResponse },
+    )
+
+    assert.ok(result)
+    assert.equal(result!.isDeliverableTask, true)
+    assert.equal(result!.walletIntent, 'none')
+    assert.deepEqual(result!.explicitToolRequests, ['shell'])
+  })
+
+  it('returns null for empty message', async () => {
+    const result = await mod.classifyMessage(
+      { sessionId: 'test-session', message: '' },
+      { generateText: async () => '{}' },
+    )
+    assert.equal(result, null)
+  })
+
+  it('returns null for whitespace-only message', async () => {
+    const result = await mod.classifyMessage(
+      { sessionId: 'test-session', message: '   ' },
+      { generateText: async () => '{}' },
+    )
+    assert.equal(result, null)
+  })
+
+  it('returns null when generateText times out', async () => {
+    const result = await mod.classifyMessage(
+      { sessionId: 'test-session', message: 'A message that will timeout for classification purposes' },
+      {
+        generateText: () => new Promise((resolve) => {
+          // Never resolves within 2s timeout
+          setTimeout(() => resolve('{}'), 10_000)
+        }),
+      },
+    )
+    assert.equal(result, null)
+  })
+
+  it('caches results for the same message', async () => {
+    let callCount = 0
+    const mockResponse = JSON.stringify({
+      isDeliverableTask: false,
+      isBroadGoal: false,
+      walletIntent: 'none',
+      hasHumanSignals: false,
+      hasSignificantEvent: false,
+      isResearchSynthesis: false,
+      explicitToolRequests: [],
+      confidence: 0.8,
+    })
+
+    const generateText = async () => {
+      callCount++
+      return mockResponse
+    }
+
+    // Use a unique message to avoid cache from other tests
+    const uniqueMsg = `cache-test-${Date.now()}-${Math.random()}`
+
+    const first = await mod.classifyMessage(
+      { sessionId: 'test-session', message: uniqueMsg },
+      { generateText },
+    )
+    const second = await mod.classifyMessage(
+      { sessionId: 'test-session', message: uniqueMsg },
+      { generateText },
+    )
+
+    assert.ok(first)
+    assert.ok(second)
+    assert.deepEqual(first, second)
+    assert.equal(callCount, 1, 'generateText should only be called once due to cache')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Helper
+// ---------------------------------------------------------------------------
+
+function makeClassification(overrides: Partial<import('@/lib/server/chat-execution/message-classifier').MessageClassification>): import('@/lib/server/chat-execution/message-classifier').MessageClassification {
+  return {
+    isDeliverableTask: false,
+    isBroadGoal: false,
+    walletIntent: 'none',
+    hasHumanSignals: false,
+    hasSignificantEvent: false,
+    isResearchSynthesis: false,
+    explicitToolRequests: [],
+    confidence: 0.9,
+    ...overrides,
+  }
+}

package/src/lib/server/chat-execution/message-classifier.ts

@@ -13,9 +13,12 @@ import crypto from 'node:crypto'
 import { HumanMessage } from '@langchain/core/messages'
 import { z } from 'zod'
 import { buildLLM } from '@/lib/server/build-llm'
+import { log } from '@/lib/server/logger'
 import { hmrSingleton } from '@/lib/shared-utils'
 import type { Message } from '@/types'
 
+const TAG = 'message-classifier'
+
 // ---------------------------------------------------------------------------
 // Schema
 // ---------------------------------------------------------------------------
@@ -221,7 +224,7 @@ export async function classifyMessage(
     ])
 
     const durationMs = Date.now() - startMs
-    console.log(`[message-classifier] session=${input.sessionId} completed in ${durationMs}ms`)
+    log.info(TAG, `session=${input.sessionId} completed in ${durationMs}ms`)
 
     const classification = parseClassificationResponse(responseText)
     if (classification) {
@@ -230,7 +233,7 @@ export async function classifyMessage(
     return classification
   } catch (err: unknown) {
     const durationMs = Date.now() - startMs
-    console.warn(`[message-classifier] session=${input.sessionId} failed in ${durationMs}ms: ${err instanceof Error ? err.message : 'unknown'}`)
+    log.warn(TAG, `session=${input.sessionId} failed in ${durationMs}ms: ${err instanceof Error ? err.message : 'unknown'}`)
     return null
   }
 }

package/src/lib/server/chat-execution/post-stream-finalization.ts

@@ -6,11 +6,14 @@
  * and OpenClaw sync.
  */
 import type { Session, UsageRecord } from '@/types'
+import { log } from '@/lib/server/logger'
 import type { ChatTurnState } from '@/lib/server/chat-execution/chat-turn-state'
+
+const TAG = 'post-stream'
 import { extractSuggestions } from '@/lib/server/suggestions'
 import type { StructuredToolInterface } from '@langchain/core/tools'
 import { estimateCost, buildExtensionDefinitionCosts } from '@/lib/server/cost'
-import { appendUsage } from '@/lib/server/storage'
+import { appendUsage } from '@/lib/server/usage/usage-repository'
 import { runCapabilityHook } from '@/lib/server/native-capabilities'
 import {
   shouldForceExternalServiceSummary,
@@ -39,7 +42,7 @@ function stripLeakedClassificationJson(text: string): { cleaned: string; strippe
     else if (text[i] === '}') { depth--; if (depth === 0) { end = i + 1; break } }
   }
   if (end === -1) return { cleaned: text, stripped: false }
-  console.warn('[post-stream-finalization] Stripped leaked classification JSON from model output')
+  log.warn(TAG, 'Stripped leaked classification JSON from model output')
   return { cleaned: (text.slice(0, startIdx) + text.slice(end)).trimStart(), stripped: true }
 }
 

package/src/lib/server/chat-execution/prompt-builder.ts

@@ -73,13 +73,24 @@ function buildExtensionCapabilityLines(enabledExtensions: string[], opts?: { del
   return lines
 }
 
+const DISPLAY_TOOL_ALIASES: Record<string, string[]> = {
+  files: ['send_file'],
+  shell: ['sandbox_exec', 'sandbox_list_runtimes'],
+}
+
 function buildExactToolNameList(enabledExtensions: string[]): string[] {
   const planning = getEnabledToolPlanningView(enabledExtensions)
+  const displayAliases = dedup(
+    enabledExtensions
+      .map((toolId) => canonicalizeExtensionId(toolId))
+      .flatMap((toolId) => DISPLAY_TOOL_ALIASES[toolId] || []),
+  )
   const extensionToolNames = getExtensionManager()
     .getTools(enabledExtensions)
     .map(({ tool }) => tool.name)
   const combined = [
     ...planning.displayToolIds,
+    ...displayAliases,
     ...planning.entries.map((entry) => entry.toolName),
     ...extensionToolNames,
   ]
@@ -120,6 +131,16 @@ export function buildToolDisciplineLines(enabledExtensions: string[]): string[]
 
   lines.push(...planning.disciplineGuidance)
 
+  // Universal tool efficiency guidance — tool-specific lines live in CORE_TOOL_PLANNING (tool-planning.ts)
+  lines.push(
+    '## Tool Efficiency',
+    'Plan your approach before starting tool calls. State what you will do, then do it.',
+    'Prefer fewer, larger tool calls over many small ones.',
+    'Do not poll for status in a loop. If waiting on a process, check once and move on.',
+    'If stuck after 2-3 attempts with the same approach, stop and state the blocker — do not keep retrying.',
+    'When delegating to subagents, use waitForCompletion or wait/wait_all instead of polling status in a loop.',
+  )
+
   const researchSearchTools = getToolsForCapability(enabledExtensions, TOOL_CAPABILITY.researchSearch)
   const researchFetchTools = getToolsForCapability(enabledExtensions, TOOL_CAPABILITY.researchFetch)
   const browserCaptureTools = getToolsForCapability(enabledExtensions, TOOL_CAPABILITY.browserCapture)
@@ -275,7 +296,7 @@ const GOAL_DECOMPOSITION_BLOCK = [
   '## Goal Decomposition',
   'When you receive a broad, open-ended goal:',
   '1. Break it into 3-7 concrete, sequentially-executable subtasks before taking action.',
-  '2. If manage_tasks is available, use it only for durable tracking: multi-turn work, delegation, explicit backlog requests, or work you expect to resume later. Do not create a task for every micro-step.',
+  '2. If manage_tasks is available, use it only for durable tracking: multi-turn work, delegation, explicit backlog requests, or work you expect to resume later. Do not create a task for every micro-step. Do not re-read the task list after every update. Read once, make your changes, then move on.',
   'Single-step instructions are not broad goals. For direct actions like storing a memory, answering a recall question, editing one file, or sending one message, execute the relevant tool immediately instead of creating tasks or delegating.',
   '3. Present the plan as a short checklist or numbered list in plain language. If durable tracking is unnecessary, keep it inline instead of creating tasks.',
   '4. Execute the first substantive subtask immediately — do not stop after planning.',

package/src/lib/server/chat-execution/prompt-sections.ts

@@ -9,7 +9,8 @@
 import type { Session, Agent } from '@/types'
 import type { ActiveProjectContext } from '@/lib/server/project-context'
 import { buildIdentityContinuityContext } from '@/lib/server/identity-continuity'
-import { loadSkills, loadAgents } from '@/lib/server/storage'
+import { getAgent, listAgents } from '@/lib/server/agents/agent-repository'
+import { loadSkills } from '@/lib/server/skills/skill-repository'
 import { buildRuntimeSkillPromptBlocks, resolveRuntimeSkills } from '@/lib/server/skills/runtime-skill-resolver'
 import { resolveTeam } from '@/lib/server/agents/team-resolution'
 
@@ -123,7 +124,20 @@ export async function buildAgentAwarenessSection(
   if (!hasMultiAgentTool || !session.agentId) return null
   try {
     const { buildAgentAwarenessBlock } = await import('@/lib/server/agents/agent-registry')
-    return buildAgentAwarenessBlock(session.agentId) || null
+
+    // Load agent to get delegation settings so the awareness block respects them
+    let delegationOpts: { delegationTargetMode?: 'all' | 'selected'; delegationTargetAgentIds?: string[] } | undefined
+    try {
+      const agent = getAgent(session.agentId)
+      if (agent?.delegationTargetMode === 'selected') {
+        delegationOpts = {
+          delegationTargetMode: 'selected',
+          delegationTargetAgentIds: agent.delegationTargetAgentIds || [],
+        }
+      }
+    } catch { /* non-critical */ }
+
+    return buildAgentAwarenessBlock(session.agentId, delegationOpts) || null
   } catch { return null }
 }
 
@@ -185,6 +199,8 @@ export function buildProjectSection(
       `project secrets ${summary.secretCount}`,
     ]
     if (summary.topTaskTitles.length > 0) lines.push(`Top open tasks: ${summary.topTaskTitles.join('; ')}`)
+    if (summary.failedTaskCount > 0) lines.push(`Failed tasks needing attention: ${summary.failedTaskCount}`)
+    if (summary.staleTaskCount > 0) lines.push(`Stale tasks (no update in 3+ days): ${summary.staleTaskCount}`)
     if (summary.scheduleNames.length > 0) lines.push(`Active schedules: ${summary.scheduleNames.join('; ')}`)
     if (summary.secretNames.length > 0) lines.push(`Known project secrets: ${summary.secretNames.join('; ')}`)
     lines.push(`Project resource summary: ${resourceBits.join(', ')}.`)
@@ -257,6 +273,11 @@ export function buildSuggestionsSection(
 // Proactive Memory Recall (async)
 // ---------------------------------------------------------------------------
 
+export interface ProactiveMemoryResult {
+  section: string | null
+  injectedIds: Record<string, number>
+}
+
 export async function buildProactiveMemorySection(
   session: Session,
   agent: Agent | null | undefined,
@@ -264,9 +285,10 @@ export async function buildProactiveMemorySection(
   activeProjectRoot: string | null,
   isMinimalPrompt: boolean,
   currentThreadRecallRequest: boolean,
-): Promise<string | null> {
-  if (isMinimalPrompt || !session.agentId || currentThreadRecallRequest || message.length <= 12) return null
-  if (!agent?.proactiveMemory) return null
+): Promise<ProactiveMemoryResult> {
+  const noResult: ProactiveMemoryResult = { section: null, injectedIds: {} }
+  if (isMinimalPrompt || !session.agentId || currentThreadRecallRequest || message.length <= 12) return noResult
+  if (!agent?.proactiveMemory) return noResult
   try {
     const { getMemoryDb } = await import('@/lib/server/memory/memory-db')
     const { buildSessionMemoryScopeFilter } = await import('@/lib/server/memory/session-memory-scope')
@@ -274,13 +296,29 @@ export async function buildProactiveMemorySection(
     const recalled = memDb.search(message, session.agentId, {
       scope: buildSessionMemoryScopeFilter(session, agent.memoryScopeMode || null, activeProjectRoot),
     })
-    const topRecalled = recalled.slice(0, 3)
+
+    // Dedup: skip memories already injected 2+ times in this session
+    const priorCounts = session.injectedMemoryIds || {}
+    const filtered = recalled.filter((entry) => (priorCounts[entry.id] || 0) < 2)
+
+    const topRecalled = filtered.slice(0, 3)
     if (topRecalled.length > 0) {
-      const recalledLines = topRecalled.map((entry) => `- ${entry.content.slice(0, 300)}`)
-      return `## Recalled Context\nRelevant memories from previous interactions:\n${recalledLines.join('\n')}`
+      // Track injection counts
+      const updatedCounts: Record<string, number> = { ...priorCounts }
+      for (const entry of topRecalled) {
+        updatedCounts[entry.id] = (updatedCounts[entry.id] || 0) + 1
+      }
+
+      const recalledLines = topRecalled.map((entry) =>
+        `- ${entry.abstract || entry.content.slice(0, 300)}`,
+      )
+      return {
+        section: `## Recalled Context\nRelevant memories from previous interactions:\n${recalledLines.join('\n')}`,
+        injectedIds: updatedCounts,
+      }
     }
   } catch { /* non-critical */ }
-  return null
+  return noResult
 }
 
 // ---------------------------------------------------------------------------
@@ -296,7 +334,7 @@ export function buildCoordinatorSection(
 ): string | null {
   if (!agent || agent.role !== 'coordinator') return null
 
-  const allAgents = loadAgents()
+  const allAgents = listAgents()
   const selfId = agent.id
 
   // Resolve which agents this coordinator can delegate to
@@ -328,7 +366,7 @@ export function buildCoordinatorSection(
   for (const w of listed) {
     const caps = w.capabilities?.length ? ` [${w.capabilities.join(', ')}]` : ''
     const desc = w.description ? ` — ${w.description.slice(0, 100)}` : ''
-    const line = `- **${w.name}**${caps}${desc}`
+    const line = `- **${w.name}** [id: ${w.id}]${caps}${desc}`
     if (charBudget - line.length < 0) break
     charBudget -= line.length + 1
     lines.push(line)
@@ -338,6 +376,11 @@ export function buildCoordinatorSection(
     lines.push(`- ... and ${workers.length - COORDINATOR_MAX_WORKERS} more workers`)
   }
 
+  if (delegateMode === 'selected') {
+    lines.push('')
+    lines.push('**IMPORTANT:** You may ONLY delegate to the workers listed above. Do NOT attempt to delegate to any other agents — such attempts will be rejected.')
+  }
+
   lines.push('')
   lines.push('### Orchestration Tools')
   lines.push('- **`spawn_subagent`** — Simple fire-and-forget delegation. Best for: single tasks, batch parallel/serial, basic swarm. Use when tasks are independent.')
@@ -468,8 +511,7 @@ export function buildCliDelegationContext(opts: {
   // Team roster summary
   if (opts.agent?.id) {
     try {
-      const agents = loadAgents() as Record<string, Agent>
-      const team = resolveTeam(opts.agent.id, agents)
+      const team = resolveTeam(opts.agent.id, listAgents())
       if (team.mode === 'team') {
         const teammates = [
           ...(team.coordinator ? [`${team.coordinator.name} (coordinator)`] : []),

package/src/lib/server/chat-execution/response-completeness.ts

@@ -9,6 +9,9 @@ import crypto from 'node:crypto'
 import { HumanMessage } from '@langchain/core/messages'
 import { z } from 'zod'
 import { buildLLM } from '@/lib/server/build-llm'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'response-completeness'
 
 // ---------------------------------------------------------------------------
 // Schema
@@ -191,7 +194,7 @@ export async function evaluateResponseCompleteness(
     ])
 
     const durationMs = Date.now() - startMs
-    console.log(`[response-completeness] session=${input.sessionId} completed in ${durationMs}ms`)
+    log.info(TAG, `session=${input.sessionId} completed in ${durationMs}ms`)
 
     const completeness = parseCompletenessResponse(responseText)
     if (completeness) {
@@ -200,7 +203,7 @@ export async function evaluateResponseCompleteness(
     return completeness
   } catch (err: unknown) {
     const durationMs = Date.now() - startMs
-    console.warn(`[response-completeness] session=${input.sessionId} failed in ${durationMs}ms: ${err instanceof Error ? err.message : 'unknown'}`)
+    log.warn(TAG, `session=${input.sessionId} failed in ${durationMs}ms: ${err instanceof Error ? err.message : 'unknown'}`)
     return null
   }
 }

package/src/lib/server/chat-execution/situational-awareness.ts

@@ -1,4 +1,11 @@
-import { loadTasks, loadSchedules, loadSupervisorIncidents, loadMission, loadAgents, loadConnectors, loadChatrooms, loadUsage } from '@/lib/server/storage'
+import { listAgentIncidents } from '@/lib/server/autonomy/supervisor-incident-repository'
+import { listAgents } from '@/lib/server/agents/agent-repository'
+import { loadChatrooms } from '@/lib/server/chatrooms/chatroom-repository'
+import { loadConnectors } from '@/lib/server/connectors/connector-repository'
+import { loadMission } from '@/lib/server/missions/mission-repository'
+import { loadSchedules } from '@/lib/server/schedules/schedule-repository'
+import { loadTasks } from '@/lib/server/tasks/task-repository'
+import { loadUsage } from '@/lib/server/usage/usage-repository'
 import { listPersistedRuns } from '@/lib/server/runtime/run-ledger'
 import type { BoardTask, Mission, Schedule, SupervisorIncident, SessionRunRecord } from '@/types'
 
@@ -258,7 +265,7 @@ export function buildPlatformStatusSummary(): string {
   const oneDayAgo = now - 86_400_000
 
   // Agents
-  const agents = Object.values(loadAgents())
+  const agents = Object.values(listAgents())
   const activeAgents = agents.filter((a) => a.lastUsedAt && a.lastUsedAt > oneHourAgo)
 
   // Tasks
@@ -276,7 +283,7 @@ export function buildPlatformStatusSummary(): string {
   const connectors = Object.values(loadConnectors())
   const connectorLines: string[] = []
   for (const c of connectors) {
-    const status = c.status === 'running' || c.status === 'connected' ? '✓' : `✗ (${c.status})`
+    const status = c.status === 'running' ? '✓' : `✗ (${c.status})`
     connectorLines.push(`${c.platform || c.id} ${status}`)
   }
 
@@ -285,8 +292,7 @@ export function buildPlatformStatusSummary(): string {
   const activeChatrooms = chatrooms.filter((c) => !c.archivedAt && !c.temporary)
 
   // Incidents
-  const allIncidents = Object.values(loadSupervisorIncidents())
-  const recentIncidents = allIncidents.filter((i) => i.createdAt > oneDayAgo)
+  const recentIncidents = listAgentIncidents().filter((i) => i.createdAt > oneDayAgo)
   const warnings = recentIncidents.filter((i) => i.severity === 'medium').length
   const errors = recentIncidents.filter((i) => i.severity === 'high').length
 
@@ -348,8 +354,7 @@ export function buildSituationalAwarenessBlock(input: SituationalAwarenessInput)
 
   const failedRuns = listPersistedRuns({ sessionId, status: 'failed', limit: 10 })
 
-  const allIncidents = loadSupervisorIncidents()
-  const incidents = Object.values(allIncidents).filter((i) => i.agentId === agentId)
+  const incidents = listAgentIncidents(agentId)
 
   const mission = missionId ? loadMission(missionId) : null