@swarmclawai/swarmclaw 1.9.1 → 1.9.3

package/src/lib/server/extensions.ts

@@ -11,6 +11,7 @@ import type {
   ExtensionUIDefinition,
   ExtensionProviderDefinition,
   ExtensionConnectorDefinition,
+  ExtensionManagedResources,
   Session,
   ExtensionPackageManager,
   ExtensionDependencyInstallStatus,
@@ -467,11 +468,60 @@ function coerceTools(rawTools: unknown): ExtensionToolDef[] {
   return []
 }
 
+function coerceManagedResources(raw: Record<string, unknown>): ExtensionManagedResources | undefined {
+  const explicit = isRecord(raw.managedResources)
+    ? raw.managedResources as Record<string, unknown>
+    : {}
+  const agents = Array.isArray(explicit.agents)
+    ? explicit.agents
+    : Array.isArray(raw.agents)
+      ? raw.agents
+      : undefined
+  const schedules = Array.isArray(explicit.schedules)
+    ? explicit.schedules
+    : Array.isArray(raw.schedules)
+      ? raw.schedules
+      : undefined
+  const routines = Array.isArray(explicit.routines)
+    ? explicit.routines
+    : Array.isArray(raw.routines)
+      ? raw.routines
+      : undefined
+  const localFolders = Array.isArray(explicit.localFolders)
+    ? explicit.localFolders
+    : Array.isArray(raw.localFolders)
+      ? raw.localFolders
+      : undefined
+  const gatewayPlatforms = Array.isArray(explicit.gatewayPlatforms)
+    ? explicit.gatewayPlatforms
+    : Array.isArray(raw.gatewayPlatforms)
+      ? raw.gatewayPlatforms
+      : undefined
+  const setupChecks = Array.isArray(explicit.setupChecks)
+    ? explicit.setupChecks
+    : Array.isArray(raw.setupChecks)
+      ? raw.setupChecks
+      : undefined
+
+  const managedResources: ExtensionManagedResources = {
+    agents: agents as ExtensionManagedResources['agents'],
+    schedules: schedules as ExtensionManagedResources['schedules'],
+    routines: routines as ExtensionManagedResources['routines'],
+    localFolders: localFolders as ExtensionManagedResources['localFolders'],
+    gatewayPlatforms: gatewayPlatforms as ExtensionManagedResources['gatewayPlatforms'],
+    setupChecks: setupChecks as ExtensionManagedResources['setupChecks'],
+  }
+
+  return Object.values(managedResources).some((value) => Array.isArray(value) && value.length > 0)
+    ? managedResources
+    : undefined
+}
+
 function normalizeExtension(mod: unknown): Extension | null {
   const modObj = mod as Record<string, unknown>
   const raw: Record<string, unknown> = (modObj?.default as Record<string, unknown>) || modObj
 
-  if (raw.name && (raw.hooks || raw.tools || raw.ui || raw.providers || raw.connectors)) {
+  if (raw.name && (raw.hooks || raw.tools || raw.ui || raw.providers || raw.connectors || raw.managedResources || raw.agents || raw.schedules || raw.routines || raw.localFolders || raw.gatewayPlatforms || raw.setupChecks)) {
     const hooks = isRecord(raw.hooks) ? (raw.hooks as ExtensionHooks) : {}
     return {
       name: raw.name as string,
@@ -484,6 +534,7 @@ function normalizeExtension(mod: unknown): Extension | null {
       ui: isRecord(raw.ui) ? (raw.ui as ExtensionUIDefinition) : undefined,
       providers: Array.isArray(raw.providers) ? (raw.providers as ExtensionProviderDefinition[]) : undefined,
       connectors: Array.isArray(raw.connectors) ? (raw.connectors as ExtensionConnectorDefinition[]) : undefined,
+      managedResources: coerceManagedResources(raw),
     } as Extension
   }
 
@@ -639,6 +690,7 @@ interface LoadedExtension {
   ui?: ExtensionUIDefinition
   providers?: ExtensionProviderDefinition[]
   connectors?: ExtensionConnectorDefinition[]
+  managedResources?: ExtensionManagedResources
   isBuiltin?: boolean
 }
 
@@ -1017,6 +1069,7 @@ class ExtensionManager {
           ui: p.ui,
           providers: p.providers,
           connectors: p.connectors,
+          managedResources: p.managedResources || coerceManagedResources(p as unknown as Record<string, unknown>),
           isBuiltin: true
         })
         this.markExtensionSuccess(id)
@@ -1064,6 +1117,7 @@ class ExtensionManager {
               ui: ext.ui,
               providers: ext.providers,
               connectors: ext.connectors,
+              managedResources: ext.managedResources,
             })
             this.markExtensionSuccess(file)
           } catch (err: unknown) {
@@ -1145,6 +1199,55 @@ class ExtensionManager {
     return allUI
   }
 
+  getManagedResourceExtensions(): Array<{
+    extensionId: string
+    extensionName: string
+    enabled: boolean
+    isBuiltin: boolean
+    source?: ExtensionMeta['source']
+    managedResources: ExtensionManagedResources
+  }> {
+    this.load()
+    const result: Array<{
+      extensionId: string
+      extensionName: string
+      enabled: boolean
+      isBuiltin: boolean
+      source?: ExtensionMeta['source']
+      managedResources: ExtensionManagedResources
+    }> = []
+
+    for (const [id, entry] of this.extensions.entries()) {
+      const managedResources = entry.managedResources
+      if (!managedResources) continue
+      if (!Object.values(managedResources).some((value) => Array.isArray(value) && value.length > 0)) continue
+      result.push({
+        extensionId: id,
+        extensionName: entry.meta.name,
+        enabled: entry.meta.enabled,
+        isBuiltin: entry.isBuiltin === true,
+        source: entry.meta.source,
+        managedResources,
+      })
+    }
+
+    return result
+  }
+
+  getManagedResources(extensionId: string): ExtensionManagedResources | null {
+    this.load()
+    const candidateIds = expandExtensionIds([extensionId])
+    for (const id of candidateIds) {
+      const loaded = this.extensions.get(id)
+      if (loaded?.managedResources) return loaded.managedResources
+      const builtin = this.builtins.get(id)
+      if (builtin) {
+        return builtin.managedResources || coerceManagedResources(builtin as unknown as Record<string, unknown>) || null
+      }
+    }
+    return null
+  }
+
   listExtensionIds(): string[] {
     this.load()
     return Array.from(this.extensions.keys())
@@ -1842,11 +1945,14 @@ class ExtensionManager {
       const failures = this.readFailureState()
       const metas: ExtensionMeta[] = []
 
-      const describeCapabilities = (loaded?: LoadedExtension, fallback?: Extension): Pick<ExtensionMeta, 'toolCount' | 'hookCount' | 'hasUI' | 'providerCount' | 'connectorCount' | 'settingsFields'> => {
+      const describeCapabilities = (loaded?: LoadedExtension, fallback?: Extension): Pick<ExtensionMeta, 'toolCount' | 'hookCount' | 'hasUI' | 'providerCount' | 'connectorCount' | 'settingsFields' | 'managedAgentCount' | 'managedScheduleCount' | 'localFolderCount' | 'gatewayPlatformCount' | 'setupCheckCount'> => {
         const tools = loaded?.tools || fallback?.tools || []
         const hooks = loaded?.hooks || fallback?.hooks || {}
         const providers = loaded?.providers || fallback?.providers || []
         const connectors = loaded?.connectors || fallback?.connectors || []
+        const managedResources = loaded?.managedResources
+          || fallback?.managedResources
+          || (fallback ? coerceManagedResources(fallback as unknown as Record<string, unknown>) : undefined)
         const hasUi = !!(loaded?.ui || fallback?.ui)
         const settingsFields = loaded?.ui?.settingsFields || fallback?.ui?.settingsFields
         return {
@@ -1855,6 +1961,11 @@ class ExtensionManager {
           hasUI: hasUi,
           providerCount: Array.isArray(providers) ? providers.length : 0,
           connectorCount: Array.isArray(connectors) ? connectors.length : 0,
+          managedAgentCount: managedResources?.agents?.length || 0,
+          managedScheduleCount: (managedResources?.schedules?.length || 0) + (managedResources?.routines?.length || 0),
+          localFolderCount: managedResources?.localFolders?.length || 0,
+          gatewayPlatformCount: managedResources?.gatewayPlatforms?.length || 0,
+          setupCheckCount: managedResources?.setupChecks?.length || 0,
           settingsFields: settingsFields?.length ? settingsFields : undefined,
         }
       }

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/extension-creator.ts

@@ -138,6 +138,54 @@ module.exports = {
     }
   ],
 
+  // --- Managed Resources (Paperclip-compatible) ---
+  managedResources: {
+    agents: [
+      {
+        agentKey: 'researcher',
+        displayName: 'Managed Researcher',
+        description: 'Reusable agent this extension can provision.',
+        systemPrompt: 'Research carefully and cite durable evidence.',
+        provider: 'openai',
+        model: 'gpt-4o-mini',
+        capabilities: ['research', 'analysis'],
+        extensions: ['web', 'memory']
+      }
+    ],
+    schedules: [
+      {
+        scheduleKey: 'daily-digest',
+        displayName: 'Daily Digest',
+        agentRef: { resourceKind: 'agent', resourceKey: 'researcher' },
+        taskPrompt: 'Prepare the daily digest.',
+        scheduleType: 'cron',
+        cron: '0 9 * * *',
+        timezone: 'UTC',
+        status: 'paused'
+      }
+    ],
+    localFolders: [
+      {
+        folderKey: 'workspace',
+        displayName: 'Workspace Folder',
+        access: 'readWrite',
+        requiredDirectories: ['inputs', 'outputs']
+      }
+    ],
+    gatewayPlatforms: [
+      {
+        platformKey: 'openai-compatible-api',
+        displayName: 'OpenAI-compatible API',
+        transport: 'http',
+        endpoint: 'http://127.0.0.1:8642/v1',
+        authMode: 'bearer'
+      }
+    ],
+    setupChecks: [
+      { checkKey: 'api-key', displayName: 'API key configured', kind: 'env', target: 'OPENAI_API_KEY', required: true }
+    ]
+  },
+
   // --- Real OpenClaw Format (register API) ---
   register(api) {
     api.registerHook('agent:start', (ctx) => {
@@ -162,6 +210,8 @@ Key rules:
 - If your extension needs npm/pnpm/yarn/bun packages, include a packageJson object during scaffold or call install_dependencies later.
 - Dependency installs are run by the extension manager inside a per-extension workspace using the selected package manager with scripts disabled.
 - Extension settings are declared through ui.settingsFields and stored per extension ID
+- Managed resources let an extension declare provisionable agents, schedules/routines, trusted local folders, gateway platforms, and setup checks. Operators reconcile them through Extensions > Managed Resources or /api/extensions/managed-resources.
+- Paperclip-compatible top-level agents, routines, and localFolders are also accepted; SwarmClaw reconciles routines as schedules when they include schedule timing.
 - Keep extensions focused: one clear purpose per extension
 `
     }

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/agent.ts

@@ -2,6 +2,7 @@ import type { ProviderId, ProviderType, OllamaMode } from './provider'
 import type { SessionResetMode, IdentityContinuityState } from './session'
 import type { SkillAllowlistMode } from './skill'
 import type { DreamConfig } from './dream'
+import type { ExtensionManagedResourceMarker } from './extension'
 
 // --- SwarmFeed Heartbeat ---
 
@@ -237,6 +238,7 @@ export interface Agent {
   swarmfeedLastAutoPostAt?: number | null
   origin?: 'swarmdock' | 'swarmfeed' | 'swarmclaw' | 'external'
   swarmfeedHeartbeat?: SwarmFeedHeartbeatConfig | null
+  managedByExtension?: ExtensionManagedResourceMarker | null
 
   // SwarmDock (marketplace integration)
   swarmdockEnabled?: boolean