@swarmclawai/swarmclaw 1.2.4 → 1.2.5

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
 }

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

@@ -0,0 +1,29 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { buildAgenticExecutionPolicy } from '@/lib/server/chat-execution/prompt-builder'
+
+describe('buildAgenticExecutionPolicy', () => {
+  it('adds a routing matrix that teaches session introspection, durable tracking, and direct routing', () => {
+    const prompt = buildAgenticExecutionPolicy({
+      enabledExtensions: ['memory', 'manage_sessions', 'manage_tasks', 'manage_skills', 'spawn_subagent'],
+      loopMode: 'bounded',
+      heartbeatPrompt: 'HEARTBEAT',
+      heartbeatIntervalSec: 120,
+      userMessage: 'Figure out what tools you have, then continue the task.',
+      history: [],
+      mode: 'minimal',
+    })
+
+    assert.ok(prompt.includes('## Routing Matrix'))
+    assert.ok(prompt.includes('Current-thread facts already visible in this chat'))
+    assert.ok(prompt.includes('`memory_search`'))
+    assert.ok(prompt.includes('`sessions_tool` action `identity`'))
+    assert.ok(prompt.includes('`sessions_tool` action `history`'))
+    assert.ok(prompt.includes('`manage_tasks`'))
+    assert.ok(prompt.includes('`manage_skills`'))
+    assert.ok(prompt.includes('delegate or spawn a subagent'))
+    assert.ok(prompt.includes('use the concrete tool now'))
+    assert.ok(prompt.includes('prefer the direct `manage_*` tool'))
+  })
+})

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

@@ -202,10 +202,11 @@ export function shouldForceAttachmentFollowthrough(params: {
   enabledExtensions: string[]
   hasToolCalls: boolean
   hasAttachmentContext: boolean
+  classification?: MessageClassification | null
 }): boolean {
   if (!params.hasAttachmentContext) return false
   if (params.hasToolCalls) return false
-  const decision = routeTaskIntent(params.userMessage, params.enabledExtensions, null)
+  const decision = routeTaskIntent(params.userMessage, params.enabledExtensions, null, params.classification ?? null)
   if (decision.intent !== 'research' && decision.intent !== 'browsing') return false
   return decision.preferredTools.some((toolName) => extensionIdMatches(params.enabledExtensions, toolName))
 }
@@ -326,6 +327,13 @@ export function buildAgenticExecutionPolicy(opts: {
   const extensionLines = isMinimal ? [] : buildExtensionCapabilityLines(opts.enabledExtensions, { delegationEnabled: opts.delegationEnabled, agentId: opts.agentId })
   const toolDisciplineLines = buildToolSection(opts.enabledExtensions)
   const hasMemoryTools = opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'memory')
+  const hasManageSessions = opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'manage_sessions')
+  const hasManageTasks = opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'manage_tasks')
+  const hasManageSkills = opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'manage_skills')
+  const hasDelegationTools = opts.enabledExtensions.some((toolId) => {
+    const canonical = canonicalizeExtensionId(toolId) || toolId
+    return canonical === 'delegate' || canonical === 'spawn_subagent'
+  })
 
   const parts: string[] = []
 
@@ -351,6 +359,33 @@ export function buildAgenticExecutionPolicy(opts: {
       : 'Loop: BOUNDED — execute multiple steps but finish within recursion budget.',
   )
 
+  if (hasTooling) {
+    parts.push(
+      '## Routing Matrix',
+      'Current-thread facts already visible in this chat: answer directly from the thread before using tools.',
+      hasMemoryTools
+        ? 'Facts from previous conversations: start with `memory_search`, then `memory_get` only for a targeted follow-up read.'
+        : 'Facts from previous conversations: rely on the visible thread only and state when memory tools are unavailable.',
+      hasManageSessions
+        ? 'Harness/session context, lineage, project attachment, or enabled-tool questions: use `sessions_tool` action `identity`.'
+        : 'Harness/session introspection is limited here; rely on the runtime orientation block and visible context.',
+      hasManageSessions
+        ? 'Earlier messages from this same session that are not already visible in the thread: use `sessions_tool` action `history`.'
+        : 'Do not claim hidden session history is checked when `sessions_tool` is unavailable.',
+      hasManageTasks
+        ? 'Durable backlog or resumable progress tracking: use `manage_tasks` for multi-turn work, delegation, or explicit task-board requests.'
+        : 'Do not create pseudo-task workflows in prose when task tooling is unavailable.',
+      hasManageSkills
+        ? 'Missing capability, workflow, or environment setup blocker: use `manage_skills` before repeating generic exploration.'
+        : 'If a capability is genuinely missing, say so plainly instead of pretending a skill install happened.',
+      hasDelegationTools
+        ? 'Multi-step specialist work: delegate or spawn a subagent instead of doing the whole chain yourself.'
+        : 'If delegation tools are unavailable, execute directly with the tools you do have.',
+      'For direct reversible execution, use the concrete tool now instead of creating a task or stopping at advice.',
+      'When both `manage_platform` and a direct `manage_*` tool are available, prefer the direct `manage_*` tool.',
+    )
+  }
+
   // Sections skipped in minimal mode
   if (!isMinimal) {
     if (hasMemoryTools) {
@@ -374,7 +409,7 @@ export function buildAgenticExecutionPolicy(opts: {
         'Prefer `use_skill` action `run` for executable skills and `use_skill` action `load` only when the skill is guidance-only.',
       )
     }
-    if (opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'manage_skills')) {
+    if (hasManageSkills) {
       parts.push(
         '## Skill Resolution',
         'When you are blocked on a missing capability, binary, or environment setup, call `manage_skills` before repeating generic exploration.',

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

@@ -1,5 +1,8 @@
 import assert from 'node:assert/strict'
 import { after, before, describe, it } from 'node:test'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
 
 let mod: typeof import('@/lib/server/chat-execution/prompt-sections')
 
@@ -86,6 +89,59 @@ describe('prompt-sections', () => {
     })
   })
 
+  describe('buildRuntimeOrientationSection', () => {
+    it('includes delegated lineage, workspace markers, project context, and routing guidance', () => {
+      const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-runtime-orientation-'))
+      try {
+        fs.writeFileSync(path.join(cwd, 'AGENTS.md'), '# Agent notes')
+        const result = mod.buildRuntimeOrientationSection({
+          session: {
+            id: 'child-session',
+            cwd,
+            provider: 'openai',
+            model: 'gpt-5',
+            parentSessionId: 'parent-session',
+            agentId: 'agent-1',
+          } as never,
+          promptMode: 'minimal',
+          sessionExtensions: ['files', 'manage_sessions', 'codex_cli'],
+          toolPolicy: {
+            mode: 'balanced',
+            requestedExtensions: ['files', 'manage_sessions', 'codex_cli', 'manage_secrets'],
+            enabledExtensions: ['files', 'manage_sessions', 'codex_cli'],
+            blockedExtensions: [{ tool: 'manage_secrets', reason: 'blocked by policy', source: 'policy' }],
+          },
+          agent: {
+            id: 'agent-1',
+            name: 'Builder',
+            delegationTargetMode: 'selected',
+            delegationTargetAgentIds: ['qa-1', 'ops-1'],
+          } as never,
+          activeProjectContext: {
+            projectId: 'project-1',
+            project: { name: 'Northstar' },
+            projectRoot: '/workspace/projects/project-1',
+          } as never,
+          rootSessionId: 'root-session',
+        })
+
+        assert.ok(result.includes('## Runtime Orientation'))
+        assert.ok(result.includes('delegated_child'))
+        assert.ok(result.includes('prompt=minimal'))
+        assert.ok(result.includes('root=root-session'))
+        assert.ok(result.includes('Workspace markers: AGENTS.md'))
+        assert.ok(result.includes('Active project: Northstar'))
+        assert.ok(result.includes('`manage_sessions`'))
+        assert.ok(result.includes('`codex_cli`'))
+        assert.ok(result.includes('Policy blocked:'))
+        assert.ok(result.includes('sessions_tool'))
+        assert.ok(result.includes('use `manage_platform` only as fallback'))
+      } finally {
+        fs.rmSync(cwd, { recursive: true, force: true })
+      }
+    })
+  })
+
   // ---- buildProjectSection ----
   describe('buildProjectSection', () => {
     it('returns null for minimal mode', () => {