@swarmclawai/swarmclaw 1.9.1 → 1.9.2

package/README.md

@@ -399,6 +399,16 @@ Operational docs: https://swarmclaw.ai/docs/observability
 
 ## Releases
 
+### v1.9.2 Highlights
+
+Bundled competitor-parity release: Hermes-style reasoning hygiene, deterministic delegation routing, Mission Control task workflow polish, OpenClaw export hardening, and Paperclip-style timeout hygiene.
+
+- **Stateful reasoning tag scrubber.** String-streamed `<think>`, `<thinking>`, `<reasoning>`, `<thought>`, and `<REASONING_SCRATCHPAD>` blocks are removed across split deltas and routed into SwarmClaw's thinking stream instead of leaking into visible answers.
+- **Deterministic delegation profiles.** `manage_tasks` now accepts explicit `workType` and `requiredCapabilities` routing hints, returns a stable `routeKey`, and can auto-assign unowned work without a classifier call when the profile is explicit.
+- **Assignment workflow transitions.** Newly assigned backlog/triage/todo tasks move into the `in_progress` workflow lane without changing their runtime status or queueing execution.
+- **Knowledge hygiene pruning.** Archived or superseded knowledge sources can now be pruned after a retention window, with prune actions recorded in the hygiene summary.
+- **Collision-safe exports and timeout hardening.** Portability exports support timestamped attachment filenames, the sandbox browser image build has a configurable timeout, and release notes now carry the macOS quarantine workaround for ad-hoc signed desktop builds.
+
 ### v1.9.1 Highlights
 
 Task execution workspace release: the first Paperclip-style work-control slice for task-scoped workspaces, preview handoffs, and liveness evidence.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "description": "Build and run autonomous AI agents with OpenClaw, Hermes, multiple model providers, orchestration, delegation, memory, skills, schedules, and chat connectors.",
   "main": "electron-dist/main.js",
   "license": "MIT",
@@ -84,10 +84,10 @@
     "lint:baseline": "node ./scripts/lint-baseline.mjs check",
     "lint:baseline:update": "node ./scripts/lint-baseline.mjs update",
     "cli": "node ./bin/swarmclaw.js",
-    "test:cli": "node --test src/cli/*.test.js bin/*.test.js scripts/electron-after-pack.test.mjs scripts/postinstall.test.mjs scripts/run-next-build.test.mjs scripts/run-next-typegen.test.mjs",
+    "test:cli": "node --test src/cli/*.test.js bin/*.test.js scripts/electron-after-pack.test.mjs scripts/ensure-sandbox-browser-image.test.mjs scripts/postinstall.test.mjs scripts/run-next-build.test.mjs scripts/run-next-typegen.test.mjs",
     "test:setup": "tsx --test src/app/api/setup/check-provider/route.test.ts src/lib/server/provider-model-discovery.test.ts src/components/auth/setup-wizard/utils.test.ts src/components/auth/setup-wizard/types.test.ts src/hooks/setup-done-detection.test.ts src/lib/setup-defaults.test.ts src/lib/server/storage-auth.test.ts src/lib/server/storage-auth-docker.test.ts",
     "test:openclaw": "tsx --test src/lib/openclaw/openclaw-agent-id.test.ts src/lib/openclaw/openclaw-endpoint.test.ts src/lib/server/agents/agent-runtime-config.test.ts src/lib/server/build-llm.test.ts src/lib/server/connectors/connector-routing.test.ts src/lib/server/connectors/openclaw.test.ts src/lib/server/connectors/swarmdock.test.ts src/lib/server/gateway/protocol.test.ts src/lib/server/gateways/gateway-topology.test.ts src/lib/server/llm-response-cache.test.ts src/lib/server/mcp-conformance.test.ts src/lib/server/openclaw/agent-resolver.test.ts src/lib/server/openclaw/deploy.test.ts src/lib/server/openclaw/skills-normalize.test.ts src/lib/server/session-tools/openclaw-nodes.test.ts src/lib/server/session-tools/swarmdock.test.ts src/lib/server/tasks/task-quality-gate.test.ts src/lib/server/tasks/task-validation.test.ts src/lib/server/tool-capability-policy.test.ts src/lib/providers/openai.test.ts src/lib/providers/openclaw-exports.test.ts src/app/api/gateways/topology-route.test.ts src/app/api/openclaw/dashboard-url/route.test.ts",
-    "test:runtime": "tsx --test src/lib/a2a/agent-card.test.ts src/lib/strip-internal-metadata.test.ts src/lib/provider-sets.test.ts src/lib/providers/opencode-cli.test.ts src/lib/providers/cli-provider-metadata.test.ts src/lib/providers/cli-utils.test.ts src/lib/providers/generic-cli.test.ts src/lib/server/cli-provider-readiness.test.ts src/lib/server/provider-health.test.ts src/lib/server/mcp-gateway-runtime.test.ts src/lib/server/mcp-connection-pool.test.ts src/lib/server/knowledge-sources.test.ts src/lib/server/chat-execution/chat-execution-grounding.test.ts src/lib/server/chat-execution/chat-turn-preparation.test.ts src/lib/server/chat-execution/iteration-timers.test.ts src/lib/server/chat-execution/post-stream-finalization.test.ts src/lib/server/chats/clear-undo-snapshots.test.ts src/lib/server/connectors/email.test.ts src/lib/server/protocols/protocol-service.test.ts src/lib/server/runtime/run-ledger.test.ts src/lib/server/runtime/queue-retry-policy.test.ts src/lib/server/runs/run-brief.test.ts src/lib/server/operations/operation-pulse.test.ts src/lib/server/artifacts/artifact-resolver.test.ts src/lib/server/observability/otel-config.test.ts src/lib/server/safe-parse-body.test.ts src/lib/server/missions/mission-templates.test.ts src/lib/server/sharing/share-link-repository.test.ts src/lib/server/sharing/share-resolver.test.ts src/lib/server/tasks/task-execution-workspace.test.ts src/lib/server/session-tools/execute.test.ts src/lib/app/view-constants.test.ts src/lib/quality/quality-summary.test.ts src/app/api/approvals/route.test.ts src/app/api/agents/agents-route.test.ts src/app/api/tasks/tasks-route.test.ts src/app/api/tasks/task-workspace-route.test.ts src/app/api/chats/chat-route.test.ts src/app/api/chats/clear-route.test.ts src/app/api/chats/compact-route.test.ts src/app/api/chats/context-status-route.test.ts src/app/api/connectors/connector-doctor-route.test.ts src/app/api/healthz/route.test.ts src/app/api/logs/route.test.ts src/app/api/providers/[id]/route.test.ts src/app/api/tts/route.test.ts",
+    "test:runtime": "tsx --test src/lib/a2a/agent-card.test.ts src/lib/strip-internal-metadata.test.ts src/lib/provider-sets.test.ts src/lib/providers/opencode-cli.test.ts src/lib/providers/cli-provider-metadata.test.ts src/lib/providers/cli-utils.test.ts src/lib/providers/generic-cli.test.ts src/lib/server/agents/delegation-advisory.test.ts src/lib/server/cli-provider-readiness.test.ts src/lib/server/provider-health.test.ts src/lib/server/mcp-gateway-runtime.test.ts src/lib/server/mcp-connection-pool.test.ts src/lib/server/knowledge-sources.test.ts src/lib/server/chat-execution/chat-execution-grounding.test.ts src/lib/server/chat-execution/chat-turn-preparation.test.ts src/lib/server/chat-execution/iteration-timers.test.ts src/lib/server/chat-execution/post-stream-finalization.test.ts src/lib/server/chat-execution/reasoning-tag-scrubber.test.ts src/lib/server/chats/clear-undo-snapshots.test.ts src/lib/server/connectors/email.test.ts src/lib/server/protocols/protocol-service.test.ts src/lib/server/runtime/run-ledger.test.ts src/lib/server/runtime/queue-retry-policy.test.ts src/lib/server/runs/run-brief.test.ts src/lib/server/operations/operation-pulse.test.ts src/lib/server/artifacts/artifact-resolver.test.ts src/lib/server/observability/otel-config.test.ts src/lib/server/safe-parse-body.test.ts src/lib/server/missions/mission-templates.test.ts src/lib/server/sharing/share-link-repository.test.ts src/lib/server/sharing/share-resolver.test.ts src/lib/server/tasks/task-execution-workspace.test.ts src/lib/server/tasks/task-service.test.ts src/lib/server/session-tools/execute.test.ts src/lib/server/session-tools/manage-tasks.test.ts src/lib/app/view-constants.test.ts src/lib/quality/quality-summary.test.ts src/app/api/approvals/route.test.ts src/app/api/agents/agents-route.test.ts src/app/api/tasks/tasks-route.test.ts src/app/api/tasks/task-workspace-route.test.ts src/app/api/chats/chat-route.test.ts src/app/api/chats/clear-route.test.ts src/app/api/chats/compact-route.test.ts src/app/api/chats/context-status-route.test.ts src/app/api/connectors/connector-doctor-route.test.ts src/app/api/healthz/route.test.ts src/app/api/logs/route.test.ts src/app/api/portability/export/route.test.ts src/app/api/providers/[id]/route.test.ts src/app/api/tts/route.test.ts",
     "test:builder": "tsx --test src/features/protocols/builder/utils/nodes-to-template.test.ts src/features/protocols/builder/utils/template-to-nodes.test.ts src/features/protocols/builder/validators/dag-validator.test.ts",
     "test:e2e": "node --import tsx scripts/browser-e2e-smoke.ts",
     "test:mcp:conformance": "node --import tsx ./scripts/mcp-conformance-check.ts",

package/scripts/ensure-sandbox-browser-image.mjs

@@ -10,6 +10,7 @@ const args = new Set(process.argv.slice(2))
 const quiet = args.has('--quiet')
 const required = args.has('--required')
 const image = process.env.SWARMCLAW_SANDBOX_BROWSER_IMAGE || 'swarmclaw-sandbox-browser:bookworm-slim'
+const DEFAULT_BUILD_TIMEOUT_MS = 20 * 60 * 1000
 const SOURCE_LABEL = 'swarmclaw.sandboxBrowserSourceHash'
 
 function log(message) {
@@ -29,6 +30,11 @@ function run(command, commandArgs, options = {}) {
   })
 }
 
+function readPositiveInteger(value, fallback) {
+  const parsed = Number.parseInt(String(value || ''), 10)
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback
+}
+
 function commandExists(name) {
   const lookup = process.platform === 'win32' ? 'where' : 'which'
   const result = run(lookup, [name])
@@ -56,6 +62,7 @@ function readImageLabel(name, label) {
 }
 
 function buildImage(sourceHash) {
+  const timeoutMs = readPositiveInteger(process.env.SWARMCLAW_SANDBOX_BROWSER_BUILD_TIMEOUT_MS, DEFAULT_BUILD_TIMEOUT_MS)
   log(`Building sandbox browser image ${image}...`)
   const result = spawnSync(
     'docker',
@@ -69,13 +76,16 @@ function buildImage(sourceHash) {
     {
       cwd,
       stdio: 'inherit',
+      timeout: timeoutMs,
     },
   )
   if (result.error || (result.status ?? 1) !== 0) {
+    const timedOut = result.error?.code === 'ETIMEDOUT' || result.signal === 'SIGTERM'
+    const detail = timedOut ? ` Build timed out after ${timeoutMs}ms.` : ''
     if (required) {
-      fail(`Failed to build sandbox browser image ${image}.`, result.status ?? 1)
+      fail(`Failed to build sandbox browser image ${image}.${detail}`, result.status ?? 1)
     }
-    log(`Skipping sandbox browser image after build failure.`)
+    log(`Skipping sandbox browser image after build failure.${detail}`)
     return false
   }
   log(`Sandbox browser image ready: ${image}`)

package/src/app/api/knowledge/hygiene/route.ts

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server'
 import {
   getKnowledgeHygieneSummary,
+  pruneArchivedKnowledgeSources,
   runKnowledgeHygieneMaintenance,
 } from '@/lib/server/knowledge-sources'
 
@@ -8,6 +9,23 @@ export async function GET() {
   return NextResponse.json(await getKnowledgeHygieneSummary())
 }
 
-export async function POST() {
+export async function POST(req: Request) {
+  let body: Record<string, unknown> | null = null
+  if ((req.headers.get('content-type') || '').includes('application/json')) {
+    try {
+      const parsed = await req.json()
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) body = parsed as Record<string, unknown>
+    } catch {
+      body = null
+    }
+  }
+
+  if (body?.action === 'prune') {
+    const olderThanDays = typeof body.olderThanDays === 'number' ? body.olderThanDays : null
+    const result = await pruneArchivedKnowledgeSources({ olderThanDays })
+    const summary = await getKnowledgeHygieneSummary()
+    return NextResponse.json({ ...summary, prune: result })
+  }
+
   return NextResponse.json(await runKnowledgeHygieneMaintenance())
 }

package/src/app/api/portability/export/route.test.ts

@@ -0,0 +1,17 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { GET } from './route'
+import { buildPortableExportFilename } from '@/lib/server/portability/export'
+
+describe('GET /api/portability/export', () => {
+  it('returns a collision-resistant attachment filename for downloads', async () => {
+    const response = await GET(new Request('http://local/api/portability/export?download=true'))
+    assert.equal(response.status, 200)
+    assert.equal(response.headers.get('content-type'), 'application/json; charset=utf-8')
+    const disposition = response.headers.get('content-disposition') || ''
+    assert.match(disposition, /^attachment; filename="swarmclaw-export-\d{8}-\d{6}\d{3}Z\.json"$/)
+    const body = await response.json()
+    assert.equal(disposition, `attachment; filename="${buildPortableExportFilename(body)}"`)
+  })
+})

package/src/app/api/portability/export/route.ts

@@ -1,8 +1,17 @@
 import { NextResponse } from 'next/server'
-import { exportConfig } from '@/lib/server/portability/export'
+import { buildPortableExportFilename, exportConfig } from '@/lib/server/portability/export'
 export const dynamic = 'force-dynamic'
 
-export async function GET() {
+export async function GET(req: Request) {
   const manifest = exportConfig()
+  const { searchParams } = new URL(req.url)
+  if (searchParams.get('download') === 'true') {
+    return new NextResponse(JSON.stringify(manifest, null, 2), {
+      headers: {
+        'content-type': 'application/json; charset=utf-8',
+        'content-disposition': `attachment; filename="${buildPortableExportFilename(manifest)}"`,
+      },
+    })
+  }
   return NextResponse.json(manifest)
 }

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')
   })
 })

package/src/lib/server/tasks/task-route-service.ts

@@ -28,7 +28,11 @@ import {
   type PrepareTaskExecutionWorkspaceOptions,
 } from '@/lib/server/tasks/task-execution-workspace'
 import { resolveTaskAgentFromDescription } from '@/lib/server/tasks/task-mention'
-import { applyTaskPatch, prepareTaskCreation } from '@/lib/server/tasks/task-service'
+import {
+  applyTaskPatch,
+  prepareTaskCreation,
+  resolveAssignmentWorkflowStateTransition,
+} from '@/lib/server/tasks/task-service'
 import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
 import { queueSwarmFeedTaskCompletionWake } from '@/lib/server/swarmfeed-runtime'
 import { notify } from '@/lib/server/ws-hub'
@@ -427,12 +431,25 @@ export function bulkUpdateTasksFromRoute(body: Record<string, unknown>): Service
       }
     }
     if ('agentId' in body) {
+      const previousAgentId = tasks[id].agentId
+      const previousWorkflowStateId = tasks[id].workflowStateId || null
       tasks[id].agentId = body.agentId === null ? '' : String(body.agentId)
+      const workflowTransition = resolveAssignmentWorkflowStateTransition({
+        previousAgentId,
+        nextAgentId: tasks[id].agentId,
+        previousWorkflowStateId,
+        explicitWorkflowState: Object.prototype.hasOwnProperty.call(body, 'workflowStateId'),
+      })
+      if (workflowTransition) tasks[id].workflowStateId = workflowTransition
     }
     if ('projectId' in body) {
       if (body.projectId === null) delete tasks[id].projectId
       else tasks[id].projectId = String(body.projectId)
     }
+    if ('workflowStateId' in body) {
+      if (body.workflowStateId === null) delete tasks[id].workflowStateId
+      else tasks[id].workflowStateId = String(body.workflowStateId)
+    }
     tasks[id].updatedAt = Date.now()
     updated += 1
     results.push(id)

package/src/lib/server/tasks/task-service.test.ts

@@ -3,8 +3,11 @@ import { describe, it } from 'node:test'
 
 import { computeTaskFingerprint } from '@/lib/task-dedupe'
 import type { BoardTask } from '@/types'
-
-import { applyTaskPatch, prepareTaskCreation } from '@/lib/server/tasks/task-service'
+import {
+  applyTaskPatch,
+  prepareTaskCreation,
+  resolveAssignmentWorkflowStateTransition,
+} from '@/lib/server/tasks/task-service'
 
 function makeTask(overrides: Partial<BoardTask> = {}): BoardTask {
   return {
@@ -106,3 +109,58 @@ describe('task service helpers', () => {
     assert.equal(task.status, 'queued')
   })
 })
+
+describe('task-service assignment workflow transitions', () => {
+  it('moves newly assigned backlog workflow tasks to in_progress without queueing runtime work', () => {
+    const task = makeTask({ agentId: '', workflowStateId: 'backlog' })
+    applyTaskPatch({
+      task,
+      patch: { agentId: 'agent-builder' },
+      now: 100,
+    })
+
+    assert.equal(task.agentId, 'agent-builder')
+    assert.equal(task.status, 'backlog')
+    assert.equal(task.workflowStateId, 'in_progress')
+    assert.equal(task.updatedAt, 100)
+  })
+
+  it('preserves explicit workflow state patches', () => {
+    const task = makeTask({ workflowStateId: 'todo' })
+    applyTaskPatch({
+      task,
+      patch: { agentId: 'agent-builder', workflowStateId: 'needs_review' },
+      now: 100,
+    })
+
+    assert.equal(task.workflowStateId, 'needs_review')
+  })
+
+  it('seeds assigned task creation into the in_progress workflow lane', () => {
+    const prepared = prepareTaskCreation({
+      input: {
+        title: 'Build the client',
+        description: '',
+        agentId: 'builder',
+      },
+      tasks: {},
+      now: 200,
+    })
+
+    assert.equal(prepared.ok, true)
+    if (prepared.ok) {
+      assert.equal(prepared.task.status, 'backlog')
+      assert.equal(prepared.task.workflowStateId, 'in_progress')
+    }
+  })
+
+  it('leaves already-started workflow states alone', () => {
+    const next = resolveAssignmentWorkflowStateTransition({
+      previousAgentId: '',
+      nextAgentId: 'agent-builder',
+      previousWorkflowStateId: 'needs_review',
+    })
+
+    assert.equal(next, null)
+  })
+})

package/src/lib/server/tasks/task-service.ts

@@ -20,6 +20,28 @@ const TASK_STATUS_VALUES = new Set([
   'archived',
 ])
 
+const ASSIGNMENT_START_WORKFLOW_STATES = new Set(['triage', 'backlog', 'todo'])
+
+function hasOwn(record: Record<string, unknown>, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(record, key)
+}
+
+export function resolveAssignmentWorkflowStateTransition(params: {
+  previousAgentId?: string | null
+  nextAgentId?: string | null
+  previousWorkflowStateId?: string | null
+  explicitWorkflowState?: boolean
+}): string | null {
+  if (params.explicitWorkflowState) return null
+  const previousAgentId = typeof params.previousAgentId === 'string' ? params.previousAgentId.trim() : ''
+  const nextAgentId = typeof params.nextAgentId === 'string' ? params.nextAgentId.trim() : ''
+  if (!nextAgentId || nextAgentId === previousAgentId) return null
+  const currentWorkflow = typeof params.previousWorkflowStateId === 'string' && params.previousWorkflowStateId.trim()
+    ? params.previousWorkflowStateId.trim()
+    : 'backlog'
+  return ASSIGNMENT_START_WORKFLOW_STATES.has(currentWorkflow) ? 'in_progress' : null
+}
+
 export function deriveTaskTitle(input: { title?: unknown; description?: unknown }): string {
   const explicit = typeof input.title === 'string' ? input.title.replace(/\s+/g, ' ').trim() : ''
   if (explicit && !/^untitled task$/i.test(explicit)) return explicit.slice(0, 120)
@@ -157,6 +179,7 @@ export type PrepareTaskCreationResult =
 
 export function prepareTaskCreation(options: PrepareTaskCreationOptions): PrepareTaskCreationResult {
   const seed = options.seed ? { ...options.seed } : {}
+  delete seed.workType
   const explicitTitle = typeof options.input.title === 'string' ? options.input.title.trim() : ''
   const derivedTitle = deriveTaskTitle(options.input)
   const nextTitle = options.deriveTitleFromDescription
@@ -194,6 +217,9 @@ export function prepareTaskCreation(options: PrepareTaskCreationOptions): Prepar
       qualityGate,
     },
   })
+  if (!task.workflowStateId && task.agentId) {
+    task.workflowStateId = 'in_progress'
+  }
   task.fingerprint = computeTaskFingerprint(task.title || 'Untitled Task', task.agentId || '')
 
   const duplicate = task.fingerprint
@@ -227,6 +253,8 @@ export interface ApplyTaskPatchOptions {
 
 export function applyTaskPatch(options: ApplyTaskPatchOptions): BoardTask {
   const nextPatch = { ...options.patch }
+  const previousAgentId = options.task.agentId
+  const previousWorkflowStateId = options.task.workflowStateId || null
   if (Object.prototype.hasOwnProperty.call(nextPatch, 'status')) {
     const normalized = normalizeTaskStatusInput(nextPatch.status, options.task.status)
     if (normalized) nextPatch.status = normalized
@@ -240,6 +268,13 @@ export function applyTaskPatch(options: ApplyTaskPatchOptions): BoardTask {
 
   Object.assign(options.task, nextPatch, { updatedAt: options.now })
   if (options.clearProjectIdWhenNull && nextPatch.projectId === null) delete options.task.projectId
+  const workflowTransition = resolveAssignmentWorkflowStateTransition({
+    previousAgentId,
+    nextAgentId: options.task.agentId,
+    previousWorkflowStateId,
+    explicitWorkflowState: hasOwn(nextPatch, 'workflowStateId'),
+  })
+  if (workflowTransition) options.task.workflowStateId = workflowTransition
 
   if (options.task.status === 'completed') {
     const { validation } = refreshTaskCompletionValidation(options.task, options.settings)

package/src/lib/validation/schemas.ts

@@ -200,6 +200,8 @@ export const TaskCreateSchema = z.object({
   retryBackoffSec: z.number().optional(),
   priority: z.enum(['low', 'medium', 'high', 'critical']).optional(),
   dueAt: z.number().nullable().optional(),
+  workflowStateId: z.string().nullable().optional(),
+  requiredCapabilities: z.array(z.string()).optional(),
   provisionWorkspace: z.boolean().optional(),
   previewLinks: z.array(z.object({
     id: z.string().optional(),

package/src/types/misc.ts

@@ -486,7 +486,7 @@ export interface MemoryEntry {
 
 export type KnowledgeSourceKind = 'manual' | 'file' | 'url'
 export type KnowledgeSyncStatus = 'ready' | 'syncing' | 'error'
-export type KnowledgeHygieneActionKind = 'sync' | 'reindex' | 'archive' | 'restore' | 'supersede'
+export type KnowledgeHygieneActionKind = 'sync' | 'reindex' | 'archive' | 'restore' | 'supersede' | 'prune'
 export type KnowledgeHygieneFindingKind = 'stale' | 'duplicate' | 'overlap' | 'broken' | 'archived' | 'superseded'
 
 export interface KnowledgeCitation {