@swarmclawai/swarmclaw 1.2.3 → 1.2.5

package/src/lib/server/agents/main-agent-loop.ts

@@ -1,4 +1,5 @@
 import { hmrSingleton } from '@/lib/shared-utils'
+import { getMessages } from '@/lib/server/messages/message-repository'
 import type { GoalContract, Message, MessageToolEvent, Session } from '@/types'
 import { mergeGoalContracts, parseGoalContractFromText, parseMainLoopPlan, parseMainLoopReview } from '@/lib/server/agents/autonomy-contract'
 import {
@@ -12,6 +13,10 @@ import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
 import { buildMissionHeartbeatPrompt as buildMissionHeartbeatPromptFromMission, getMissionForSession } from '@/lib/server/missions/mission-service'
 import { loadSettings } from '@/lib/server/settings/settings-repository'
 import { getSession, loadSessions } from '@/lib/server/sessions/session-repository'
+import { deleteSessionWorkingState, loadSessionWorkingState, syncWorkingStateFromMainLoopState } from '@/lib/server/working-state/service'
+import { syncMainLoopToRunContext } from '@/lib/server/run-context'
+import { buildExecutionBrief, buildExecutionBriefContextBlock } from '@/lib/server/execution-brief'
+import { cleanText, cleanMultiline } from '@/lib/server/text-normalization'
 
 const LEGACY_META_LINE_RE = /\[(?:MAIN_LOOP_META|MAIN_LOOP_PLAN|MAIN_LOOP_REVIEW|AGENT_HEARTBEAT_META)\]\s*(\{[^\n]*\})?/i
 const HEARTBEAT_META_RE = /\[AGENT_HEARTBEAT_META\]\s*(\{[^\n]*\})/i
@@ -19,7 +24,7 @@ const MAX_PENDING_EVENTS = 16
 const MAX_TIMELINE_ITEMS = 40
 const MAX_WORKING_MEMORY_NOTES = 12
 const DEFAULT_FOLLOWUP_DELAY_MS = 1500
-const DEFAULT_MAX_FOLLOWUP_CHAIN = 4
+const DEFAULT_MAX_FOLLOWUP_CHAIN = 3
 const MAX_LIFETIME_ITERATIONS = 200
 
 export interface MainLoopState {
@@ -111,24 +116,6 @@ function asSession(session: unknown): MainSessionLike | null {
   return session as MainSessionLike
 }
 
-function cleanText(value: unknown, maxChars = 320): string | null {
-  if (typeof value !== 'string') return null
-  const normalized = value.replace(/\s+/g, ' ').trim()
-  return normalized ? normalized.slice(0, maxChars) : null
-}
-
-function cleanMultiline(value: unknown, maxChars = 1400): string | null {
-  if (typeof value !== 'string') return null
-  const normalized = value
-    .split('\n')
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .join('\n')
-    .slice(0, maxChars)
-    .trim()
-  return normalized || null
-}
-
 function normalizeConfidence(value: unknown): number | null {
   const raw = typeof value === 'number'
     ? value
@@ -403,7 +390,7 @@ function hydrateStateFromSession(sessionId: string): MainLoopState | null {
   const session = sessions[sessionId]
   if (!session || !isMainSession(session)) return null
 
-  const messages = Array.isArray(session.messages) ? session.messages : []
+  const messages = getMessages(sessionId)
   const hydrated = defaultState()
   hydrated.autonomyMode = session.heartbeatEnabled === true ? 'autonomous' : 'assist'
   hydrated.updatedAt = typeof session.lastActiveAt === 'number' ? session.lastActiveAt : now()
@@ -440,21 +427,48 @@ function hydrateStateFromSession(sessionId: string): MainLoopState | null {
     }
   }
 
-  return normalizeState(hydrated)
+  return mergeWorkingStateIntoMainLoopState(sessionId, normalizeState(hydrated))
 }
 
 function persistState(sessionId: string, state: MainLoopState): void {
-  upsertPersistedMainLoopState(sessionId, state as unknown as Record<string, unknown>)
+  const normalized = clampState(state)
+  upsertPersistedMainLoopState(sessionId, normalized as unknown as Record<string, unknown>)
+  const session = getSession(sessionId)
+  if (!session) return
+  const mission = getMissionForSession(session)
+  void syncWorkingStateFromMainLoopState({
+    sessionId,
+    mission,
+    goal: normalized.goal,
+    summary: normalized.summary,
+    status: normalized.status === 'ok'
+      ? 'completed'
+      : normalized.status === 'blocked'
+        ? 'blocked'
+        : normalized.status === 'progress'
+          ? 'progress'
+          : 'idle',
+    nextAction: normalized.nextAction,
+    planSteps: normalized.planSteps,
+    blockers: normalized.skillBlocker ? [{
+      summary: normalized.skillBlocker.summary,
+      kind: normalized.skillBlocker.status === 'approval_requested' ? 'approval' : 'other',
+    }] : undefined,
+  })
 }
 
 function getOrCreateState(sessionId: string): MainLoopState | null {
   const existing = stateMap.get(sessionId)
-  if (existing) return existing
+  if (existing) {
+    const merged = mergeWorkingStateIntoMainLoopState(sessionId, existing)
+    stateMap.set(sessionId, merged)
+    return merged
+  }
 
   // Try disk (survives full restart)
   const persisted = loadPersistedMainLoopState(sessionId) as Partial<MainLoopState> | null
   if (persisted) {
-    const restored = normalizeState(persisted)
+    const restored = mergeWorkingStateIntoMainLoopState(sessionId, normalizeState(persisted))
     stateMap.set(sessionId, restored)
     return restored
   }
@@ -467,6 +481,43 @@ function getOrCreateState(sessionId: string): MainLoopState | null {
   return hydrated
 }
 
+function mergeWorkingStateIntoMainLoopState(sessionId: string, current: MainLoopState): MainLoopState {
+  const workingState = loadSessionWorkingState(sessionId)
+  if (!workingState) return clampState(current)
+  const next = normalizeState(current)
+  if (workingState.objective) next.goal = cleanMultiline(workingState.objective, 900)
+  if (workingState.summary) next.summary = cleanText(workingState.summary, 1000)
+  if (workingState.nextAction) next.nextAction = cleanText(workingState.nextAction, 240)
+  if (workingState.status === 'completed') next.status = 'ok'
+  else if (workingState.status === 'blocked' || workingState.status === 'waiting') next.status = 'blocked'
+  else if (workingState.status === 'progress') next.status = 'progress'
+
+  const planSteps = (workingState.planSteps || [])
+    .map((step) => cleanText(step.text, 240))
+    .filter((step): step is string => Boolean(step))
+  if (planSteps.length > 0) {
+    next.planSteps = uniqueStrings(planSteps, 8)
+    next.completedPlanSteps = uniqueStrings(
+      (workingState.planSteps || [])
+        .filter((step) => step.status === 'resolved')
+        .map((step) => cleanText(step.text, 240))
+        .filter((step): step is string => Boolean(step)),
+      16,
+    )
+    const activeStep = (workingState.planSteps || []).find((step) => step.status === 'active')
+    if (activeStep?.text) next.currentPlanStep = cleanText(activeStep.text, 240)
+  }
+
+  const noteCandidates = [
+    ...(workingState.confirmedFacts || []).filter((item) => item.status === 'active').map((item) => `Fact: ${item.statement}`),
+    ...(workingState.blockers || []).filter((item) => item.status === 'active').map((item) => `Blocker: ${item.summary}`),
+  ]
+  if (noteCandidates.length > 0) {
+    next.workingMemoryNotes = uniqueStrings([...(next.workingMemoryNotes || []), ...noteCandidates], MAX_WORKING_MEMORY_NOTES)
+  }
+  return clampState(next)
+}
+
 function summarizePendingEvents(events: MainLoopState['pendingEvents']): string {
   if (!events.length) return ''
   return events
@@ -754,39 +805,38 @@ export function buildMainLoopHeartbeatPrompt(session: unknown, fallbackPrompt: s
   const state = getOrCreateState(String(candidate.id))
   if (!state) return fallbackPrompt
   const latestExternalGoal = extractLatestGoal(Array.isArray(candidate.messages) ? candidate.messages as Message[] : [])
-  const effectiveGoal = state.goal || latestExternalGoal.goal
   const effectiveGoalContract = latestExternalGoal.goalContract
     ? mergeGoalContracts(state.goalContract, latestExternalGoal.goalContract)
     : state.goalContract
 
-  const completedSet = new Set(state.completedPlanSteps.map((s) => s.toLowerCase()))
-  const planLines = state.planSteps.length > 0
-    ? state.planSteps.slice(0, 8).map((step, index) => {
-      const isDone = completedSet.has(step.toLowerCase())
-      return `${index + 1}. ${isDone ? '[DONE] ' : ''}${step}`
-    }).join('\n')
-    : ''
+  const heartbeatSession = (persistedSession || candidate as Session)
+  const executionBrief = buildExecutionBrief({
+    session: heartbeatSession,
+    mission: getMissionForSession(heartbeatSession),
+  })
+  const executionBriefBlock = buildExecutionBriefContextBlock(executionBrief)
   const boundedFallbackPrompt = cleanMultiline(fallbackPrompt, 500)
-  const boundedSummary = cleanMultiline(state.summary, 500)
+  const workingState = loadSessionWorkingState(String(candidate.id))
+  const activeWorkingBlockers = (workingState?.blockers || [])
+    .filter((item) => item.status === 'active')
+    .map((item) => item.nextAction ? `${item.summary} | next: ${item.nextAction}` : item.summary)
+    .slice(0, 4)
+    .join('\n')
 
   return [
     'MAIN_AGENT_HEARTBEAT_TICK',
     `Time: ${new Date().toISOString()}`,
-    effectiveGoal ? `Current goal:\n${effectiveGoal}` : '',
+    executionBriefBlock,
     formatGoalContract(effectiveGoalContract),
-    `Current status: ${state.status}`,
-    state.nextAction ? `Planned next action: ${state.nextAction}` : '',
-    state.currentPlanStep ? `Current plan step: ${state.currentPlanStep}` : '',
-    planLines ? `Plan:\n${planLines}` : '',
     state.pendingEvents.length > 0 ? `Pending external events:\n${summarizePendingEvents(state.pendingEvents)}` : '',
+    activeWorkingBlockers ? `Active blockers:\n${activeWorkingBlockers}` : '',
     state.skillBlocker ? `Active skill blocker:\n${summarizeSkillBlocker(state.skillBlocker)}` : '',
     summarizeSelectedSkillRuntime(candidate),
-    boundedSummary ? `Latest summary:\n${boundedSummary}` : '',
     boundedFallbackPrompt ? `Base heartbeat instructions:\n${boundedFallbackPrompt}` : '',
     '',
     'You are checking the durable main mission thread for this agent.',
     'Keep this status check brief — 5-10 tool calls maximum. Read key state, summarize progress, and report. Do not attempt fixes or deep investigation during heartbeats.',
-    'Use only the current goal, plan, next action, and pending external events shown above.',
+    'Use the execution brief and pending external events shown above as the authoritative state for this tick.',
     'Do not infer or repeat old tasks from prior heartbeats.',
     'Prefer taking the single highest-value next step over restating the plan. Do not repeat completed work.',
     'If you revise the plan, emit exactly one line like:',
@@ -827,6 +877,7 @@ export function getMainLoopStateForSession(sessionId: string): MainLoopState | n
 
 export function clearMainLoopStateForSession(sessionId: string): boolean {
   deletePersistedMainLoopState(sessionId)
+  deleteSessionWorkingState(sessionId)
   return stateMap.delete(sessionId)
 }
 
@@ -840,6 +891,7 @@ export function pruneMainLoopState(liveSessionIds: Set<string>): number {
     if (!liveSessionIds.has(sessionId)) {
       stateMap.delete(sessionId)
       deletePersistedMainLoopState(sessionId)
+      deleteSessionWorkingState(sessionId)
       removed++
     }
   }
@@ -1096,5 +1148,11 @@ export function handleMainLoopRunResult(input: HandleMainLoopRunResultInput): Ma
   const finalClamped = clampState(state)
   stateMap.set(input.sessionId, finalClamped)
   persistState(input.sessionId, finalClamped)
+
+  // Project orchestrator state into session RunContext (non-critical)
+  try {
+    syncMainLoopToRunContext(input.sessionId, finalClamped)
+  } catch { /* non-critical — main loop continues even if sync fails */ }
+
   return followup
 }

package/src/lib/server/agents/subagent-runtime.ts

@@ -49,6 +49,8 @@ import { logExecution } from '@/lib/server/execution-log'
 import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
 import { getEnabledCapabilityIds, splitCapabilityIds } from '@/lib/capability-selection'
 import { getSession, loadSessions, saveSession } from '@/lib/server/sessions/session-repository'
+import { ensureRunContext } from '@/lib/server/run-context'
+import { buildExecutionBrief, serializeExecutionBriefForDelegation } from '@/lib/server/execution-brief'
 
 // ---------------------------------------------------------------------------
 // Types
@@ -277,6 +279,16 @@ async function spawnSubagentImpl(
     browserProfileId,
   }
   sessions[sid] = applyResolvedRoute(nextSession, resolvePrimaryAgentRoute(agent))
+
+  // Enrich child session with parent's RunContext for delegation handoff
+  const delegationContext = parent ? serializeExecutionBriefForDelegation(buildExecutionBrief({ sessionId: context.sessionId })) : null
+  if (delegationContext) {
+    const childCtx = ensureRunContext(null)
+    childCtx.parentContext = delegationContext
+    childCtx.objective = input.message.slice(0, 900)
+    sessions[sid].runContext = childCtx
+  }
+
   saveSession(sid, sessions[sid])
 
   log.info('subagent', 'Spawning', { agentId: agent.id, agentName: agent.name, depth: depth + 1, jobId: job.id, sessionId: sid })

package/src/lib/server/autonomy/supervisor-reflection.test.ts

@@ -228,7 +228,26 @@ describe('supervisor-reflection', () => {
           model: 'gpt-test',
           claudeSessionId: null,
           messages: [
-            { role: 'user', text: 'I am moving to Lisbon next month and prefer short check-ins while I am juggling the move.', time: 1 },
+            {
+              role: 'user',
+              text: 'I am moving to Lisbon next month and prefer short check-ins while I am juggling the move.',
+              time: 1,
+              semantics: {
+                taskIntent: 'general',
+                workType: 'general',
+                walletIntent: 'none',
+                isDeliverableTask: false,
+                isBroadGoal: false,
+                isResearchSynthesis: false,
+                hasHumanSignals: true,
+                hasSignificantEvent: true,
+                wantsScreenshots: false,
+                wantsOutboundDelivery: false,
+                wantsVoiceDelivery: false,
+                explicitToolRequests: [],
+                confidence: 0.98,
+              },
+            },
             { role: 'assistant', text: 'Understood. I will keep updates tight and remember the move timing.', time: 2 },
           ],
           createdAt: 1,

package/src/lib/server/autonomy/supervisor-reflection.ts

@@ -33,14 +33,16 @@ import { log } from '@/lib/server/logger'
 import { logExecution } from '@/lib/server/execution-log'
 import { logActivity } from '@/lib/server/storage'
 import { createNotification } from '@/lib/server/create-notification'
+import { foldReflectionIntoRunContext } from '@/lib/server/run-context'
+import { getSession, saveSession } from '@/lib/server/sessions/session-repository'
+import { cleanText } from '@/lib/server/text-normalization'
+import { getMessages, getMessageCount, getRecentMessages } from '@/lib/server/messages/message-repository'
 
 const TAG = 'supervisor-reflection'
 
 const MAIN_LOOP_META_LINE_RE = /\[(?:MAIN_LOOP_META|MAIN_LOOP_PLAN|MAIN_LOOP_REVIEW|AGENT_HEARTBEAT_META)\]\s*(\{[^\n]*\})?/i
 const DEFAULT_TRANSCRIPT_MESSAGES = 12
 const DEFAULT_SNIPPET_CHARS = 800
-const HUMAN_SIGNAL_RE = /\b(?:prefer|please|call me|don't call me|do not call me|i like|i dislike|i hate|i love|my pronouns|my partner|my wife|my husband|my kid|my child|my mom|my dad|my sister|my brother|birthday|anniversary|wedding|married|divorc|pregnan|baby|moved|moving|relocat|promotion|promoted|laid off|new job|job change|graduat|hospital|sick|illness|diagnos|passed away|funeral|grief|bereave|deadline|launch|fundraising|closing|house|home|travel)\b/i
-const SIGNIFICANT_EVENT_RE = /\b(?:birthday|anniversary|wedding|married|divorc|pregnan|baby|moved|moving|relocat|promotion|promoted|laid off|new job|job change|graduat|hospital|sick|illness|diagnos|passed away|funeral|grief|bereave|deadline|launch|fundraising|closing|house|home|travel)\b/i
 
 export interface SupervisorStateSnapshot {
   followupChainCount?: number | null
@@ -81,13 +83,6 @@ function now(): number {
   return Date.now()
 }
 
-function cleanText(value: unknown, max = 320): string | null {
-  if (typeof value !== 'string') return null
-  const compact = value.replace(/\s+/g, ' ').trim()
-  if (!compact) return null
-  return compact.slice(0, max)
-}
-
 function looksLikeHtmlErrorPayload(value: string): boolean {
   const normalized = value.toLowerCase()
   let matches = 0
@@ -189,9 +184,11 @@ function buildIncident(
 }
 
 function sessionContextPressure(session: Session | null): boolean {
-  if (!session || !Array.isArray(session.messages)) return false
-  if (session.messages.length >= 60) return true
-  const totalChars = session.messages.reduce((sum, message) => sum + String(message?.text || '').length, 0)
+  if (!session) return false
+  const msgCount = getMessageCount(session.id)
+  if (msgCount >= 60) return true
+  const messages = getMessages(session.id)
+  const totalChars = messages.reduce((sum, message) => sum + String(message?.text || '').length, 0)
   return totalChars >= 18_000
 }
 
@@ -428,7 +425,7 @@ export async function executeSupervisorAutoActions(params: {
 }
 
 function buildSessionTranscript(session: Session, maxMessages = DEFAULT_TRANSCRIPT_MESSAGES): string {
-  const messages = Array.isArray(session.messages) ? session.messages.slice(-maxMessages) : []
+  const messages = getRecentMessages(session.id, maxMessages)
   const lines: string[] = []
   for (const message of messages) {
     if (!message || message.suppressed) continue
@@ -543,10 +540,21 @@ function normalizeNoteArray(value: unknown, limit = 4): string[] {
   return out
 }
 
+function transcriptHasSemanticSignal(
+  session: Session | null,
+  signal: 'hasHumanSignals' | 'hasSignificantEvent',
+): boolean {
+  if (!session) return false
+  const recentMessages = getRecentMessages(session.id, 8)
+  return recentMessages.some((message) => message?.role === 'user' && message?.semantics?.[signal] === true)
+}
+
 function transcriptHasHumanSignals(session: Session | null): boolean {
-  if (!session || !Array.isArray(session.messages)) return false
-  const recentMessages = session.messages.slice(-8)
-  return recentMessages.some((message) => HUMAN_SIGNAL_RE.test(stripMainLoopMeta(String(message?.text || ''))))
+  return transcriptHasSemanticSignal(session, 'hasHumanSignals')
+}
+
+function transcriptHasSignificantEvents(session: Session | null): boolean {
+  return transcriptHasSemanticSignal(session, 'hasSignificantEvent')
 }
 
 function parseReflectionResponse(raw: string): {
@@ -658,10 +666,11 @@ function shouldReflectRun(params: {
   if (!surface || !runtimeScopeIncludes(params.runtimeScope, surface)) return false
   if (params.status === 'cancelled') return false
   if (surface === 'task') return Boolean(params.resultText.trim() || params.incidents.length > 0)
-  const meaningfulMessages = Array.isArray(params.session?.messages)
-    ? params.session.messages.filter((message) => message && !message.suppressed && (message.text || message.toolEvents?.length)).length
+  const meaningfulMessages = params.session
+    ? getMessages(params.session.id).filter((message) => message && !message.suppressed && (message.text || message.toolEvents?.length)).length
     : 0
   if (transcriptHasHumanSignals(params.session)) return true
+  if (transcriptHasSignificantEvents(params.session)) return true
   if (params.incidents.length > 0) return true
   if (params.toolEvents.length > 0) return true
   if (params.resultText.trim().length >= 180) return true
@@ -788,7 +797,7 @@ function writeReflectionMemories(params: {
       }
       if (group.kind === 'significant_event') {
         metadata.memoryFacet = 'event'
-        metadata.eventSalience = SIGNIFICANT_EVENT_RE.test(note) ? 'high' : 'medium'
+        metadata.eventSalience = 'high'
       }
       if (group.kind === 'open_loop') {
         metadata.memoryFacet = 'followup'
@@ -1095,6 +1104,17 @@ export async function observeAutonomyRunOutcome(
   reflections[reflection.id] = reflection
   saveRunReflections(reflections)
 
+  // Fold reflection notes into session RunContext (non-critical)
+  try {
+    const freshSession = getSession(input.sessionId) as Session | undefined
+    if (freshSession) {
+      freshSession.runContext = foldReflectionIntoRunContext(freshSession.runContext, reflection)
+      saveSession(input.sessionId, freshSession)
+    }
+  } catch (err: unknown) {
+    log.warn(TAG, 'RunContext reflection folding failed:', err instanceof Error ? err.message : String(err))
+  }
+
   // Quality degradation alert — if recent quality trend drops below 0.5
   if (typeof reflection.qualityScore === 'number' && input.agentId) {
     checkQualityDegradation(input.agentId).catch(() => {})

package/src/lib/server/build-llm.ts

@@ -1,11 +1,13 @@
 import { ChatAnthropic } from '@langchain/anthropic'
 import { ChatOpenAI } from '@langchain/openai'
-import { loadCredentials, decryptKey, loadAgents, loadSessions } from './storage'
 import { getProviderList } from '../providers'
 import { normalizeOpenClawEndpoint } from '@/lib/openclaw/openclaw-endpoint'
 import { NON_LANGGRAPH_PROVIDER_IDS } from '../provider-sets'
 import { resolveOllamaRuntimeConfig } from './ollama-runtime'
 import { resolveProviderApiEndpoint, resolveProviderCredentialId } from './provider-endpoint'
+import { getAgent } from './agents/agent-repository'
+import { resolveCredentialSecret } from './credentials/credential-service'
+import { getSession } from './sessions/session-repository'
 import type { Agent } from '@/types'
 
 const OLLAMA_CLOUD_URL = 'https://ollama.com/v1'
@@ -135,15 +137,7 @@ export function buildChatModel(opts: {
 }
 
 function resolveApiKeyFromCredential(credentialId: string | null | undefined): string | null {
-  if (!credentialId) return null
-  const creds = loadCredentials()
-  const cred = creds[credentialId]
-  if (!cred?.encryptedKey) return null
-  try {
-    return decryptKey(cred.encryptedKey)
-  } catch {
-    return null
-  }
+  return resolveCredentialSecret(credentialId)
 }
 
 function normalizePreferenceValue(value: string | null | undefined): string {
@@ -222,12 +216,10 @@ export function resolveGenerationModelConfig(options?: {
   excludeProviders?: string[]
 }): ResolvedGenerationModelConfig {
   const providers = getProviderList()
-  const agents = loadAgents()
-  const sessions = loadSessions()
   const excludeProviders = new Set((options?.excludeProviders || []).map((value) => normalizePreferenceValue(value)).filter(Boolean))
-  const session = options?.sessionId ? sessions[options.sessionId] : null
-  const sessionAgent = session?.agentId ? agents[session.agentId] as Agent | undefined : null
-  const directAgent = options?.agentId ? agents[options.agentId] as Agent | undefined : null
+  const session = options?.sessionId ? getSession(options.sessionId) : null
+  const sessionAgent = session?.agentId ? getAgent(session.agentId) as Agent | null : null
+  const directAgent = options?.agentId ? getAgent(options.agentId) as Agent | null : null
   const resolved = resolvePreferredGenerationConfig(providers, [
     ...(Array.isArray(options?.preferred) ? options?.preferred : options?.preferred ? [options.preferred] : []),
     ...(session ? [{

package/src/lib/server/capability-router.test.ts

@@ -1,12 +1,14 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
 import { routeTaskIntent } from './capability-router'
+import type { MessageClassification } from '@/lib/server/chat-execution/message-classifier'
 
 test('routeTaskIntent keeps recall-style prompts as general intent', () => {
   const decision = routeTaskIntent(
     'What token did we store earlier as e2e_validation_token? Reply only with the token.',
     ['memory', 'web_search'],
     null,
+    makeClassification({ taskIntent: 'general' }),
   )
   assert.equal(decision.intent, 'general')
 })
@@ -16,6 +18,7 @@ test('routeTaskIntent keeps coding prompts prioritized over memory keywords', ()
     'Build and test a calculator app, then remember the final path in memory.',
     ['memory', 'shell', 'files'],
     null,
+    makeClassification({ taskIntent: 'coding', workType: 'coding' }),
   )
   assert.equal(decision.intent, 'coding')
 })
@@ -25,6 +28,14 @@ test('routeTaskIntent keeps hybrid research-plus-media prompts in research inten
     'Can you tell me more if there is any news related to the US-Iran war, and can you send me some screenshots and give me a summary and maybe send me a voice note about it?',
     ['web_search', 'web_fetch', 'browser', 'manage_connectors'],
     null,
+    makeClassification({
+      taskIntent: 'research',
+      workType: 'research',
+      wantsScreenshots: true,
+      wantsVoiceDelivery: true,
+      wantsOutboundDelivery: true,
+      isResearchSynthesis: true,
+    }),
   )
 
   assert.equal(decision.intent, 'research')
@@ -36,6 +47,12 @@ test('routeTaskIntent treats direct voice-note delivery as outreach', () => {
     'Send me a voice note over WhatsApp summarizing what changed.',
     ['manage_connectors'],
     null,
+    makeClassification({
+      taskIntent: 'outreach',
+      workType: 'writing',
+      wantsVoiceDelivery: true,
+      wantsOutboundDelivery: true,
+    }),
   )
 
   assert.equal(decision.intent, 'outreach')
@@ -45,10 +62,62 @@ test('routeTaskIntent treats direct voice-note delivery as outreach', () => {
 test('routeTaskIntent treats keep-watching update requests as research even without explicit news keywords', () => {
   const decision = routeTaskIntent(
     'Tell me about the Iran war, keep watching for meaningful updates, and avoid duplicate reminders.',
-    ['web_search', 'manage_schedules'],
+    ['web_search', 'web_fetch', 'manage_schedules'],
     null,
+    makeClassification({
+      taskIntent: 'research',
+      workType: 'research',
+      isResearchSynthesis: true,
+    }),
   )
 
   assert.equal(decision.intent, 'research')
   assert.deepEqual(decision.preferredTools, ['web_search', 'web_fetch'])
 })
+
+test('routeTaskIntent uses structured classification when available', () => {
+  const classification: MessageClassification = {
+    taskIntent: 'browsing',
+    isDeliverableTask: true,
+    isBroadGoal: false,
+    walletIntent: 'none',
+    hasHumanSignals: false,
+    hasSignificantEvent: false,
+    isResearchSynthesis: true,
+    workType: 'research',
+    wantsScreenshots: true,
+    wantsOutboundDelivery: false,
+    wantsVoiceDelivery: false,
+    explicitToolRequests: ['browser'],
+    confidence: 0.92,
+  }
+
+  const decision = routeTaskIntent(
+    'Review this story and show me screenshots.',
+    ['web_search', 'web_fetch', 'browser'],
+    null,
+    classification,
+  )
+
+  assert.equal(decision.intent, 'browsing')
+  assert.deepEqual(decision.preferredTools, ['browser', 'web_fetch'])
+})
+
+function makeClassification(overrides: Partial<MessageClassification>): MessageClassification {
+  return {
+    taskIntent: 'general',
+    isDeliverableTask: false,
+    isBroadGoal: false,
+    walletIntent: 'none',
+    hasHumanSignals: false,
+    hasSignificantEvent: false,
+    isResearchSynthesis: false,
+    workType: 'general',
+    wantsScreenshots: false,
+    wantsOutboundDelivery: false,
+    wantsVoiceDelivery: false,
+    explicitToolRequests: [],
+    confidence: 0.9,
+    ...overrides,
+  }
+}