@swarmclawai/swarmclaw 1.8.13 → 1.9.2

package/src/lib/server/agents/delegation-advisory.test.ts

@@ -124,6 +124,7 @@ describe('delegation-advisory', () => {
     assert.equal(result.shouldDelegate, true)
     assert.equal(result.style, 'managerial')
     assert.equal(result.recommended?.agentId, 'builder')
+    assert.equal(result.recommended?.routeKey, 'coding:coding,debugging,implementation:builder')
     assert.match(advisory.formatDelegationRationale(result.recommended), /coding/i)
   })
 

package/src/lib/server/agents/delegation-advisory.ts

@@ -20,6 +20,7 @@ export interface DelegationTaskProfile {
 export interface DelegationCandidateFit {
   agentId: string
   agentName: string
+  routeKey: string
   score: number
   availability: 'idle' | 'working' | 'unknown'
   matchedCapabilities: string[]
@@ -76,6 +77,14 @@ function matchedCapabilities(agentCapabilities: string[] | undefined, requiredCa
   return requiredCapabilities.filter((entry) => agentSet.has(entry.toLowerCase()))
 }
 
+function buildRouteKey(agent: Agent, profile: DelegationTaskProfile): string {
+  const required = profile.requiredCapabilities
+    .map((entry) => entry.toLowerCase())
+    .sort()
+    .join(',')
+  return [profile.workType, required || 'general', agent.id].join(':')
+}
+
 function roleAdjustment(agent: Agent, profile: DelegationTaskProfile): number {
   const role = agent.role === 'coordinator' ? 'coordinator' : 'worker'
   if (profile.workType === 'operations') {
@@ -141,6 +150,7 @@ function buildCandidateFit(
   return {
     agentId: agent.id,
     agentName: agent.name,
+    routeKey: buildRouteKey(agent, profile),
     score,
     availability,
     matchedCapabilities: matched,

package/src/lib/server/chat-execution/iteration-event-handler.ts

@@ -30,6 +30,7 @@ import {
   createReasoningContentMetadata,
   extractReasoningContentDelta,
 } from '@/lib/providers/deepseek-reasoning-chat-openai'
+import { StreamingReasoningTagScrubber } from '@/lib/server/chat-execution/reasoning-tag-scrubber'
 
 // ---------------------------------------------------------------------------
 // LangGraph event kind constants
@@ -92,10 +93,24 @@ export async function processIterationEvents(opts: ProcessIterationEventsOpts):
   let toolEndCount = 0
   const iterationText = { value: '' }
   const toolPerfEnds = new Map<string, (extra?: Record<string, unknown>) => number>()
+  const reasoningTagScrubber = new StreamingReasoningTagScrubber()
 
   /** Interval for progress checkpoint nudges */
   const PROGRESS_CHECK_INTERVAL = 10
 
+  const emitThinking = (text: string) => {
+    if (!text) return
+    state.accumulatedThinking += text
+    write(`data: ${JSON.stringify({ t: 'thinking', text })}\n\n`)
+  }
+
+  const appendScrubbedText = (text: string) => {
+    if (!text) return
+    const scrubbed = reasoningTagScrubber.feed(text)
+    if (scrubbed.reasoning) emitThinking(scrubbed.reasoning)
+    if (scrubbed.visible) state.appendText(scrubbed.visible, iterationText, write)
+  }
+
   for await (const event of eventStream) {
     const kind = event.event
 
@@ -104,27 +119,24 @@ export async function processIterationEvents(opts: ProcessIterationEventsOpts):
       const chunk = event.data?.chunk
       const reasoningDelta = extractReasoningContentDelta(chunk?.additional_kwargs as Record<string, unknown> | undefined)
       if (reasoningDelta) {
-        state.accumulatedThinking += reasoningDelta
-        write(`data: ${JSON.stringify({ t: 'thinking', text: reasoningDelta })}\n\n`)
+        emitThinking(reasoningDelta)
         write(`data: ${JSON.stringify({ t: 'md', text: JSON.stringify(createReasoningContentMetadata(reasoningDelta)) })}\n\n`)
       }
       if (chunk?.content) {
         if (Array.isArray(chunk.content)) {
           for (const block of chunk.content) {
             if (block.type === 'thinking' && block.thinking) {
-              state.accumulatedThinking += block.thinking
-              write(`data: ${JSON.stringify({ t: 'thinking', text: block.thinking })}\n\n`)
+              emitThinking(block.thinking)
             } else if (typeof block.text === 'string' && block.text.startsWith('[[thinking]]')) {
-              state.accumulatedThinking += block.text.slice(12)
-              write(`data: ${JSON.stringify({ t: 'thinking', text: block.text.slice(12) })}\n\n`)
+              emitThinking(block.text.slice(12))
             } else if (block.text) {
-              state.appendText(block.text, iterationText, write)
+              appendScrubbedText(block.text)
             }
           }
         } else {
           const text = typeof chunk.content === 'string' ? chunk.content : ''
           if (text) {
-            state.appendText(text, iterationText, write)
+            appendScrubbedText(text)
           }
         }
       }
@@ -351,6 +363,10 @@ export async function processIterationEvents(opts: ProcessIterationEventsOpts):
     }
   }
 
+  const finalScrubbed = reasoningTagScrubber.flush()
+  if (finalScrubbed.reasoning) emitThinking(finalScrubbed.reasoning)
+  if (finalScrubbed.visible) state.appendText(finalScrubbed.visible, iterationText, write)
+
   return {
     reachedExecutionBoundary,
     executionFollowthroughReason,

package/src/lib/server/chat-execution/reasoning-tag-scrubber.test.ts

@@ -0,0 +1,117 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { StreamingReasoningTagScrubber } from './reasoning-tag-scrubber'
+import { ChatTurnState } from './chat-turn-state'
+import { processIterationEvents } from './iteration-event-handler'
+
+function drive(deltas: string[]) {
+  const scrubber = new StreamingReasoningTagScrubber()
+  let visible = ''
+  let reasoning = ''
+  for (const delta of deltas) {
+    const result = scrubber.feed(delta)
+    visible += result.visible
+    reasoning += result.reasoning
+  }
+  const final = scrubber.flush()
+  visible += final.visible
+  reasoning += final.reasoning
+  return { visible, reasoning }
+}
+
+test('strips closed reasoning pairs from visible text and captures reasoning', () => {
+  assert.deepEqual(
+    drive(['Hello <think>private note</think> world']),
+    { visible: 'Hello  world', reasoning: 'private note' },
+  )
+})
+
+test('handles all supported tag variants case-insensitively', () => {
+  assert.deepEqual(
+    drive(['<THINKING>a</Thinking><reasoning>b</reasoning><thought>c</thought><REASONING_SCRATCHPAD>d</REASONING_SCRATCHPAD>done']),
+    { visible: 'done', reasoning: 'abcd' },
+  )
+})
+
+test('holds split opening tags across stream deltas', () => {
+  assert.deepEqual(
+    drive(['<', 'think>reasoning</think>', 'done']),
+    { visible: 'done', reasoning: 'reasoning' },
+  )
+})
+
+test('captures reasoning until a split close tag resolves', () => {
+  assert.deepEqual(
+    drive(['<think>first', ' second</th', 'ink>answer']),
+    { visible: 'answer', reasoning: 'first second' },
+  )
+})
+
+test('does not treat a mid-line prose mention as an open reasoning block', () => {
+  const text = 'Use the <think> element for examples'
+  assert.deepEqual(drive([text]), { visible: text, reasoning: '' })
+})
+
+test('does strip a bounded mid-line pair because it is model reasoning markup', () => {
+  assert.deepEqual(
+    drive(['Use <think>hidden</think>this answer']),
+    { visible: 'Use this answer', reasoning: 'hidden' },
+  )
+})
+
+test('drops unterminated reasoning content at flush after capturing streamed content', () => {
+  assert.deepEqual(
+    drive(['Visible\n<think>private reasoning with no close']),
+    { visible: 'Visible\n', reasoning: 'private reasoning with no close' },
+  )
+})
+
+test('reset clears an interrupted reasoning block and buffered partial tags', () => {
+  const scrubber = new StreamingReasoningTagScrubber()
+  assert.deepEqual(scrubber.feed('<think>hanging'), { visible: '', reasoning: 'hanging' })
+  scrubber.reset()
+  assert.deepEqual(scrubber.feed('fresh<'), { visible: 'fresh', reasoning: '' })
+  scrubber.reset()
+  assert.deepEqual(scrubber.feed('content'), { visible: 'content', reasoning: '' })
+})
+
+test('processIterationEvents routes split reasoning tags away from visible deltas', async () => {
+  async function* eventStream() {
+    yield { event: 'on_chat_model_stream', data: { chunk: { content: '<' } } }
+    yield { event: 'on_chat_model_stream', data: { chunk: { content: 'think>private' } } }
+    yield { event: 'on_chat_model_stream', data: { chunk: { content: ' reasoning</th' } } }
+    yield { event: 'on_chat_model_stream', data: { chunk: { content: 'ink>done' } } }
+  }
+
+  const state = new ChatTurnState()
+  const writes: string[] = []
+  const outcome = await processIterationEvents({
+    eventStream: eventStream(),
+    state,
+    timers: {
+      armIdleWatchdog: () => undefined,
+      clearIdleWatchdog: () => undefined,
+      clearRequiredToolKickoff: () => undefined,
+    } as never,
+    loopTracker: {} as never,
+    toolEventTracker: {} as never,
+    session: { id: 'sess_reasoning_tags', provider: 'openai', model: 'gpt-4o-mini' } as never,
+    message: 'answer briefly',
+    write: (data: string) => writes.push(data),
+    sessionExtensions: [],
+    boundedExternalExecutionTask: false,
+    toolToExtensionMap: {},
+    iterationController: new AbortController(),
+  })
+
+  assert.equal(outcome.iterationText, 'done')
+  assert.equal(state.fullText, 'done')
+  assert.equal(state.accumulatedThinking, 'private reasoning')
+
+  const rendered = writes.join('')
+  assert.match(rendered, /"t":"thinking"/)
+  assert.match(rendered, /"text":"private"/)
+  assert.match(rendered, /"text":" reasoning"/)
+  assert.doesNotMatch(rendered, /"t":"d"[^\n]*private/)
+  assert.doesNotMatch(rendered, /<think>|<\/think>/i)
+})

package/src/lib/server/chat-execution/reasoning-tag-scrubber.ts

@@ -0,0 +1,219 @@
+export interface ReasoningTagScrubResult {
+  visible: string
+  reasoning: string
+}
+
+const TAG_NAMES = [
+  'think',
+  'thinking',
+  'reasoning',
+  'thought',
+  'reasoning_scratchpad',
+] as const
+
+const OPEN_TAGS = TAG_NAMES.map((name) => `<${name}>`)
+const CLOSE_TAGS = TAG_NAMES.map((name) => `</${name}>`)
+const MAX_TAG_LENGTH = Math.max(...OPEN_TAGS.map((tag) => tag.length), ...CLOSE_TAGS.map((tag) => tag.length))
+
+function isWhitespace(text: string): boolean {
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i)
+    if (code !== 9 && code !== 10 && code !== 11 && code !== 12 && code !== 13 && code !== 32) return false
+  }
+  return true
+}
+
+function matchTagAt(lowerText: string, index: number, tags: string[]): number {
+  for (const tag of tags) {
+    if (lowerText.startsWith(tag, index)) return tag.length
+  }
+  return 0
+}
+
+function findFirstTag(text: string, tags: string[]): { index: number; length: number } {
+  const lowerText = text.toLowerCase()
+  let bestIndex = -1
+  let bestLength = 0
+  for (const tag of tags) {
+    const index = lowerText.indexOf(tag)
+    if (index !== -1 && (bestIndex === -1 || index < bestIndex)) {
+      bestIndex = index
+      bestLength = tag.length
+    }
+  }
+  return { index: bestIndex, length: bestLength }
+}
+
+function maxPartialSuffix(text: string, tags: string[]): number {
+  const lowerText = text.toLowerCase()
+  const maxLength = Math.min(MAX_TAG_LENGTH - 1, lowerText.length)
+  let best = 0
+  for (let length = 1; length <= maxLength; length++) {
+    const suffix = lowerText.slice(-length)
+    if (tags.some((tag) => tag.startsWith(suffix))) best = length
+  }
+  return best
+}
+
+function stripOrphanCloseTags(text: string): string {
+  const lowerText = text.toLowerCase()
+  let output = ''
+  let index = 0
+  while (index < text.length) {
+    const closeLength = matchTagAt(lowerText, index, CLOSE_TAGS)
+    if (closeLength > 0) {
+      index += closeLength
+      while (index < text.length && isWhitespace(text[index])) index++
+      continue
+    }
+    output += text[index]
+    index++
+  }
+  return output
+}
+
+export class StreamingReasoningTagScrubber {
+  private inBlock = false
+  private buffer = ''
+  private lastVisibleEndedNewline = true
+
+  reset(): void {
+    this.inBlock = false
+    this.buffer = ''
+    this.lastVisibleEndedNewline = true
+  }
+
+  feed(text: string): ReasoningTagScrubResult {
+    if (!text) return { visible: '', reasoning: '' }
+    let buffer = this.buffer + text
+    this.buffer = ''
+    let visible = ''
+    let reasoning = ''
+
+    while (buffer) {
+      if (this.inBlock) {
+        const close = findFirstTag(buffer, CLOSE_TAGS)
+        if (close.index === -1) {
+          const held = maxPartialSuffix(buffer, CLOSE_TAGS)
+          const captureEnd = held ? buffer.length - held : buffer.length
+          reasoning += buffer.slice(0, captureEnd)
+          this.buffer = held ? buffer.slice(-held) : ''
+          return { visible, reasoning }
+        }
+        reasoning += buffer.slice(0, close.index)
+        buffer = buffer.slice(close.index + close.length)
+        this.inBlock = false
+        continue
+      }
+
+      const pair = this.findEarliestClosedPair(buffer)
+      const open = this.findOpenAtBoundary(buffer)
+
+      if (pair && (open.index === -1 || pair.start <= open.index)) {
+        const preceding = stripOrphanCloseTags(buffer.slice(0, pair.start))
+        if (preceding) {
+          visible += preceding
+          this.lastVisibleEndedNewline = preceding.endsWith('\n')
+        }
+        reasoning += buffer.slice(pair.contentStart, pair.contentEnd)
+        buffer = buffer.slice(pair.end)
+        continue
+      }
+
+      if (open.index !== -1) {
+        const preceding = stripOrphanCloseTags(buffer.slice(0, open.index))
+        if (preceding) {
+          visible += preceding
+          this.lastVisibleEndedNewline = preceding.endsWith('\n')
+        }
+        this.inBlock = true
+        buffer = buffer.slice(open.index + open.length)
+        continue
+      }
+
+      const held = Math.max(maxPartialSuffix(buffer, OPEN_TAGS), maxPartialSuffix(buffer, CLOSE_TAGS))
+      const emitText = held ? buffer.slice(0, -held) : buffer
+      this.buffer = held ? buffer.slice(-held) : ''
+      if (emitText) {
+        const cleaned = stripOrphanCloseTags(emitText)
+        if (cleaned) {
+          visible += cleaned
+          this.lastVisibleEndedNewline = cleaned.endsWith('\n')
+        }
+      }
+      return { visible, reasoning }
+    }
+
+    return { visible, reasoning }
+  }
+
+  flush(): ReasoningTagScrubResult {
+    if (this.inBlock) {
+      this.inBlock = false
+      this.buffer = ''
+      return { visible: '', reasoning: '' }
+    }
+    const tail = stripOrphanCloseTags(this.buffer)
+    this.buffer = ''
+    if (tail) this.lastVisibleEndedNewline = tail.endsWith('\n')
+    return { visible: tail, reasoning: '' }
+  }
+
+  private findEarliestClosedPair(text: string): {
+    start: number
+    contentStart: number
+    contentEnd: number
+    end: number
+  } | null {
+    const lowerText = text.toLowerCase()
+    let best: { start: number; contentStart: number; contentEnd: number; end: number } | null = null
+    for (const name of TAG_NAMES) {
+      const openTag = `<${name}>`
+      const closeTag = `</${name}>`
+      let searchFrom = 0
+      while (searchFrom < lowerText.length) {
+        const start = lowerText.indexOf(openTag, searchFrom)
+        if (start === -1) break
+        const contentStart = start + openTag.length
+        const contentEnd = lowerText.indexOf(closeTag, contentStart)
+        if (contentEnd !== -1) {
+          const candidate = {
+            start,
+            contentStart,
+            contentEnd,
+            end: contentEnd + closeTag.length,
+          }
+          if (!best || candidate.start < best.start) best = candidate
+          break
+        }
+        searchFrom = contentStart
+      }
+    }
+    return best
+  }
+
+  private findOpenAtBoundary(text: string): { index: number; length: number } {
+    const lowerText = text.toLowerCase()
+    let best = { index: -1, length: 0 }
+    for (const openTag of OPEN_TAGS) {
+      let searchFrom = 0
+      while (searchFrom < lowerText.length) {
+        const index = lowerText.indexOf(openTag, searchFrom)
+        if (index === -1) break
+        if (this.isBlockBoundary(text.slice(0, index))) {
+          if (best.index === -1 || index < best.index) best = { index, length: openTag.length }
+          break
+        }
+        searchFrom = index + openTag.length
+      }
+    }
+    return best
+  }
+
+  private isBlockBoundary(preceding: string): boolean {
+    if (!preceding) return this.lastVisibleEndedNewline
+    const lastNewline = Math.max(preceding.lastIndexOf('\n'), preceding.lastIndexOf('\r'))
+    if (lastNewline !== -1) return isWhitespace(preceding.slice(lastNewline + 1))
+    return this.lastVisibleEndedNewline && isWhitespace(preceding)
+  }
+}

package/src/lib/server/knowledge-sources.test.ts

@@ -259,3 +259,48 @@ test('runKnowledgeHygieneMaintenance keeps same-content sources separate when vi
   assert.equal(output.agent1Hits, 2)
   assert.equal(output.agent2Hits, 1)
 })
+
+test('pruneArchivedKnowledgeSources deletes old archived sources and records prune actions', () => {
+  const output = runWithTempDataDir<{
+    pruned: number
+    sourceStillExists: boolean
+    hitCount: number
+    actionKind: string | null
+  }>(`
+    const knowledgeMod = await import('./src/lib/server/knowledge-sources.ts')
+    const storageMod = await import('./src/lib/server/storage.ts')
+    const knowledge = knowledgeMod.default || knowledgeMod
+    const storage = storageMod.default || storageMod
+
+    const source = await knowledge.createKnowledgeSource({
+      kind: 'manual',
+      title: 'Old Archived Notes',
+      content: 'prune candidate payload',
+    })
+
+    await knowledge.archiveKnowledgeSource(source.source.id, { reason: 'obsolete' })
+    const oldTimestamp = Date.now() - 60 * 24 * 60 * 60 * 1000
+    storage.patchKnowledgeSource(source.source.id, (current) => current ? {
+      ...current,
+      archivedAt: oldTimestamp,
+      maintenanceUpdatedAt: oldTimestamp,
+      updatedAt: oldTimestamp,
+    } : null)
+
+    const result = await knowledge.pruneArchivedKnowledgeSources({ olderThanDays: 30 })
+    const summary = await knowledge.getKnowledgeHygieneSummary()
+    const hits = await knowledge.searchKnowledgeHits({ query: 'candidate', includeArchived: true })
+
+    console.log(JSON.stringify({
+      pruned: result.pruned,
+      sourceStillExists: Boolean(storage.loadKnowledgeSource(source.source.id)),
+      hitCount: hits.length,
+      actionKind: summary.recentActions.find((action) => action.sourceId === source.source.id)?.kind || null,
+    }))
+  `, { prefix: 'swarmclaw-knowledge-prune-' })
+
+  assert.equal(output.pruned, 1)
+  assert.equal(output.sourceStillExists, false)
+  assert.equal(output.hitCount, 0)
+  assert.equal(output.actionKind, 'prune')
+})

package/src/lib/server/knowledge-sources.ts

@@ -31,6 +31,7 @@ import {
 import { onNextIdleWindow } from '@/lib/server/runtime/idle-window'
 
 const KNOWLEDGE_STALE_AFTER_MS = 1000 * 60 * 60 * 24 * 14
+const DEFAULT_PRUNE_ARCHIVED_AFTER_DAYS = 30
 const CHUNK_TARGET_CHARS = 2200
 const CHUNK_OVERLAP_CHARS = 320
 const MAX_KNOWLEDGE_SCAN = 10_000
@@ -1049,6 +1050,38 @@ export async function supersedeKnowledgeSource(
   return getKnowledgeSourceDetail(updated.id)
 }
 
+export async function pruneArchivedKnowledgeSources(input?: {
+  olderThanDays?: number | null
+  now?: number
+}): Promise<{ pruned: number; sourceIds: string[] }> {
+  await ensureLegacyKnowledgeBackfill()
+  const now = typeof input?.now === 'number' && Number.isFinite(input.now) ? input.now : Date.now()
+  const olderThanDays = typeof input?.olderThanDays === 'number' && Number.isFinite(input.olderThanDays)
+    ? Math.max(1, Math.trunc(input.olderThanDays))
+    : DEFAULT_PRUNE_ARCHIVED_AFTER_DAYS
+  const cutoff = now - olderThanDays * 24 * 60 * 60 * 1000
+  const sourceIds: string[] = []
+
+  for (const source of listStoredSources()) {
+    if (!sourceIsArchived(source) && !sourceIsSuperseded(source)) continue
+    const lifecycleAt = source.archivedAt || source.maintenanceUpdatedAt || source.updatedAt
+    if (lifecycleAt > cutoff) continue
+    const title = source.title
+    const removed = await deleteKnowledgeSource(source.id)
+    if (!removed) continue
+    sourceIds.push(source.id)
+    recordMaintenanceAction({
+      kind: 'prune',
+      sourceId: source.id,
+      relatedSourceId: source.duplicateOfSourceId || source.supersededBySourceId || null,
+      summary: `Pruned ${title}`,
+      createdAt: now,
+    })
+  }
+
+  return { pruned: sourceIds.length, sourceIds }
+}
+
 function sameSourceOrigin(left: KnowledgeSource, right: KnowledgeSource): boolean {
   if (left.id === right.id) return false
   if (left.sourceUrl && right.sourceUrl) return left.sourceUrl === right.sourceUrl

package/src/lib/server/portability/export.ts

@@ -34,6 +34,16 @@ export interface PortableManifest {
   extensions?: PortableExtensionRef[]
 }
 
+export function buildPortableExportFilename(manifest: Pick<PortableManifest, 'exportedAt'> = { exportedAt: new Date().toISOString() }): string {
+  const safeStamp = manifest.exportedAt
+    .replaceAll(':', '')
+    .replaceAll('.', '')
+    .replaceAll('-', '')
+    .replace('T', '-')
+    .replace('Z', 'Z')
+  return `swarmclaw-export-${safeStamp}.json`
+}
+
 export type PortableAgent = Omit<Agent,
   | 'id' | 'credentialId' | 'fallbackCredentialIds' | 'apiEndpoint'
   | 'threadSessionId' | 'lastUsedAt' | 'totalCost' | 'trashedAt'

package/src/lib/server/session-tools/crud.ts

@@ -43,6 +43,7 @@ import {
   buildDelegationTaskProfile,
   formatDelegationRationale,
   resolveDelegationAdvisory,
+  type DelegationWorkType,
 } from '@/lib/server/agents/delegation-advisory'
 import type { ToolBuildContext } from './context'
 import { normalizeToolInputArgs } from './normalize-tool-args'
@@ -102,6 +103,17 @@ function buildTaskDelegationText(parsed: Record<string, unknown>): string {
   return [title, description].filter(Boolean).join('\n\n').trim()
 }
 
+function normalizeDelegationWorkType(value: unknown): DelegationWorkType | null {
+  return value === 'coding'
+    || value === 'research'
+    || value === 'writing'
+    || value === 'review'
+    || value === 'operations'
+    || value === 'general'
+    ? value
+    : null
+}
+
 async function resolveManagedTaskDelegation(params: {
   parsed: Record<string, unknown>
   agents: ReturnType<typeof loadAgents>
@@ -122,9 +134,11 @@ async function resolveManagedTaskDelegation(params: {
     return { assignedAgentId: params.assignedAgentId, advisory: null }
   }
 
+  const decisionStartedAt = Date.now()
   const explicitCapabilities = normalizeStringList(params.parsed.requiredCapabilities)
+  const explicitWorkType = normalizeDelegationWorkType(params.parsed.workType)
   const classificationText = buildTaskDelegationText(params.parsed)
-  const classification = (!explicitCapabilities.length && classificationText && params.ctx?.sessionId)
+  const classification = (!explicitCapabilities.length && !explicitWorkType && classificationText && params.ctx?.sessionId)
     ? await classifyMessage({
         sessionId: params.ctx.sessionId,
         agentId: currentAgentId,
@@ -134,6 +148,7 @@ async function resolveManagedTaskDelegation(params: {
 
   const profile = buildDelegationTaskProfile({
     classification,
+    workType: explicitWorkType,
     requiredCapabilities: explicitCapabilities,
   })
   if (!profile.substantial) {
@@ -167,10 +182,18 @@ async function resolveManagedTaskDelegation(params: {
     advisory: {
       recommendedAgentId: recommended.agentId,
       recommendedAgentName: recommended.agentName,
+      routeKey: recommended.routeKey,
       rationale: formatDelegationRationale(recommended),
       workType: profile.workType,
       requiredCapabilities: profile.requiredCapabilities,
       autoAssigned,
+      routingMode: explicitCapabilities.length || explicitWorkType
+        ? 'deterministic'
+        : classification
+          ? 'classified'
+          : 'default',
+      decisionLatencyMs: Date.now() - decisionStartedAt,
+      score: Number(recommended.score.toFixed(3)),
     },
   }
 }
@@ -465,7 +488,7 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
       }
       description += '\n\nCreate/update calls accept either `data` as a JSON string or direct top-level fields like `title`, `description`, `status`, `agentId`, and `projectId`.'
       if (canAssignOtherAgents) {
-        description += '\n\nWhen you omit an assignee, the runtime may auto-assign the task to a materially better-fit teammate based on `requiredCapabilities` or the classified work type. If you set an explicit assignee, it is respected in v1, but the response may include `delegationAdvisory` when another teammate is a better fit.'
+        description += '\n\nWhen you omit an assignee, the runtime may auto-assign the task to a materially better-fit teammate based on `requiredCapabilities`, explicit `workType`, or the classified work type. Use `workType:"coding"|"research"|"writing"|"review"|"operations"|"general"` for deterministic routing without a classifier call. If you set an explicit assignee, it is respected in v1, but the response may include `delegationAdvisory` when another teammate is a better fit.'
       }
       description += '\n\nFor follow-up work, set `continueFromTaskId` (or `followUpToTaskId`) to a prior task ID. The new task will inherit the predecessor\'s project/agent/session context, block on that task by default, and reuse its execution session when possible.'
       if (ctx?.projectId) {

package/src/lib/server/session-tools/manage-tasks.test.ts

@@ -172,7 +172,7 @@ describe('manage_tasks tool', () => {
         action: 'create',
         title: 'Implement API integration',
         description: 'Build the API client and fix the failing tests.',
-        requiredCapabilities: ['coding'],
+        workType: 'coding',
         status: 'backlog',
       })
 
@@ -185,7 +185,11 @@ describe('manage_tasks tool', () => {
     assert.equal(output.stored.agentId, 'builder')
     assert.equal(output.response.delegationAdvisory.autoAssigned, true)
     assert.equal(output.response.delegationAdvisory.recommendedAgentId, 'builder')
-    assert.deepEqual(output.response.delegationAdvisory.requiredCapabilities, ['coding'])
+    assert.deepEqual(output.response.delegationAdvisory.requiredCapabilities, ['coding', 'implementation', 'debugging'])
+    assert.equal(output.response.delegationAdvisory.routingMode, 'deterministic')
+    assert.match(output.response.delegationAdvisory.routeKey, /^coding:coding,debugging,implementation:builder$/)
+    assert.equal(typeof output.response.delegationAdvisory.decisionLatencyMs, 'number')
+    assert.equal(output.stored.workflowStateId, 'in_progress')
   })
 
   it('keeps an explicit assignee but returns delegation advisory when another teammate is a better fit', () => {
@@ -262,5 +266,6 @@ describe('manage_tasks tool', () => {
     assert.equal(output.stored.agentId, 'researcher')
     assert.equal(output.response.delegationAdvisory.autoAssigned, false)
     assert.equal(output.response.delegationAdvisory.recommendedAgentId, 'builder')
+    assert.equal(output.response.delegationAdvisory.routingMode, 'deterministic')
   })
 })