@swarmclawai/swarmclaw 0.7.7 → 0.8.0

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,
@@ -20,7 +21,7 @@ import {
   decryptKey,
 } from '../storage'
 import { resolveScheduleName } from '@/lib/schedule-name'
-import { findDuplicateSchedule, type ScheduleLike } from '@/lib/schedule-dedupe'
+import { findDuplicateSchedule, findEquivalentSchedules, type ScheduleLike } from '@/lib/schedule-dedupe'
 import { computeTaskFingerprint, findDuplicateTask } from '@/lib/task-dedupe'
 import {
   hasManagedAgentAssignmentInput,
@@ -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
@@ -115,6 +118,95 @@ function deriveTaskTitle(input: { title?: unknown; description?: unknown }): str
   return compact.slice(0, 120)
 }
 
+const VALID_CONNECTOR_PLATFORMS = new Set([
+  'discord',
+  'telegram',
+  'slack',
+  'whatsapp',
+  'openclaw',
+  'bluebubbles',
+  'signal',
+  'teams',
+  'googlechat',
+  'matrix',
+  'email',
+  'webchat',
+  'mockmail',
+])
+
+const VALID_CONNECTOR_STATUSES = new Set(['stopped', 'running', 'error'])
+
+function normalizeConnectorConfig(raw: unknown): Record<string, string> {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {}
+  const normalized: Record<string, string> = {}
+  for (const [key, value] of Object.entries(raw as Record<string, unknown>)) {
+    const normalizedKey = typeof key === 'string' ? key.trim() : ''
+    if (!normalizedKey) continue
+    if (typeof value === 'string') {
+      normalized[normalizedKey] = value
+      continue
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+      normalized[normalizedKey] = String(value)
+    }
+  }
+  return normalized
+}
+
+function sanitizeConnectorCrudPayload(
+  raw: Record<string, unknown>,
+  options: { forUpdate?: boolean } = {},
+): Record<string, unknown> {
+  const { forUpdate = false } = options
+  const out: Record<string, unknown> = {}
+  const setString = (key: 'name' | 'platform' | 'status') => {
+    if (!Object.prototype.hasOwnProperty.call(raw, key)) return
+    const value = typeof raw[key] === 'string' ? raw[key].trim() : ''
+    if (!value) return
+    if (key === 'platform' && !VALID_CONNECTOR_PLATFORMS.has(value)) return
+    if (key === 'status' && !VALID_CONNECTOR_STATUSES.has(value)) return
+    out[key] = value
+  }
+  const setNullableId = (key: 'agentId' | 'chatroomId' | 'credentialId') => {
+    if (!Object.prototype.hasOwnProperty.call(raw, key)) return
+    const value = typeof raw[key] === 'string' ? raw[key].trim() : ''
+    out[key] = value || null
+  }
+
+  setString('name')
+  setString('platform')
+  setString('status')
+  setNullableId('agentId')
+  setNullableId('chatroomId')
+  setNullableId('credentialId')
+
+  if (Object.prototype.hasOwnProperty.call(raw, 'config')) {
+    out.config = normalizeConnectorConfig(raw.config)
+  }
+
+  if (Object.prototype.hasOwnProperty.call(raw, 'isEnabled')) {
+    out.isEnabled = raw.isEnabled === true
+  } else if (Object.prototype.hasOwnProperty.call(raw, 'enabled')) {
+    out.isEnabled = raw.enabled === true
+  }
+
+  if (!forUpdate) {
+    const platform = typeof out.platform === 'string' ? out.platform : 'discord'
+    return {
+      name: typeof out.name === 'string' && out.name ? out.name : 'Unnamed Connector',
+      platform,
+      agentId: Object.prototype.hasOwnProperty.call(out, 'agentId') ? out.agentId : null,
+      chatroomId: Object.prototype.hasOwnProperty.call(out, 'chatroomId') ? out.chatroomId : null,
+      credentialId: Object.prototype.hasOwnProperty.call(out, 'credentialId') ? out.credentialId : null,
+      config: Object.prototype.hasOwnProperty.call(out, 'config') ? out.config : {},
+      isEnabled: Object.prototype.hasOwnProperty.call(out, 'isEnabled') ? out.isEnabled : false,
+      ...(typeof out.status === 'string' ? { status: out.status } : {}),
+    }
+  }
+
+  return out
+}
+
 const TASK_STATUS_VALUES = new Set([
   'backlog',
   'queued',
@@ -132,6 +224,187 @@ 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 buildScheduleCreatorScope(schedule: Record<string, unknown> | null | undefined): {
+  agentId?: string | null
+  sessionId?: string | null
+} | null {
+  if (!schedule || typeof schedule !== 'object') return null
+  const agentId = typeof schedule.createdByAgentId === 'string' && schedule.createdByAgentId.trim()
+    ? schedule.createdByAgentId.trim()
+    : null
+  const sessionId = typeof schedule.createdInSessionId === 'string' && schedule.createdInSessionId.trim()
+    ? schedule.createdInSessionId.trim()
+    : null
+  if (!agentId && !sessionId) return null
+  return { agentId, sessionId }
+}
+
+function deriveScheduleFollowupTarget(sessionId: string | null | undefined): {
+  followupConnectorId?: string | null
+  followupChannelId?: string | null
+  followupThreadId?: string | null
+  followupSenderId?: string | null
+  followupSenderName?: string | null
+} {
+  const normalizedSessionId = typeof sessionId === 'string' ? sessionId.trim() : ''
+  if (!normalizedSessionId) return {}
+
+  const session = loadSessions()[normalizedSessionId] as {
+    connectorContext?: Record<string, unknown>
+    messages?: Array<Record<string, unknown>>
+  } | undefined
+  if (!session) return {}
+
+  const pickSourceFields = (source: Record<string, unknown> | null | undefined) => {
+    const connectorId = typeof source?.connectorId === 'string' ? source.connectorId.trim() : ''
+    const channelId = typeof source?.channelId === 'string' ? source.channelId.trim() : ''
+    if (!connectorId || !channelId) return {}
+    const threadId = typeof source?.threadId === 'string' ? source.threadId.trim() : ''
+    const senderId = typeof source?.senderId === 'string' ? source.senderId.trim() : ''
+    const senderName = typeof source?.senderName === 'string' ? source.senderName.trim() : ''
+    return {
+      followupConnectorId: connectorId,
+      followupChannelId: channelId,
+      followupThreadId: threadId || null,
+      followupSenderId: senderId || null,
+      followupSenderName: senderName || null,
+    }
+  }
+
+  const contextTarget = pickSourceFields(session.connectorContext || undefined)
+  if (contextTarget.followupConnectorId && contextTarget.followupChannelId) return contextTarget
+
+  const messages = Array.isArray(session.messages) ? session.messages : []
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const message = messages[i]
+    if ((typeof message?.role === 'string' ? message.role : '') !== 'user') continue
+    if (message?.historyExcluded === true) continue
+    const messageTarget = pickSourceFields(message?.source as Record<string, unknown> | undefined)
+    if (messageTarget.followupConnectorId && messageTarget.followupChannelId) return messageTarget
+  }
+
+  return {}
+}
+
+function findRelatedScheduleIds(
+  schedules: Record<string, ScheduleLike>,
+  schedule: Record<string, unknown> | null | undefined,
+  opts: { ignoreId?: string | null } = {},
+): string[] {
+  if (!schedule || typeof schedule !== 'object') return []
+  const scope = buildScheduleCreatorScope(schedule)
+  if (!scope?.sessionId) return []
+  const matches = findEquivalentSchedules(schedules, {
+    id: typeof schedule.id === 'string' ? schedule.id : null,
+    agentId: typeof schedule.agentId === 'string' ? schedule.agentId : null,
+    taskPrompt: typeof schedule.taskPrompt === 'string' ? schedule.taskPrompt : null,
+    scheduleType: typeof schedule.scheduleType === 'string' ? schedule.scheduleType : null,
+    cron: typeof schedule.cron === 'string' ? schedule.cron : null,
+    intervalMs: typeof schedule.intervalMs === 'number' ? schedule.intervalMs : null,
+    runAt: typeof schedule.runAt === 'number' ? schedule.runAt : null,
+    createdByAgentId: scope.agentId,
+    createdInSessionId: scope.sessionId,
+  }, {
+    ignoreId: opts.ignoreId || (typeof schedule.id === 'string' ? schedule.id : null),
+    creatorScope: scope,
+  })
+  return Array.from(new Set(matches
+    .map((entry) => (typeof entry.id === 'string' ? entry.id : ''))
+    .filter(Boolean)))
+}
+
+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
 // ---------------------------------------------------------------------------
@@ -190,11 +463,7 @@ const RESOURCE_DEFAULTS: Record<string, (parsed: any) => any> = {
     ...p,
   }),
   manage_connectors: (p) => ({
-    name: p.name || 'Unnamed Connector',
-    platform: p.platform || 'discord',
-    agentId: p.agentId || null,
-    enabled: p.enabled ?? false,
-    ...p,
+    ...sanitizeConnectorCrudPayload(p as Record<string, unknown>),
   }),
   manage_webhooks: (p) => ({
     name: p.name || 'Unnamed Webhook',
@@ -212,6 +481,7 @@ const RESOURCE_DEFAULTS: Record<string, (parsed: any) => any> = {
     agentIds: Array.isArray(p.agentIds) ? p.agentIds : [],
     ...p,
   }),
+  manage_projects: (p) => normalizeProjectCreateInput(p),
 }
 
 // ---------------------------------------------------------------------------
@@ -226,6 +496,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 +513,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,16 +550,35 @@ 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') {
       if (assignScope === 'self') {
-        description += `\n\nOmit "agentId" to assign a schedule to yourself ("${ctx?.agentId || 'unknown'}"), or set it explicitly to yourself. You can only assign schedules to yourself. 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).`
+        description += `\n\nOmit "agentId" to assign a schedule to yourself ("${ctx?.agentId || 'unknown'}"), or set it explicitly to yourself. You can only assign schedules to yourself. 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. Reuse or update an existing schedule you already created in this chat instead of making a near-duplicate. If an equivalent active/paused schedule already exists, create returns that existing schedule (deduplicated=true). For one-off reminders, prefer "once"; agent-created one-off schedules are cleaned up automatically after they finish. When the user says stop/pause/cancel a reminder, pause or delete every matching schedule you created in this chat, not just one row.`
       } 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
+        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. Reuse or update an existing schedule you already created in this chat instead of making a near-duplicate. If an equivalent active/paused schedule already exists, create returns that existing schedule (deduplicated=true). For one-off reminders, prefer "once"; agent-created one-off schedules are cleaned up automatically after they finish. When the user says stop/pause/cancel a reminder, pause or delete every matching schedule you created in this chat, not just one row.` + 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 +596,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 +610,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 +619,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(
@@ -447,15 +767,19 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                 }
               }
               const newId = genId()
+              const scheduleFollowupTarget = toolKey === 'manage_schedules'
+                ? deriveScheduleFollowupTarget(ctx?.sessionId || null)
+                : {}
               const entry = {
                 id: newId,
                 ...parsed,
                 createdByAgentId: ctx?.agentId || null,
                 createdInSessionId: ctx?.sessionId || null,
+                ...scheduleFollowupTarget,
                 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 +794,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 +839,42 @@ 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 previousEntry = all[effectiveId]
+              let affectedScheduleIds: string[] | null = null
+              const parsed = toolKey === 'manage_projects'
+                ? normalizeProjectPatchInput(buildCrudPayload(normalized, action, data))
+                : toolKey === 'manage_connectors'
+                  ? sanitizeConnectorCrudPayload(buildCrudPayload(normalized, action, data), { forUpdate: true })
+                : 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 +888,167 @@ 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(),
                 }
+                const nextStatus = typeof all[effectiveId].status === 'string' ? all[effectiveId].status.trim().toLowerCase() : ''
+                if (nextStatus === 'paused' || nextStatus === 'completed' || nextStatus === 'failed') {
+                  const relatedIds = findRelatedScheduleIds(all as Record<string, ScheduleLike>, previousEntry, {
+                    ignoreId: effectiveId,
+                  })
+                  for (const relatedId of relatedIds) {
+                    if (!all[relatedId]) continue
+                    all[relatedId] = {
+                      ...all[relatedId],
+                      status: nextStatus,
+                      updatedAt: Date.now(),
+                    }
+                  }
+                  affectedScheduleIds = [effectiveId, ...relatedIds]
+                }
               }
               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[id].scope = nextScope
-                if (typeof parsed.value === 'string' && parsed.value.trim()) {
-                  all[id].encryptedValue = encryptKey(parsed.value)
+                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
                 }
-                delete all[id].value
+                if (typeof parsedRecord.value === 'string' && parsedRecord.value.trim()) {
+                  all[effectiveId].encryptedValue = encryptKey(parsedRecord.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]))
+              }
+              if (toolKey === 'manage_schedules' && affectedScheduleIds?.length) {
+                return JSON.stringify({
+                  ...all[effectiveId],
+                  affectedScheduleIds,
+                })
+              }
+              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]
+              const deletedIds = toolKey === 'manage_schedules'
+                ? [effectiveId, ...findRelatedScheduleIds(all as Record<string, ScheduleLike>, all[effectiveId], { ignoreId: effectiveId })]
+                : [effectiveId]
+              for (const deleteId of deletedIds) {
+                delete all[deleteId]
+              }
               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,
+                deletedIds,
+              })
             }
             return `Unknown action "${action}". Valid: list, get, create, update, delete`
           } catch (err: any) {
@@ -662,7 +1062,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(),
         },
       ),
     )