@swarmclawai/swarmclaw 1.2.3 → 1.2.5

package/src/lib/server/chat-execution/chat-turn-tool-routing.test.ts

@@ -439,6 +439,51 @@ describe('chat-turn-tool-routing', () => {
     assert.equal(result.calledNames.has('memory_search'), true)
   })
 
+  it('uses classifier-backed memory list fallback for broad memory inventory requests', async () => {
+    const invocations: Array<{ toolName: string; args: Record<string, unknown> }> = []
+    const result = await runPostLlmToolRouting({
+      session: {
+        cwd: process.cwd(),
+        tools: ['memory'],
+      },
+      sessionId: 'session-memory-list',
+      message: 'List everything you remember about me.',
+      effectiveMessage: 'List everything you remember about me.',
+      enabledExtensions: ['memory'],
+      toolPolicy: resolveSessionToolPolicy(['memory'], {}),
+      appSettings: {},
+      internal: false,
+      source: 'chat',
+      toolEvents: [],
+      emit: () => {},
+    }, '', undefined, {
+      classifyDirectMemoryIntent: async () => ({
+        action: 'list',
+        confidence: 0.91,
+      }),
+      invokeTool: async (_ctx, toolName, args, _failurePrefix, calledNames) => {
+        invocations.push({ toolName, args })
+        calledNames.add(toolName)
+        return {
+          invoked: true,
+          responseOverride: null,
+          toolOutputText: '[mem_1] favorite editor: Neovim\n[mem_2] timezone: Europe/Isle_of_Man',
+        }
+      },
+    })
+
+    assert.equal(invocations.length, 1)
+    assert.equal(invocations[0].toolName, 'memory_tool')
+    assert.deepEqual(invocations[0].args, {
+      action: 'list',
+      key: '',
+      scope: 'auto',
+    })
+    assert.equal(result.fullResponse, '[mem_1] favorite editor: Neovim\n[mem_2] timezone: Europe/Isle_of_Man')
+    assert.equal(result.errorMessage, undefined)
+    assert.equal(result.calledNames.has('memory_tool'), true)
+  })
+
   it('fails open when post-LLM memory classification times out', async () => {
     let invoked = false
     const started = Date.now()

package/src/lib/server/chat-execution/chat-turn-tool-routing.ts

@@ -22,6 +22,7 @@ import { log } from '@/lib/server/logger'
 import { rankDelegatesByHealth } from '@/lib/server/provider-health'
 import { routeTaskIntent, type CapabilityRoutingDecision } from '@/lib/server/capability-router'
 import { canonicalizeExtensionId, extensionIdMatches } from '@/lib/server/tool-aliases'
+import { classifyMessage, type MessageClassification } from '@/lib/server/chat-execution/message-classifier'
 import {
   buildDirectMemoryRecallResponse,
   classifyDirectMemoryIntent,
@@ -37,7 +38,6 @@ import {
   findFirstUrl,
   hasToolEnabled,
   hasDirectLocalCodingTools,
-  isMemoryListIntent,
   requestedToolNamesFromMessage,
   translateRequestedToolInvocation,
 } from '@/lib/server/chat-execution/chat-execution-utils'
@@ -61,6 +61,7 @@ export interface ToolRoutingContext {
   source: string
   toolEvents: MessageToolEvent[]
   emit: (ev: SSEEvent) => void
+  classification?: MessageClassification | null
 }
 
 export interface ToolRoutingResult {
@@ -126,6 +127,16 @@ async function resolveDirectMemoryIntentWithTimeout(
   }
 }
 
+async function resolveTurnClassification(ctx: ToolRoutingContext): Promise<MessageClassification | null> {
+  if (ctx.classification !== undefined) return ctx.classification ?? null
+  if (ctx.internal || ctx.source !== 'chat') return null
+  return classifyMessage({
+    sessionId: ctx.sessionId,
+    agentId: ctx.session.agentId || null,
+    message: ctx.message,
+  }).catch(() => null)
+}
+
 export async function runExclusiveDirectMemoryPreflight(
   ctx: ToolRoutingContext,
   hooks?: ToolRoutingHooks,
@@ -148,14 +159,18 @@ export async function runExclusiveDirectMemoryPreflight(
     ? 'memory_store'
     : directMemoryIntent.action === 'update'
       ? 'memory_update'
-      : 'memory_search'
+      : directMemoryIntent.action === 'list'
+        ? 'memory_tool'
+        : 'memory_search'
 
   const args: Record<string, unknown> = directMemoryIntent.action === 'recall'
     ? { query: directMemoryIntent.query, scope: 'auto' }
-    : {
-        value: directMemoryIntent.value,
-        ...(directMemoryIntent.title ? { title: directMemoryIntent.title } : {}),
-      }
+    : directMemoryIntent.action === 'list'
+      ? { action: 'list', key: '', scope: 'auto' }
+      : {
+          value: directMemoryIntent.value,
+          ...(directMemoryIntent.title ? { title: directMemoryIntent.title } : {}),
+        }
 
   const result = await invokeTool(
     ctx,
@@ -192,6 +207,15 @@ export async function runExclusiveDirectMemoryPreflight(
     }
   }
 
+  if (directMemoryIntent.action === 'list') {
+    return {
+      calledNames,
+      fullResponse: String(result.toolOutputText || '').trim() || 'No memories found.',
+      errorMessage: undefined,
+      missedRequestedTools: [],
+    }
+  }
+
   if (directMemoryIntent.action === 'recall') {
     const recallResponse = result.toolOutputText
       ? buildDirectMemoryRecallResponse(directMemoryIntent, result.toolOutputText)
@@ -494,12 +518,13 @@ export async function runPostLlmToolRouting(
   const unavailableRequestedTools = new Map<string, string>()
   let fullResponse = currentResponse
   let errorMessage = currentError
+  const classification = await resolveTurnClassification(ctx)
 
   const requestedToolNames = (!ctx.internal && ctx.source === 'chat')
     ? requestedToolNamesFromMessage(ctx.message)
     : []
   const routingDecision: CapabilityRoutingDecision | null = (!ctx.internal && ctx.source === 'chat')
-    ? routeTaskIntent(ctx.message, ctx.enabledExtensions, ctx.appSettings)
+    ? routeTaskIntent(ctx.message, ctx.enabledExtensions, ctx.appSettings, classification)
     : null
 
   // --- Forced connector_message_tool ---
@@ -609,6 +634,22 @@ export async function runPostLlmToolRouting(
     }
   }
 
+  if (directMemoryIntent?.action === 'list') {
+    const result = await invokeTool(
+      ctx,
+      'memory_tool',
+      { action: 'list', key: '', scope: 'auto' },
+      'Forced memory list invocation failed',
+      calledNames,
+    )
+    if (result.blockedReason) policyBlockedTools.set('memory_tool', result.blockedReason)
+    if (result.unavailableReason) unavailableRequestedTools.set('memory_tool', result.unavailableReason)
+    if (result.invoked) {
+      fullResponse = String(result.toolOutputText || '').trim() || 'No memories found.'
+      errorMessage = undefined
+    }
+  }
+
   // --- Auto-delegation for coding intent ---
   const hasDelegationCall = FORCED_DELEGATION_TOOLS.some((t) => calledNames.has(t))
   const enabledDelegates = enabledDelegationTools(ctx.session)
@@ -690,16 +731,6 @@ export async function runPostLlmToolRouting(
     }
   }
 
-  if (canAutoRoute && calledNames.size === 0 && hasToolEnabled(ctx.session, 'memory') && isMemoryListIntent(ctx.message)) {
-    const result = await invokeTool(
-      ctx, 'memory_tool',
-      { action: 'list', key: '', scope: 'auto' },
-      'Auto memory listing failed',
-      calledNames,
-    )
-    if (result.responseOverride) fullResponse = result.responseOverride
-  }
-
   const explicitArtifactTarget = extractExplicitArtifactTarget(ctx.message)
   const canAutoSaveArtifact = (!ctx.internal && ctx.source === 'chat')
     && !!explicitArtifactTarget

package/src/lib/server/chat-execution/continuation-evaluator.ts

@@ -42,6 +42,8 @@ export interface ContinuationContext {
   sessionExtensions: string[]
   isConnectorSession: boolean
   isCoordinatorAgent: boolean
+  delegationEnabled: boolean
+  delegationPreferenceActive: boolean
   history: Message[]
   session: { cwd: string }
   write: (data: string) => void
@@ -279,6 +281,7 @@ function checkAttachmentFollowthrough(ctx: ContinuationContext): ContinuationDec
     enabledExtensions: ctx.sessionExtensions,
     hasToolCalls: ctx.state.hasToolCalls,
     hasAttachmentContext: ctx.hasAttachmentContext,
+    classification: ctx.classification,
   })) return null
   const count = ctx.limits.increment('attachment_followthrough')
   const { max } = ctx.limits.getStatus('attachment_followthrough')
@@ -335,7 +338,7 @@ function checkToolErrorFollowthrough(ctx: ContinuationContext): ContinuationDeci
 }
 
 function checkCoordinatorDelegation(ctx: ContinuationContext): ContinuationDecision | null {
-  if (!ctx.isCoordinatorAgent) return null
+  if (!ctx.delegationEnabled || !ctx.delegationPreferenceActive) return null
   if (!ctx.limits.canContinue('coordinator_delegation_nudge')) return null
   // Skip if already delegated
   const delegationTools = ['spawn_subagent', 'manage_protocols']

package/src/lib/server/chat-execution/direct-memory-intent.test.ts

@@ -46,6 +46,15 @@ describe('direct-memory-intent', () => {
     })
   })
 
+  it('parses a list classification payload', () => {
+    const parsed = parseDirectMemoryIntentResponse('{"action":"list","confidence":0.84}')
+
+    assert.deepEqual(parsed, {
+      action: 'list',
+      confidence: 0.84,
+    })
+  })
+
   it('parses exclusive completion for pure memory turns', () => {
     const parsed = parseDirectMemoryIntentResponse('{"action":"store","confidence":0.98,"title":"Launch marker","value":"My launch marker is ALPHA-9","acknowledgement":"I\\u2019ll remember that.","exclusiveCompletion":true}')
 

package/src/lib/server/chat-execution/direct-memory-intent.ts

@@ -4,7 +4,7 @@ import type { MessageToolEvent } from '@/types'
 import { buildLLM } from '@/lib/server/build-llm'
 
 const DirectMemoryIntentResponseSchema = z.object({
-  action: z.enum(['none', 'store', 'update', 'recall']),
+  action: z.enum(['none', 'store', 'update', 'recall', 'list']),
   confidence: z.number().min(0).max(1).optional(),
   title: z.string().optional().nullable(),
   value: z.string().optional().nullable(),
@@ -18,6 +18,7 @@ export type DirectMemoryIntent =
   | { action: 'none'; confidence: number }
   | { action: 'store'; confidence: number; title?: string; value: string; acknowledgement: string; exclusiveCompletion: boolean }
   | { action: 'update'; confidence: number; title?: string; value: string; acknowledgement: string; exclusiveCompletion: boolean }
+  | { action: 'list'; confidence: number }
   | { action: 'recall'; confidence: number; query: string; missResponse: string }
 
 export interface DirectMemoryIntentClassifierInput {
@@ -122,6 +123,13 @@ export function parseDirectMemoryIntentResponse(text: string): DirectMemoryInten
     }
   }
 
+  if (parsed.data.action === 'list') {
+    return {
+      action: 'list',
+      confidence,
+    }
+  }
+
   const query = normalizeText(parsed.data.query)
   if (!query) return null
   return {
@@ -153,15 +161,17 @@ function buildDirectMemoryIntentPrompt(input: DirectMemoryIntentClassifierInput)
     'Rules:',
     '- Choose "store" when the user wants a new durable fact, preference, decision, or profile detail remembered.',
     '- Choose "update" when the user is correcting or replacing previously remembered information.',
+    '- Choose "list" when the user wants a broad inventory of stored memories or asks what the assistant remembers in general.',
     '- Choose "recall" when the user is asking what the assistant remembers from earlier interactions.',
     '- Choose "none" for ordinary conversation, current-thread-only questions, file/code/document work, and anything that should not touch durable memory.',
     '- Be conservative. If unsure, return {"action":"none","confidence":0}.',
     '- For "store" and "update", return the durable fact in "value" and a short natural user-facing acknowledgement in "acknowledgement". Do not mention tools, memory ids, storage, creation, or updating.',
     '- Set "exclusiveCompletion" to true only when a successful memory write fully satisfies the user turn and the assistant should stop after the acknowledgement. Set it to false when the user also asked for other work in the same turn.',
+    '- Choose "recall" for targeted lookups about a specific remembered fact. Choose "list" for broad inventory requests like listing memories or asking what is remembered overall.',
     '- For "recall", return a concise search query in "query" and a short natural "missResponse". Do not mention tools.',
     '',
     'Output shape:',
-    '{"action":"none|store|update|recall","confidence":0-1,"title":"optional short title","value":"for store/update","query":"for recall","acknowledgement":"for store/update","missResponse":"for recall","exclusiveCompletion":true}',
+    '{"action":"none|store|update|recall|list","confidence":0-1,"title":"optional short title","value":"for store/update","query":"for recall","acknowledgement":"for store/update","missResponse":"for recall","exclusiveCompletion":true}',
     '',
     `user_message: ${JSON.stringify(message)}`,
     `assistant_response: ${JSON.stringify(currentResponse)}`,

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

@@ -23,12 +23,14 @@ after(() => {
 
 describe('parseClassificationResponse', () => {
   const validJson = JSON.stringify({
+    taskIntent: 'general',
     isDeliverableTask: true,
     isBroadGoal: false,
     walletIntent: 'none',
     hasHumanSignals: false,
     hasSignificantEvent: false,
     isResearchSynthesis: false,
+    workType: 'general',
     explicitToolRequests: [],
     confidence: 0.9,
   })
@@ -39,6 +41,8 @@ describe('parseClassificationResponse', () => {
     assert.equal(result!.isDeliverableTask, true)
     assert.equal(result!.isBroadGoal, false)
     assert.equal(result!.walletIntent, 'none')
+    assert.equal(result!.taskIntent, 'general')
+    assert.equal(result!.workType, 'general')
     assert.equal(result!.confidence, 0.9)
     assert.deepEqual(result!.explicitToolRequests, [])
   })
@@ -55,12 +59,14 @@ describe('parseClassificationResponse', () => {
 
   it('tolerates extra keys in JSON', () => {
     const withExtra = JSON.stringify({
+      taskIntent: 'general',
       isDeliverableTask: true,
       isBroadGoal: false,
       walletIntent: 'none',
       hasHumanSignals: false,
       hasSignificantEvent: false,
       isResearchSynthesis: false,
+      workType: 'general',
       explicitToolRequests: ['shell'],
       confidence: 0.85,
       extraKey: 'should be ignored',
@@ -97,9 +103,10 @@ describe('isDeliverableTask', () => {
   })
 
   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')
+    assert.equal(
+      mod.isDeliverableTask(null, 'Create a detailed marketing report with competitor analysis and market sizing.'),
+      false,
+    )
   })
 })
 
@@ -114,8 +121,10 @@ describe('isBroadGoal', () => {
   })
 
   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')
+    assert.equal(
+      mod.isBroadGoal(null, 'I want to build a complete e-commerce platform with user authentication, product catalog, shopping cart, and payment processing'),
+      false,
+    )
   })
 })
 
@@ -137,8 +146,7 @@ describe('hasWalletIntent', () => {
   })
 
   it('falls back to regex when classification is null', () => {
-    const result = mod.hasWalletIntent(null, 'check my wallet balance')
-    assert.equal(typeof result, 'boolean')
+    assert.equal(mod.hasWalletIntent(null, 'check my wallet balance'), false)
   })
 })
 
@@ -154,8 +162,7 @@ describe('hasTransactionalWalletIntent', () => {
   })
 
   it('falls back to regex when classification is null', () => {
-    const result = mod.hasTransactionalWalletIntent(null, 'swap 1 ETH for USDC')
-    assert.equal(typeof result, 'boolean')
+    assert.equal(mod.hasTransactionalWalletIntent(null, 'swap 1 ETH for USDC'), false)
   })
 })
 
@@ -169,11 +176,8 @@ describe('hasHumanSignals', () => {
     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', () => {
+  it('returns false when classification is null', () => {
+    assert.equal(mod.hasHumanSignals(null, 'my birthday is next week'), false)
     assert.equal(mod.hasHumanSignals(null, 'deploy the app'), false)
   })
 })
@@ -188,12 +192,9 @@ describe('hasSignificantEvent', () => {
     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', () => {
+  it('returns false when classification is null', () => {
+    assert.equal(mod.hasSignificantEvent(null, 'I just got promoted at work'), false)
+    assert.equal(mod.hasSignificantEvent(null, 'my graduation ceremony is on Friday'), false)
     assert.equal(mod.hasSignificantEvent(null, 'fix the login bug'), false)
   })
 })
@@ -208,9 +209,9 @@ describe('isResearchSynthesis', () => {
     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)
+  it('returns false when classification is null', () => {
+    assert.equal(mod.isResearchSynthesis(null, 'research'), false)
+    assert.equal(mod.isResearchSynthesis(null, 'browsing'), false)
     assert.equal(mod.isResearchSynthesis(null, 'coding'), false)
     assert.equal(mod.isResearchSynthesis(null, null), false)
   })
@@ -223,12 +224,14 @@ describe('isResearchSynthesis', () => {
 describe('classifyMessage', () => {
   it('returns valid classification from mock generateText', async () => {
     const mockResponse = JSON.stringify({
+      taskIntent: 'coding',
       isDeliverableTask: true,
       isBroadGoal: false,
       walletIntent: 'none',
       hasHumanSignals: false,
       hasSignificantEvent: false,
       isResearchSynthesis: false,
+      workType: 'coding',
       explicitToolRequests: ['shell'],
       confidence: 0.95,
     })
@@ -240,7 +243,9 @@ describe('classifyMessage', () => {
 
     assert.ok(result)
     assert.equal(result!.isDeliverableTask, true)
+    assert.equal(result!.taskIntent, 'coding')
     assert.equal(result!.walletIntent, 'none')
+    assert.equal(result!.workType, 'coding')
     assert.deepEqual(result!.explicitToolRequests, ['shell'])
   })
 
@@ -276,12 +281,14 @@ describe('classifyMessage', () => {
   it('caches results for the same message', async () => {
     let callCount = 0
     const mockResponse = JSON.stringify({
+      taskIntent: 'general',
       isDeliverableTask: false,
       isBroadGoal: false,
       walletIntent: 'none',
       hasHumanSignals: false,
       hasSignificantEvent: false,
       isResearchSynthesis: false,
+      workType: 'general',
       explicitToolRequests: [],
       confidence: 0.8,
     })
@@ -316,12 +323,17 @@ describe('classifyMessage', () => {
 
 function makeClassification(overrides: Partial<import('@/lib/server/chat-execution/message-classifier').MessageClassification>): import('@/lib/server/chat-execution/message-classifier').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,

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

@@ -15,7 +15,8 @@ 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'
+import type { Message, MessageSemanticsSummary, MessageTaskIntent } from '@/types'
+import type { DelegationWorkType } from '@/lib/server/agents/delegation-advisory'
 
 const TAG = 'message-classifier'
 
@@ -23,18 +24,40 @@ const TAG = 'message-classifier'
 // Schema
 // ---------------------------------------------------------------------------
 
+const WorkTypeSchema = z.enum(['coding', 'research', 'writing', 'review', 'operations', 'general']).optional().default('general')
+const TaskIntentSchema = z.enum(['coding', 'research', 'browsing', 'outreach', 'scheduling', 'general']).optional().default('general')
+
 export const MessageClassificationSchema = z.object({
+  taskIntent: TaskIntentSchema,
   isDeliverableTask: z.boolean(),
   isBroadGoal: z.boolean(),
   walletIntent: z.enum(['none', 'read_only', 'transactional']),
   hasHumanSignals: z.boolean(),
   hasSignificantEvent: z.boolean(),
   isResearchSynthesis: z.boolean(),
+  workType: WorkTypeSchema,
+  wantsScreenshots: z.boolean().optional().default(false),
+  wantsOutboundDelivery: z.boolean().optional().default(false),
+  wantsVoiceDelivery: z.boolean().optional().default(false),
   explicitToolRequests: z.array(z.string()),
   confidence: z.number().min(0).max(1),
 })
 
-export type MessageClassification = z.infer<typeof MessageClassificationSchema>
+export interface MessageClassification {
+  taskIntent: MessageTaskIntent
+  isDeliverableTask: boolean
+  isBroadGoal: boolean
+  walletIntent: 'none' | 'read_only' | 'transactional'
+  hasHumanSignals: boolean
+  hasSignificantEvent: boolean
+  isResearchSynthesis: boolean
+  workType?: DelegationWorkType
+  wantsScreenshots?: boolean
+  wantsOutboundDelivery?: boolean
+  wantsVoiceDelivery?: boolean
+  explicitToolRequests: string[]
+  confidence: number
+}
 
 // ---------------------------------------------------------------------------
 // LRU Cache (module-level, keyed on sha256 of message)
@@ -76,12 +99,17 @@ function buildClassificationPrompt(message: string, recentHistory: string): stri
     'Classify the user message below across multiple dimensions. Return JSON only.',
     '',
     'Dimensions:',
+    '- taskIntent: The primary execution intent. Use exactly one of: "coding", "research", "browsing", "outreach", "scheduling", or "general". Choose "coding" for repo/code/build/debug/edit tasks. Choose "research" for gathering current info or synthesizing sources. Choose "browsing" for page navigation, rendered-page inspection, form work, or literal browser workflows. Choose "outreach" for sending/sharing/delivering updates to an external channel. Choose "scheduling" for reminders, recurring work, monitoring, or follow-up scheduling. Choose "general" when none of the above clearly fits.',
     '- isDeliverableTask (bool): The user wants a concrete artifact produced — a document, report, plan, proposal, landing page, dashboard, HTML file, markdown file, brief, copy, screenshots, or similar deliverable. NOT simple Q&A, code fixes, or single-command tasks.',
     '- isBroadGoal (bool): The message describes a broad, multi-step goal (50+ chars, no code blocks, no file paths, no numbered lists). Short questions ending with "?" are NOT broad goals.',
     '- walletIntent: "none" if no crypto/wallet/trading context. "read_only" if mentioning wallet/crypto but only for checking balances, viewing transactions, or research. "transactional" if the user wants to swap, trade, buy, sell, mint, claim, deposit, withdraw, bridge, or execute a transaction.',
     '- hasHumanSignals (bool): The message contains personal signals — preferences ("I prefer", "call me"), relationships ("my wife", "my partner", "my kid"), life events ("birthday", "wedding", "promotion", "moving", "graduation", "hospital"), or personal disclosures.',
     '- hasSignificantEvent (bool): The message mentions a notable life/work event or milestone (birthday, anniversary, wedding, graduation, promotion, new job, relocation, illness, funeral, travel, house, deadline, launch).',
     '- isResearchSynthesis (bool): The task requires gathering information from multiple sources and synthesizing it — research reports, competitive analysis, market overviews, literature reviews, multi-source comparisons. NOT simple factual lookups.',
+    '- workType: The primary work domain. Use exactly one of: "coding", "research", "writing", "review", "operations", or "general". Choose "general" when nothing else clearly fits.',
+    '- wantsScreenshots (bool): The user explicitly wants screenshots, visual capture, rendered proof, or page snapshots.',
+    '- wantsOutboundDelivery (bool): The user explicitly wants the result sent, shared, delivered, posted, or messaged to an external destination/channel.',
+    '- wantsVoiceDelivery (bool): The user explicitly wants a voice note, voice memo, audio note, or voice message.',
     '- explicitToolRequests (string[]): Tool names the user explicitly asks to use. E.g. "use the shell", "run curl", "send an email", "ask the human", "use the browser". Return canonical tool names: "shell", "email", "ask_human", "browser", "files", "web". Empty array if none.',
     '- confidence (0-1): How confident are you in this classification overall.',
     '',
@@ -90,9 +118,10 @@ function buildClassificationPrompt(message: string, recentHistory: string): stri
     '- A message can be both a deliverable task AND a broad goal.',
     '- "walletIntent" should be "transactional" only if the user wants to execute a state-changing action, not just discuss crypto.',
     '- For "explicitToolRequests", only include tools the user explicitly mentions by name or clear synonym. Do not infer tool needs from the task type.',
+    '- Prefer the most execution-relevant taskIntent. Example: "research this and send me a voice note" is "research", not "outreach".',
     '',
     'Output shape:',
-    '{"isDeliverableTask":bool,"isBroadGoal":bool,"walletIntent":"none|read_only|transactional","hasHumanSignals":bool,"hasSignificantEvent":bool,"isResearchSynthesis":bool,"explicitToolRequests":[],"confidence":0.0-1.0}',
+    '{"taskIntent":"coding|research|browsing|outreach|scheduling|general","isDeliverableTask":bool,"isBroadGoal":bool,"walletIntent":"none|read_only|transactional","hasHumanSignals":bool,"hasSignificantEvent":bool,"isResearchSynthesis":bool,"workType":"coding|research|writing|review|operations|general","wantsScreenshots":bool,"wantsOutboundDelivery":bool,"wantsVoiceDelivery":bool,"explicitToolRequests":[],"confidence":0.0-1.0}',
     '',
     recentHistory ? `Recent context:\n${recentHistory}\n` : '',
     `User message: ${JSON.stringify(message)}`,
@@ -181,7 +210,7 @@ const CLASSIFIER_TIMEOUT_MS = 2_000
 
 /**
  * Classify a user message using a single LLM call.
- * Returns null on failure/timeout — callers should fall back to regex.
+ * Returns null on failure/timeout so callers can fail open to neutral behavior.
  */
 export async function classifyMessage(
   input: ClassifyMessageInput,
@@ -238,47 +267,60 @@ export async function classifyMessage(
   }
 }
 
+export function toMessageSemanticsSummary(classification: MessageClassification | null | undefined): MessageSemanticsSummary | undefined {
+  if (!classification) return undefined
+  return {
+    taskIntent: classification.taskIntent,
+    workType: classification.workType || 'general',
+    walletIntent: classification.walletIntent,
+    isDeliverableTask: classification.isDeliverableTask,
+    isBroadGoal: classification.isBroadGoal,
+    isResearchSynthesis: classification.isResearchSynthesis,
+    hasHumanSignals: classification.hasHumanSignals,
+    hasSignificantEvent: classification.hasSignificantEvent,
+    wantsScreenshots: classification.wantsScreenshots === true,
+    wantsOutboundDelivery: classification.wantsOutboundDelivery === true,
+    wantsVoiceDelivery: classification.wantsVoiceDelivery === true,
+    explicitToolRequests: [...classification.explicitToolRequests],
+    confidence: classification.confidence,
+  }
+}
+
 // ---------------------------------------------------------------------------
-// Adapter functions — fall back to regex when classification is null
+// Adapter functions — neutral defaults when classification is unavailable
 // ---------------------------------------------------------------------------
 
-import {
-  isBroadGoal as regexIsBroadGoal,
-  looksLikeExternalWalletTask as regexLooksLikeExternalWalletTask,
-  looksLikeBoundedExternalExecutionTask as regexLooksLikeBoundedExternalExecutionTask,
-  looksLikeOpenEndedDeliverableTask as regexLooksLikeOpenEndedDeliverableTask,
-} from '@/lib/server/chat-execution/stream-continuation'
-
-export function isDeliverableTask(classification: MessageClassification | null, message: string): boolean {
-  return classification?.isDeliverableTask ?? regexLooksLikeOpenEndedDeliverableTask(message)
+export function isDeliverableTask(classification: MessageClassification | null, message?: string): boolean {
+  void message
+  return classification?.isDeliverableTask === true
 }
 
-export function isBroadGoal(classification: MessageClassification | null, message: string): boolean {
-  return classification?.isBroadGoal ?? regexIsBroadGoal(message)
+export function isBroadGoal(classification: MessageClassification | null, message?: string): boolean {
+  void message
+  return classification?.isBroadGoal === true
 }
 
-export function hasWalletIntent(classification: MessageClassification | null, message: string): boolean {
-  if (classification) return classification.walletIntent !== 'none'
-  return regexLooksLikeExternalWalletTask(message)
+export function hasWalletIntent(classification: MessageClassification | null, message?: string): boolean {
+  void message
+  return classification?.walletIntent !== undefined && classification.walletIntent !== 'none'
 }
 
-export function hasTransactionalWalletIntent(classification: MessageClassification | null, message: string): boolean {
-  if (classification) return classification.walletIntent === 'transactional'
-  return regexLooksLikeBoundedExternalExecutionTask(message)
+export function hasTransactionalWalletIntent(classification: MessageClassification | null, message?: string): boolean {
+  void message
+  return classification?.walletIntent === 'transactional'
 }
 
-export function hasHumanSignals(classification: MessageClassification | null, transcript: string): boolean {
-  if (classification) return classification.hasHumanSignals
-  // Fallback to regex
-  return /\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.test(transcript)
+export function hasHumanSignals(classification: MessageClassification | null, transcript?: string): boolean {
+  void transcript
+  return classification?.hasHumanSignals === true
 }
 
-export function hasSignificantEvent(classification: MessageClassification | null, text: string): boolean {
-  if (classification) return classification.hasSignificantEvent
-  return /\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.test(text)
+export function hasSignificantEvent(classification: MessageClassification | null, text?: string): boolean {
+  void text
+  return classification?.hasSignificantEvent === true
 }
 
-export function isResearchSynthesis(classification: MessageClassification | null, routingIntent: string | null): boolean {
-  if (classification) return classification.isResearchSynthesis
-  return routingIntent === 'research' || routingIntent === 'browsing'
+export function isResearchSynthesis(classification: MessageClassification | null, routingIntent?: string | null): boolean {
+  void routingIntent
+  return classification?.isResearchSynthesis === true
 }