@swarmclawai/swarmclaw 0.7.6 → 0.7.8

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

@@ -7,6 +7,7 @@ import { spawnSync } from 'child_process'
 import * as cheerio from 'cheerio'
 import {
   loadAgents, saveAgents,
+  loadProjects, saveProjects,
   loadTasks, saveTasks,
   loadSchedules, saveSchedules,
   loadSkills, saveSkills,
@@ -31,9 +32,11 @@ import {
 } from '@/lib/server/agent-assignment'
 import { normalizeTaskQualityGate } from '@/lib/server/task-quality-gate'
 import { normalizeSchedulePayload } from '@/lib/server/schedule-normalization'
+import { buildProjectSnapshot, ensureProjectWorkspace, normalizeProjectCreateInput, normalizeProjectPatchInput } from '@/lib/server/project-utils'
 import type { ToolBuildContext } from './context'
 import { safePath, findBinaryOnPath } from './context'
 import { normalizeToolInputArgs } from './normalize-tool-args'
+import type { BoardTask } from '@/types'
 
 // ---------------------------------------------------------------------------
 // Document helpers
@@ -132,6 +135,98 @@ function normalizeTaskStatusInput(status: unknown, prevStatus?: string): string
   return normalized
 }
 
+function normalizeTaskIdList(value: unknown): string[] {
+  const rawValues = Array.isArray(value)
+    ? value
+    : typeof value === 'string'
+      ? value.split(',')
+      : []
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const entry of rawValues) {
+    const normalized = typeof entry === 'string' ? entry.trim() : ''
+    if (!normalized || seen.has(normalized)) continue
+    seen.add(normalized)
+    out.push(normalized)
+  }
+  return out
+}
+
+function pickFirstTaskId(value: unknown): string | null {
+  const ids = normalizeTaskIdList(value)
+  return ids[0] || null
+}
+
+function applyTaskContinuationDefaults(
+  parsed: Record<string, unknown>,
+  tasks: Record<string, BoardTask>,
+  explicitInput?: Record<string, unknown>,
+): string | null {
+  const explicit = explicitInput || parsed
+  const continuationTaskId = pickFirstTaskId(parsed.continueFromTaskId)
+    || pickFirstTaskId(parsed.followUpToTaskId)
+    || pickFirstTaskId(parsed.resumeFromTaskId)
+  const blockedBy = [
+    ...normalizeTaskIdList(parsed.blockedBy),
+    ...normalizeTaskIdList(parsed.dependsOn),
+    ...normalizeTaskIdList(parsed.dependsOnTaskIds),
+    ...normalizeTaskIdList(parsed.prerequisiteTaskIds),
+  ]
+  if (continuationTaskId && !blockedBy.includes(continuationTaskId)) {
+    blockedBy.unshift(continuationTaskId)
+  }
+  if (blockedBy.length > 0) parsed.blockedBy = blockedBy
+
+  if (continuationTaskId) {
+    const sourceTask = tasks[continuationTaskId]
+    if (!sourceTask) return `Error: source task "${continuationTaskId}" not found.`
+
+    if (!Object.prototype.hasOwnProperty.call(explicit, 'projectId') && typeof sourceTask.projectId === 'string' && sourceTask.projectId.trim()) {
+      parsed.projectId = sourceTask.projectId.trim()
+    }
+    if (
+      !Object.prototype.hasOwnProperty.call(explicit, 'agentId')
+      && !hasManagedAgentAssignmentInput(explicit)
+      && typeof sourceTask.agentId === 'string'
+      && sourceTask.agentId.trim()
+    ) {
+      parsed.agentId = sourceTask.agentId.trim()
+    }
+    if (!Object.prototype.hasOwnProperty.call(explicit, 'cwd') && typeof sourceTask.cwd === 'string' && sourceTask.cwd.trim()) {
+      parsed.cwd = sourceTask.cwd.trim()
+    }
+    const sourceSessionId = typeof sourceTask.checkpoint?.lastSessionId === 'string' && sourceTask.checkpoint.lastSessionId.trim()
+      ? sourceTask.checkpoint.lastSessionId.trim()
+      : typeof sourceTask.sessionId === 'string' && sourceTask.sessionId.trim()
+        ? sourceTask.sessionId.trim()
+        : ''
+    if (!Object.prototype.hasOwnProperty.call(explicit, 'sessionId') && sourceSessionId) {
+      parsed.sessionId = sourceSessionId
+    }
+
+    const resumeFieldMap: Array<[keyof BoardTask, string]> = [
+      ['cliResumeId', 'cliResumeId'],
+      ['cliProvider', 'cliProvider'],
+      ['claudeResumeId', 'claudeResumeId'],
+      ['codexResumeId', 'codexResumeId'],
+      ['opencodeResumeId', 'opencodeResumeId'],
+      ['geminiResumeId', 'geminiResumeId'],
+    ]
+    for (const [sourceKey, targetKey] of resumeFieldMap) {
+      const value = sourceTask[sourceKey]
+      if (Object.prototype.hasOwnProperty.call(explicit, targetKey)) continue
+      if (typeof value === 'string' && value.trim()) {
+        parsed[targetKey] = value.trim()
+      }
+    }
+  }
+
+  for (const aliasKey of ['continueFromTaskId', 'followUpToTaskId', 'resumeFromTaskId', 'dependsOn', 'dependsOnTaskIds', 'prerequisiteTaskIds']) {
+    delete parsed[aliasKey]
+  }
+  return null
+}
+
 // ---------------------------------------------------------------------------
 // RESOURCE_DEFAULTS
 // ---------------------------------------------------------------------------
@@ -212,6 +307,7 @@ const RESOURCE_DEFAULTS: Record<string, (parsed: any) => any> = {
     agentIds: Array.isArray(p.agentIds) ? p.agentIds : [],
     ...p,
   }),
+  manage_projects: (p) => normalizeProjectCreateInput(p),
 }
 
 // ---------------------------------------------------------------------------
@@ -226,6 +322,7 @@ const PLATFORM_RESOURCES: Record<string, {
   readOnly?: boolean
 }> = {
   manage_agents: { toolId: 'manage_agents', label: 'agents', load: loadAgents, save: saveAgents },
+  manage_projects: { toolId: 'manage_projects', label: 'projects', load: loadProjects, save: saveProjects },
   manage_tasks: { toolId: 'manage_tasks', label: 'tasks', load: loadTasks, save: saveTasks },
   manage_schedules: { toolId: 'manage_schedules', label: 'schedules', load: loadSchedules, save: saveSchedules },
   manage_skills: { toolId: 'manage_skills', label: 'skills', load: loadSkills, save: saveSkills },
@@ -242,6 +339,14 @@ const PLATFORM_RESOURCES: Record<string, {
 export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[] {
   const tools: StructuredToolInterface[] = []
   const { cwd, ctx, hasPlugin } = bctx
+  const buildCrudPayload = (normalized: Record<string, unknown>, action: string | undefined, data: string | undefined): Record<string, unknown> => {
+    if (data) return JSON.parse(data)
+    if (action !== 'create' && action !== 'update') return {}
+    const entries = Object.entries(normalized).filter(([key]) =>
+      !['action', 'id', 'data', 'resource', 'input', 'args', 'arguments', 'payload', 'parameters'].includes(key),
+    )
+    return entries.length > 0 ? Object.fromEntries(entries) : {}
+  }
 
   // Build dynamic agent summary for tools that need agent awareness
   const assignScope = ctx?.platformAssignScope || 'self'
@@ -271,6 +376,17 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
       } else {
         description += `\n\nYou may create tasks for yourself, leave them unassigned, or delegate them to other agents. Your agent ID is "${ctx?.agentId || 'unknown'}". When delegating, set a target agent using "agentId", "assignee", "agent", "assignedAgentId", or "assigned_agent_id". Use the target agent's exact ID when possible. Valid manual statuses: backlog, queued, completed, failed, archived. "running" is runtime-only and set automatically when execution starts.` + agentSummary
       }
+      description += '\n\nCreate/update calls accept either `data` as a JSON string or direct top-level fields like `title`, `description`, `status`, `agentId`, and `projectId`.'
+      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) {
+        description += `\n\nCurrent project context: "${ctx.projectName || ctx.projectId}" (projectId "${ctx.projectId}"). Omit "projectId" to use this active project by default.`
+      }
+    } else if (toolKey === 'manage_projects') {
+      description += '\n\nProjects hold durable execution context for longer-lived work: objective, audience, pilot priorities, open objectives, credential requirements, and preferred heartbeat cadence.'
+      description += '\n\nCreate/update calls accept either `data` as a JSON string or direct top-level fields like `name`, `description`, `objective`, `audience`, `priorities`, `openObjectives`, `capabilityHints`, `credentialRequirements`, `heartbeatPrompt`, and `heartbeatIntervalSec`.'
+      if (ctx?.projectId) {
+        description += `\n\nCurrent project context: "${ctx.projectName || ctx.projectId}" (projectId "${ctx.projectId}"). For get/update/delete, you may omit "id" to target this active project.`
+      }
     } else if (toolKey === 'manage_agents') {
       description += `\n\nAgents may self-edit their own soul. To update your soul, use action="update", id="${ctx?.agentId || 'your-agent-id'}", and include data with the "soul" field. Set "platformAssignScope":"all" to let an agent delegate work across the fleet; use "self" for solo execution.`
     } else if (toolKey === 'manage_schedules') {
@@ -279,8 +395,16 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
       } else {
         description += `\n\nOmit "agentId" to assign a schedule to yourself ("${ctx?.agentId || 'unknown'}"), or set "agentId" to another agent when needed. Schedule types: interval (set intervalMs), cron (set cron), once (set runAt). Provide either taskPrompt, command, or action+path. Before create, call list/get to avoid duplicate schedules. If an equivalent active/paused schedule already exists, create returns that existing schedule (deduplicated=true).` + agentSummary
       }
+      if (ctx?.projectId) {
+        description += `\n\nCurrent project context: "${ctx.projectName || ctx.projectId}" (projectId "${ctx.projectId}"). Omit "projectId" to use this active project by default.`
+      }
     } else if (toolKey === 'manage_webhooks') {
       description += '\n\nUse `source`, `events`, `agentId`, and `secret` when creating webhooks. Inbound calls should POST to `/api/webhooks/{id}` with header `x-webhook-secret` when a secret is configured.'
+    } else if (toolKey === 'manage_secrets') {
+      description += '\n\nUse this for credential bootstrapping and durable secret storage. Create/update calls accept either `data` as JSON or direct top-level fields like `name`, `service`, `value`, `scope`, `agentIds`, and `projectId`.'
+      if (ctx?.projectId) {
+        description += `\n\nCurrent project context: "${ctx.projectName || ctx.projectId}" (projectId "${ctx.projectId}"). Omit "projectId" to link the secret to this active project.`
+      }
     }
 
     tools.push(
@@ -298,6 +422,11 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
           }
           try {
             if (action === 'list') {
+              if (toolKey === 'manage_projects') {
+                const values = Object.values(res.load())
+                  .map((project: any) => buildProjectSnapshot(project))
+                return JSON.stringify(values)
+              }
               if (toolKey === 'manage_secrets') {
                 const values = Object.values(res.load())
                   .filter((s: any) => canAccessSecret(s))
@@ -307,6 +436,7 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                     service: s.service,
                     scope: s.scope || 'global',
                     agentIds: s.agentIds || [],
+                    projectId: s.projectId || null,
                     createdAt: s.createdAt,
                     updatedAt: s.updatedAt,
                   }))
@@ -315,40 +445,56 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
               return JSON.stringify(Object.values(res.load()))
             }
             if (action === 'get') {
-              if (!id) return 'Error: "id" is required for get action.'
+              const effectiveId = id || (toolKey === 'manage_projects' ? ctx?.projectId || undefined : undefined)
+              if (!effectiveId) return 'Error: "id" is required for get action.'
               const all = res.load()
-              if (!all[id]) return `Not found: ${res.label} "${id}"`
+              if (!all[effectiveId]) return `Not found: ${res.label} "${effectiveId}"`
+              if (toolKey === 'manage_projects') {
+                return JSON.stringify(buildProjectSnapshot(all[effectiveId]))
+              }
               if (toolKey === 'manage_secrets') {
-                if (!canAccessSecret(all[id])) return 'Error: you do not have access to this secret.'
+                if (!canAccessSecret(all[effectiveId])) return 'Error: you do not have access to this secret.'
                 let value = ''
                 try {
-                  value = all[id].encryptedValue ? decryptKey(all[id].encryptedValue) : ''
+                  value = all[effectiveId].encryptedValue ? decryptKey(all[effectiveId].encryptedValue) : ''
                 } catch {
                   value = ''
                 }
                 return JSON.stringify({
-                  id: all[id].id,
-                  name: all[id].name,
-                  service: all[id].service,
-                  scope: all[id].scope || 'global',
-                  agentIds: all[id].agentIds || [],
+                  id: all[effectiveId].id,
+                  name: all[effectiveId].name,
+                  service: all[effectiveId].service,
+                  scope: all[effectiveId].scope || 'global',
+                  agentIds: all[effectiveId].agentIds || [],
+                  projectId: all[effectiveId].projectId || null,
                   value,
-                  createdAt: all[id].createdAt,
-                  updatedAt: all[id].updatedAt,
+                  createdAt: all[effectiveId].createdAt,
+                  updatedAt: all[effectiveId].updatedAt,
                 })
               }
-              return JSON.stringify(all[id])
+              return JSON.stringify(all[effectiveId])
             }
             if (res.readOnly) return `Cannot ${action} ${res.label} via this tool (read-only).`
             if (action === 'create') {
               const all = res.load()
-              const raw = data ? JSON.parse(data) : {}
+              const raw = buildCrudPayload(normalized, action, data)
               const defaults = RESOURCE_DEFAULTS[toolKey]
               const parsed = defaults ? defaults(raw) : raw
               if (parsed && typeof parsed === 'object' && 'id' in parsed) {
                 delete (parsed as Record<string, unknown>).id
               }
               const now = Date.now()
+              if (toolKey === 'manage_tasks') {
+                const continuationError = applyTaskContinuationDefaults(
+                  parsed as Record<string, unknown>,
+                  all as Record<string, BoardTask>,
+                  raw as Record<string, unknown>,
+                )
+                if (continuationError) return continuationError
+              }
+              if ((toolKey === 'manage_tasks' || toolKey === 'manage_schedules' || toolKey === 'manage_secrets') && !Object.prototype.hasOwnProperty.call(parsed, 'projectId') && ctx?.projectId) {
+                parsed.projectId = ctx.projectId
+              }
               if (toolKey === 'manage_tasks' || toolKey === 'manage_schedules') {
                 const agents = loadAgents()
                 const resolution = resolveManagedAgentAssignment(
@@ -455,7 +601,7 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                 createdAt: now,
                 updatedAt: now,
               }
-              let responseEntry: any = entry
+              let responseEntry: unknown = entry
               if (toolKey === 'manage_secrets') {
                 const secretValue = typeof parsed.value === 'string' ? parsed.value : null
                 if (!secretValue) return 'Error: data.value is required to create a secret.'
@@ -470,12 +616,17 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                   ...entry,
                   scope: normalizedScope,
                   agentIds: normalizedAgentIds,
+                  projectId: typeof parsed.projectId === 'string' && parsed.projectId.trim() ? parsed.projectId.trim() : undefined,
                   encryptedValue: encryptKey(secretValue),
                 }
                 delete (stored as any).value
                 all[newId] = stored
                 const { encryptedValue, ...safe } = stored
                 responseEntry = safe
+              } else if (toolKey === 'manage_projects') {
+                all[newId] = entry
+                ensureProjectWorkspace(newId, entry.name)
+                responseEntry = buildProjectSnapshot(entry)
               } else {
                 all[newId] = entry
               }
@@ -510,30 +661,38 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
               return JSON.stringify(responseEntry)
             }
             if (action === 'update') {
-              if (!id) return 'Error: "id" is required for update action.'
+              const effectiveId = id || (toolKey === 'manage_projects' ? ctx?.projectId || undefined : undefined)
+              if (!effectiveId) return 'Error: "id" is required for update action.'
               const all = res.load()
-              if (!all[id]) return `Not found: ${res.label} "${id}"`
-              const parsed = data ? JSON.parse(data) : {}
-              const prevStatus = all[id]?.status
-              if (toolKey === 'manage_tasks' && Object.prototype.hasOwnProperty.call(parsed, 'status')) {
-                const normalized = normalizeTaskStatusInput(parsed.status, prevStatus)
-                if (normalized) parsed.status = normalized
-                else delete parsed.status
+              if (!all[effectiveId]) return `Not found: ${res.label} "${effectiveId}"`
+              const parsed = toolKey === 'manage_projects'
+                ? normalizeProjectPatchInput(buildCrudPayload(normalized, action, data))
+                : buildCrudPayload(normalized, action, data)
+              const parsedRecord = parsed as Record<string, unknown>
+              if (toolKey === 'manage_tasks') {
+                const continuationError = applyTaskContinuationDefaults(parsedRecord, all as Record<string, BoardTask>, parsedRecord)
+                if (continuationError) return continuationError
+              }
+              const prevStatus = all[effectiveId]?.status
+              if (toolKey === 'manage_tasks' && Object.prototype.hasOwnProperty.call(parsedRecord, 'status')) {
+                const normalized = normalizeTaskStatusInput(parsedRecord.status, prevStatus)
+                if (normalized) parsedRecord.status = normalized
+                else delete parsedRecord.status
               }
-              if (toolKey === 'manage_tasks' && Object.prototype.hasOwnProperty.call(parsed, 'qualityGate')) {
+              if (toolKey === 'manage_tasks' && Object.prototype.hasOwnProperty.call(parsedRecord, 'qualityGate')) {
                 const settings = loadSettings()
-                parsed.qualityGate = parsed.qualityGate
-                  ? normalizeTaskQualityGate(parsed.qualityGate, settings)
+                parsedRecord.qualityGate = parsedRecord.qualityGate
+                  ? normalizeTaskQualityGate(parsedRecord.qualityGate, settings)
                   : null
               }
               if (toolKey === 'manage_tasks' || toolKey === 'manage_schedules') {
                 const agents = loadAgents()
-                const requestedClear = Object.prototype.hasOwnProperty.call(parsed, 'agentId') && parsed.agentId == null
+                const requestedClear = Object.prototype.hasOwnProperty.call(parsedRecord, 'agentId') && parsedRecord.agentId == null
                 const shouldResolveAssignment = requestedClear
-                  || hasManagedAgentAssignmentInput(parsed as Record<string, unknown>)
+                  || hasManagedAgentAssignmentInput(parsedRecord)
                 if (shouldResolveAssignment) {
                   const resolution = resolveManagedAgentAssignment(
-                    parsed as Record<string, unknown>,
+                    parsedRecord,
                     agents,
                     null,
                     { allowDescription: false },
@@ -547,108 +706,138 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                     unresolvedReference: requestedClear ? null : resolution.unresolvedReference,
                     isDelegation: toolKey === 'manage_tasks'
                       ? isDelegationTaskPayload({
-                          ...all[id],
-                          ...parsed,
+                          ...all[effectiveId],
+                          ...parsedRecord,
                           agentId: requestedClear ? null : resolution.agentId,
                         } as Record<string, unknown>)
                       : false,
                     delegatorAgentId: toolKey === 'manage_tasks'
                       ? resolveDelegatorAgentId({
-                          ...all[id],
-                          ...parsed,
-                        } as Record<string, unknown>, agents, ctx?.agentId || null)
+                          ...all[effectiveId],
+                          ...parsedRecord,
+                        }, agents, ctx?.agentId || null)
                       : null,
                   })
                   if (assignmentError) return assignmentError
-                  if (!requestedClear) parsed.agentId = resolution.agentId
+                  if (!requestedClear) parsedRecord.agentId = resolution.agentId
                 }
               }
-              all[id] = { ...all[id], ...parsed, updatedAt: Date.now() }
+              all[effectiveId] = { ...all[effectiveId], ...parsed, updatedAt: Date.now() }
               if (toolKey === 'manage_schedules') {
-                const normalizedSchedule = normalizeSchedulePayload(all[id] as Record<string, unknown>, {
+                const normalizedSchedule = normalizeSchedulePayload(all[effectiveId] as Record<string, unknown>, {
                   cwd,
                   now: Date.now(),
                 })
                 if (!normalizedSchedule.ok) return normalizedSchedule.error
-                all[id] = {
-                  ...all[id],
+                all[effectiveId] = {
+                  ...all[effectiveId],
                   ...normalizedSchedule.value,
                   updatedAt: Date.now(),
                 }
               }
               if (toolKey === 'manage_secrets') {
-                if (!canAccessSecret(all[id])) return 'Error: you do not have access to this secret.'
-                const nextScope = parsed.scope === 'agent'
+                if (!canAccessSecret(all[effectiveId])) return 'Error: you do not have access to this secret.'
+                const nextScope = parsedRecord.scope === 'agent'
                   ? 'agent'
-                  : parsed.scope === 'global'
+                  : parsedRecord.scope === 'global'
                     ? 'global'
-                    : (all[id].scope === 'agent' ? 'agent' : 'global')
+                    : (all[effectiveId].scope === 'agent' ? 'agent' : 'global')
                 if (nextScope === 'agent') {
-                  const incomingIds = Array.isArray(parsed.agentIds)
-                    ? parsed.agentIds.filter((x: any) => typeof x === 'string')
-                    : Array.isArray(all[id].agentIds)
-                      ? all[id].agentIds
+                  const incomingIds = Array.isArray(parsedRecord.agentIds)
+                    ? parsedRecord.agentIds.filter((x: any) => typeof x === 'string')
+                    : Array.isArray(all[effectiveId].agentIds)
+                      ? all[effectiveId].agentIds
                       : []
-                  all[id].agentIds = Array.from(new Set([
+                  all[effectiveId].agentIds = Array.from(new Set([
                     ...incomingIds,
                     ...(ctx?.agentId ? [ctx.agentId] : []),
                   ]))
                 } else {
-                  all[id].agentIds = []
+                  all[effectiveId].agentIds = []
+                }
+                all[effectiveId].scope = nextScope
+                if (Object.prototype.hasOwnProperty.call(parsedRecord, 'projectId')) {
+                  all[effectiveId].projectId = typeof parsedRecord.projectId === 'string' && parsedRecord.projectId.trim()
+                    ? parsedRecord.projectId.trim()
+                    : undefined
                 }
-                all[id].scope = nextScope
-                if (typeof parsed.value === 'string' && parsed.value.trim()) {
-                  all[id].encryptedValue = encryptKey(parsed.value)
+                if (typeof parsedRecord.value === 'string' && parsedRecord.value.trim()) {
+                  all[effectiveId].encryptedValue = encryptKey(parsedRecord.value)
                 }
-                delete all[id].value
+                delete all[effectiveId].value
               }
 
-              if (toolKey === 'manage_tasks' && all[id].status === 'completed') {
+              if (toolKey === 'manage_tasks' && all[effectiveId].status === 'completed') {
                 const { formatValidationFailure, validateTaskCompletion } = await import('../task-validation')
                 const { ensureTaskCompletionReport } = await import('../task-reports')
                 const settings = loadSettings()
-                const report = ensureTaskCompletionReport(all[id] as any)
-                if (report?.relativePath) (all[id] as any).completionReportPath = report.relativePath
-                const validation = validateTaskCompletion(all[id] as any, { report, settings })
-                ;(all[id] as any).validation = validation
+                const report = ensureTaskCompletionReport(all[effectiveId] as any)
+                if (report?.relativePath) (all[effectiveId] as any).completionReportPath = report.relativePath
+                const validation = validateTaskCompletion(all[effectiveId] as any, { report, settings })
+                ;(all[effectiveId] as any).validation = validation
                 if (!validation.ok) {
-                  all[id].status = 'failed'
-                  ;(all[id] as any).completedAt = null
-                  ;(all[id] as any).error = formatValidationFailure(validation.reasons).slice(0, 500)
-                } else if ((all[id] as any).completedAt == null) {
-                  ;(all[id] as any).completedAt = Date.now()
+                  all[effectiveId].status = 'failed'
+                  ;(all[effectiveId] as any).completedAt = null
+                  ;(all[effectiveId] as any).error = formatValidationFailure(validation.reasons).slice(0, 500)
+                } else if ((all[effectiveId] as any).completedAt == null) {
+                  ;(all[effectiveId] as any).completedAt = Date.now()
                 }
               }
 
               res.save(all)
-              if (toolKey === 'manage_tasks' && prevStatus !== 'queued' && all[id].status === 'queued') {
+              if (toolKey === 'manage_projects') {
+                ensureProjectWorkspace(effectiveId, all[effectiveId].name)
+              }
+              if (toolKey === 'manage_tasks' && prevStatus !== 'queued' && all[effectiveId].status === 'queued') {
                 const { enqueueTask } = await import('../queue')
-                enqueueTask(id)
+                enqueueTask(effectiveId)
               } else if (
                 toolKey === 'manage_tasks'
-                && prevStatus !== all[id].status
-                && (all[id].status === 'completed' || all[id].status === 'failed')
-                && all[id].sessionId
+                && prevStatus !== all[effectiveId].status
+                && (all[effectiveId].status === 'completed' || all[effectiveId].status === 'failed')
+                && all[effectiveId].sessionId
               ) {
                 const { disableSessionHeartbeat } = await import('../queue')
-                disableSessionHeartbeat(all[id].sessionId)
+                disableSessionHeartbeat(all[effectiveId].sessionId)
               }
               if (toolKey === 'manage_secrets') {
-                const { encryptedValue, ...safe } = all[id]
+                const { encryptedValue, ...safe } = all[effectiveId]
                 return JSON.stringify(safe)
               }
-              return JSON.stringify(all[id])
+              if (toolKey === 'manage_projects') {
+                return JSON.stringify(buildProjectSnapshot(all[effectiveId]))
+              }
+              return JSON.stringify(all[effectiveId])
             }
             if (action === 'delete') {
-              if (!id) return 'Error: "id" is required for delete action.'
+              const effectiveId = id || (toolKey === 'manage_projects' ? ctx?.projectId || undefined : undefined)
+              if (!effectiveId) return 'Error: "id" is required for delete action.'
               const all = res.load()
-              if (!all[id]) return `Not found: ${res.label} "${id}"`
-              if (toolKey === 'manage_secrets' && !canAccessSecret(all[id])) {
+              if (!all[effectiveId]) return `Not found: ${res.label} "${effectiveId}"`
+              if (toolKey === 'manage_secrets' && !canAccessSecret(all[effectiveId])) {
                 return 'Error: you do not have access to this secret.'
               }
-              delete all[id]
+              delete all[effectiveId]
               res.save(all)
-              return JSON.stringify({ deleted: id })
+              if (toolKey === 'manage_projects') {
+                const clearProjectId = (load: () => Record<string, Record<string, unknown>>, save: (d: Record<string, Record<string, unknown>>) => void) => {
+                  const items = load()
+                  let changed = false
+                  for (const item of Object.values(items)) {
+                    if (item.projectId === effectiveId) {
+                      item.projectId = undefined
+                      changed = true
+                    }
+                  }
+                  if (changed) save(items)
+                }
+                clearProjectId(loadAgents, saveAgents)
+                clearProjectId(loadTasks, saveTasks)
+                clearProjectId(loadSchedules, saveSchedules)
+                clearProjectId(loadSkills, saveSkills)
+                clearProjectId(loadSecrets, saveSecrets)
+              }
+              return JSON.stringify({ deleted: effectiveId })
             }
             return `Unknown action "${action}". Valid: list, get, create, update, delete`
           } catch (err: any) {
@@ -662,7 +851,7 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
             action: z.enum(['list', 'get', 'create', 'update', 'delete']).describe('The CRUD action to perform'),
             id: z.string().optional().describe('Resource ID (required for get, update, delete)'),
             data: z.string().optional().describe('JSON string of fields for create/update'),
-          }),
+          }).passthrough(),
         },
       ),
     )

package/src/lib/server/session-tools/delegate-resume.test.ts

@@ -0,0 +1,50 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { resolveDelegateResumeConfig } from './delegate'
+
+describe('resolveDelegateResumeConfig', () => {
+  it('auto-resumes when a stored backend resume ID exists', () => {
+    const config = resolveDelegateResumeConfig(
+      { task: 'continue the implementation' },
+      'codex',
+      {
+        readStoredDelegateResumeId: (key) => key === 'codex' ? 'codex-thread-42' : null,
+      },
+    )
+
+    assert.deepEqual(config, {
+      resume: true,
+      resumeId: '',
+    })
+  })
+
+  it('respects explicit resume=false even when a stored ID exists', () => {
+    const config = resolveDelegateResumeConfig(
+      { task: 'start fresh', resume: false },
+      'claude',
+      {
+        readStoredDelegateResumeId: () => 'claude-session-99',
+      },
+    )
+
+    assert.deepEqual(config, {
+      resume: false,
+      resumeId: '',
+    })
+  })
+
+  it('treats an explicit resumeId as an instruction to resume immediately', () => {
+    const config = resolveDelegateResumeConfig(
+      { task: 'continue', resumeId: 'gemini-session-5' },
+      'gemini',
+      {
+        readStoredDelegateResumeId: () => null,
+      },
+    )
+
+    assert.deepEqual(config, {
+      resume: true,
+      resumeId: 'gemini-session-5',
+    })
+  })
+})

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

@@ -247,12 +247,48 @@ function bindDelegateRuntime(runtime: DelegateRuntimeState | undefined, child: C
   child.once('error', clear)
 }
 
+function coerceOptionalBool(value: unknown): boolean | null {
+  if (typeof value === 'boolean') return value
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase()
+    if (['true', '1', 'yes', 'on'].includes(normalized)) return true
+    if (['false', '0', 'no', 'off'].includes(normalized)) return false
+  }
+  return null
+}
+
+function resumeStorageKeyForBackend(
+  backend: 'claude' | 'codex' | 'opencode' | 'gemini',
+): 'claudeCode' | 'codex' | 'opencode' | 'gemini' {
+  if (backend === 'claude') return 'claudeCode'
+  if (backend === 'codex') return 'codex'
+  if (backend === 'opencode') return 'opencode'
+  return 'gemini'
+}
+
+export function resolveDelegateResumeConfig(
+  normalized: Record<string, unknown>,
+  backend: 'claude' | 'codex' | 'opencode' | 'gemini',
+  bctx: { readStoredDelegateResumeId?: (key: 'claudeCode' | 'codex' | 'opencode' | 'gemini') => string | null },
+): { resume: boolean; resumeId: string } {
+  const explicitResumeId = typeof normalized.resumeId === 'string' ? normalized.resumeId.trim() : ''
+  if (explicitResumeId) return { resume: true, resumeId: explicitResumeId }
+
+  const explicitResume = coerceOptionalBool(normalized.resume)
+  if (explicitResume !== null) return { resume: explicitResume, resumeId: '' }
+
+  const storedResumeId = bctx.readStoredDelegateResumeId?.(resumeStorageKeyForBackend(backend))
+  return {
+    resume: Boolean(storedResumeId),
+    resumeId: '',
+  }
+}
+
 async function runDelegateBackend(args: Record<string, unknown>, bctx: DelegateContext, runtime?: DelegateRuntimeState): Promise<string> {
   const normalized = normalizeDelegateArgs(args)
   const task = normalized.task as string
   const backend = ((normalized.backend as string) || 'claude') as DelegateBackend
-  const resume = normalized.resume as boolean
-  const resumeId = normalized.resumeId as string
+  const { resume, resumeId } = resolveDelegateResumeConfig(normalized, backend, bctx)
   const backends = {
     claude: findBinaryOnPath('claude'),
     codex: findBinaryOnPath('codex'),