@wrongstack/tools 0.284.1 → 0.286.0

package/dist/kanban.js

@@ -0,0 +1,845 @@
+// src/kanban.ts
+import { deserializeTaskGraph, serializeTaskGraph } from "@wrongstack/core";
+import {
+  addCheckToTask,
+  addColumn,
+  addDependency,
+  addGoalMetricToTask,
+  addLinkToTask,
+  addNoteToTask,
+  addTask,
+  assignTask,
+  claimReadyTask,
+  copyTaskToBoard,
+  createBoard,
+  duplicateBoard,
+  exportBoardAsMarkdown,
+  exportBoardToTaskGraph,
+  generateBoardFromDescription,
+  getBoard,
+  getKanbanOrchestrationSnapshot,
+  getKanbanQueueHealth,
+  getTask,
+  getTaskChain,
+  heartbeatTaskAssignment,
+  listBoards,
+  listKanbanEvents,
+  listReadyTasks,
+  mergeTasks,
+  moveTask,
+  parseLinesIntoTasks,
+  recoverStaleTaskAssignments,
+  releaseTaskClaim,
+  removeBoard,
+  removeColumn,
+  removeTask,
+  searchKanban,
+  setTaskChain,
+  splitTask,
+  syncBoardFromTaskGraph,
+  transferTaskToBoard,
+  updateBoard,
+  updateCheckOnTask,
+  updateColumn,
+  updateGoalMetricOnTask,
+  updateTask,
+  updateTaskAssignment
+} from "@wrongstack/kanban";
+var kanbanTool = {
+  name: "kanban",
+  category: "Project",
+  description: "Manage project-scoped multi-kanban boards stored under .wrongstack/kanbans. Supports board/task/column CRUD, ready-task queues, dependency chains, split/merge, assignment metadata, provider/model/fallback routing hints, goal metrics, success checks, notes, links, and run status updates.",
+  usageHint: "Use this for durable project kanban state. Agents should call snapshot/ready_tasks, then claim_task before working. Use set_chain for ordered work, split_task/merge_tasks when task scope changes, assign_task with provider/model/fallback hints before spawning, mark_assignment when starting or finishing, and release_task if the claim cannot be worked.",
+  permission: "confirm",
+  mutating: true,
+  capabilities: ["fs.write"],
+  icon: "task",
+  timeoutMs: 5e3,
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: [
+          "list_boards",
+          "get_board",
+          "create_board",
+          "duplicate_board",
+          "update_board",
+          "delete_board",
+          "generate_board",
+          "export_markdown",
+          "export_task_graph",
+          "sync_task_graph",
+          "search_tasks",
+          "ready_tasks",
+          "snapshot",
+          "add_column",
+          "update_column",
+          "delete_column",
+          "add_task",
+          "split_task",
+          "merge_tasks",
+          "copy_task",
+          "transfer_task",
+          "get_task",
+          "update_task",
+          "move_task",
+          "delete_task",
+          "set_chain",
+          "get_chain",
+          "claim_task",
+          "release_task",
+          "assign_task",
+          "mark_assignment",
+          "heartbeat_assignment",
+          "recover_stale",
+          "events",
+          "queue_health",
+          "add_dependency",
+          "add_goal_metric",
+          "update_goal_metric",
+          "add_check",
+          "update_check",
+          "add_note",
+          "add_link"
+        ]
+      },
+      boardId: { type: "string" },
+      taskId: { type: "string" },
+      taskIds: { type: "array", items: { type: "string" } },
+      chainId: { type: "string" },
+      columnId: { type: "string" },
+      targetBoardId: { type: "string" },
+      targetColumnId: { type: "string" },
+      title: { type: "string" },
+      description: { type: "string" },
+      tags: { type: "array", items: { type: "string" } },
+      labels: { type: "array", items: { type: "string" } },
+      priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
+      status: {
+        type: "string",
+        enum: [
+          "pending",
+          "ready",
+          "in_progress",
+          "blocked",
+          "review",
+          "completed",
+          "failed",
+          "archived"
+        ]
+      },
+      order: { type: "number" },
+      query: { type: "string" },
+      limit: { type: "number" },
+      agentId: { type: "string" },
+      name: { type: "string" },
+      role: { type: "string" },
+      provider: { type: "string" },
+      model: { type: "string" },
+      fallbackProfile: { type: "string" },
+      fallbackModels: { type: "array", items: { type: "string" } },
+      tools: { type: "array", items: { type: "string" } },
+      allowedCapabilities: { type: "array", items: { type: "string" } },
+      leaseId: { type: "string" },
+      claimedAt: { type: "string" },
+      heartbeatAt: { type: "string" },
+      leaseExpiresAt: { type: "string" },
+      attempt: { type: "number" },
+      maxAttempts: { type: "number" },
+      subagentId: { type: "string" },
+      runTaskId: { type: "string" },
+      lastResult: { type: "string" },
+      error: { type: "string" },
+      assignmentStatus: {
+        type: "string",
+        enum: ["assigned", "queued", "running", "completed", "failed", "cancelled"]
+      },
+      releaseStatus: { type: "string", enum: ["pending", "ready", "blocked"] },
+      releaseReason: { type: "string" },
+      clearAssignee: { type: "boolean" },
+      recoveryMode: { type: "string", enum: ["release", "retry", "fail"] },
+      recoveryNow: { type: "string" },
+      taskGraph: { type: "object" },
+      graphId: { type: "string" },
+      specId: { type: "string" },
+      sourceSystem: { type: "string" },
+      phaseId: { type: "string" },
+      preserveOriginTaskIds: { type: "boolean" },
+      includeArchived: { type: "boolean" },
+      archiveMissingTasks: { type: "boolean" },
+      preserveManualDependencies: { type: "boolean" },
+      dependencyTaskId: { type: "string" },
+      enforceDependencies: { type: "boolean" },
+      childTitles: { type: "array", items: { type: "string" } },
+      inheritAssignment: { type: "boolean" },
+      inheritLabels: { type: "boolean" },
+      inheritSuccessCriteria: { type: "boolean" },
+      inheritGoalMetrics: { type: "boolean" },
+      inheritDependencies: { type: "boolean" },
+      chainChildren: { type: "boolean" },
+      rewireDependents: { type: "boolean" },
+      closeSourceTasks: { type: "boolean" },
+      metricId: { type: "string" },
+      metricName: { type: "string" },
+      metricTarget: { oneOf: [{ type: "string" }, { type: "number" }] },
+      metricCurrent: { oneOf: [{ type: "string" }, { type: "number" }] },
+      metricUnit: { type: "string" },
+      metricStatus: { type: "string", enum: ["pending", "met", "missed", "waived"] },
+      metricNotes: { type: "string" },
+      checkId: { type: "string" },
+      checkDescription: { type: "string" },
+      checkStatus: { type: "string", enum: ["pending", "passed", "failed", "skipped"] },
+      note: { type: "string" },
+      author: { type: "string" },
+      url: { type: "string" },
+      linkTitle: { type: "string" },
+      linkType: {
+        type: "string",
+        enum: ["issue", "pr", "doc", "commit", "design", "file", "url", "other"]
+      },
+      context: { type: "string" },
+      columns: { type: "array", items: { type: "string" } },
+      generatedBy: { type: "string" },
+      includeTasks: { type: "boolean" },
+      includeCompletedTasks: { type: "boolean" },
+      preserveAssignment: { type: "boolean" },
+      preserveDependencies: { type: "boolean" },
+      moveTasksToColumnId: { type: "string" }
+    },
+    required: ["action"]
+  },
+  async execute(input, ctx) {
+    const projectRoot = ctx.projectRoot;
+    if (!projectRoot) return fail("No project root is available.");
+    try {
+      switch (input.action) {
+        case "list_boards": {
+          const boards = await listBoards(projectRoot);
+          return { ok: true, message: `${boards.length} board(s).`, boards };
+        }
+        case "get_board": {
+          const board = await requireBoard(projectRoot, input.boardId);
+          return board ? okBoard(board) : fail("Board not found.");
+        }
+        case "create_board": {
+          if (!input.title) return fail("create_board requires title.");
+          const board = await createBoard(projectRoot, {
+            title: input.title,
+            ...input.description !== void 0 ? { description: input.description } : {},
+            ...input.tags !== void 0 ? { tags: input.tags } : {},
+            ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {}
+          });
+          return { ok: true, message: `Board created: ${board.title}`, board };
+        }
+        case "update_board": {
+          if (!input.boardId) return fail("update_board requires boardId.");
+          const board = await updateBoard(projectRoot, input.boardId, {
+            ...input.title !== void 0 ? { title: input.title } : {},
+            ...input.description !== void 0 ? { description: input.description } : {},
+            ...input.tags !== void 0 ? { tags: input.tags } : {}
+          });
+          return board ? okBoard(board, "Board updated.") : fail("Board not found.");
+        }
+        case "duplicate_board": {
+          if (!input.boardId) return fail("duplicate_board requires boardId.");
+          const board = await duplicateBoard(projectRoot, input.boardId, {
+            ...input.title !== void 0 ? { title: input.title } : {},
+            ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
+            ...input.includeTasks !== void 0 ? { includeTasks: input.includeTasks } : {},
+            ...input.includeCompletedTasks !== void 0 ? { includeCompletedTasks: input.includeCompletedTasks } : {},
+            ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {}
+          });
+          return board ? okBoard(board, "Board duplicated.") : fail("Board not found.");
+        }
+        case "delete_board": {
+          if (!input.boardId) return fail("delete_board requires boardId.");
+          const removed = await removeBoard(projectRoot, input.boardId);
+          return { ok: removed, message: removed ? "Board deleted." : "Board not found." };
+        }
+        case "generate_board": {
+          if (!input.description) return fail("generate_board requires description.");
+          const boardInput = generateBoardFromDescription({
+            description: input.description,
+            ...input.title !== void 0 ? { title: input.title } : {},
+            ...input.context !== void 0 ? { context: input.context } : {},
+            ...input.columns !== void 0 ? { columns: input.columns } : {}
+          });
+          const board = await createBoard(projectRoot, boardInput);
+          for (const taskInput2 of parseLinesIntoTasks(
+            input.description,
+            board.columns[0]?.id ?? "backlog"
+          )) {
+            await addTask(projectRoot, board.id, taskInput2);
+          }
+          return okBoard(await getBoard(projectRoot, board.id) ?? board, "Board generated.");
+        }
+        case "export_markdown": {
+          const board = await requireBoard(projectRoot, input.boardId);
+          if (!board) return fail("Board not found.");
+          return {
+            ok: true,
+            message: "Board exported.",
+            board,
+            markdown: exportBoardAsMarkdown(board)
+          };
+        }
+        case "export_task_graph": {
+          if (!input.boardId) return fail("export_task_graph requires boardId.");
+          const exported = await exportBoardToTaskGraph(projectRoot, input.boardId, {
+            ...input.graphId !== void 0 ? { graphId: input.graphId } : {},
+            ...input.specId !== void 0 ? { specId: input.specId } : {},
+            ...input.title !== void 0 ? { title: input.title } : {},
+            ...input.preserveOriginTaskIds !== void 0 ? { preserveOriginTaskIds: input.preserveOriginTaskIds } : {},
+            ...input.includeArchived !== void 0 ? { includeArchived: input.includeArchived } : {}
+          });
+          if (!exported) return fail("Board not found.");
+          return {
+            ok: true,
+            message: `Task graph exported with ${exported.graph.nodes.size} node(s).`,
+            board: exported.board,
+            taskGraph: serializeTaskGraph(exported.graph)
+          };
+        }
+        case "sync_task_graph": {
+          if (!input.boardId || !input.taskGraph) {
+            return fail("sync_task_graph requires boardId and taskGraph.");
+          }
+          const graph = deserializeTaskGraph(input.taskGraph);
+          const result = await syncBoardFromTaskGraph(projectRoot, input.boardId, graph, {
+            ...input.title !== void 0 ? { title: input.title } : {},
+            ...input.description !== void 0 ? { description: input.description } : {},
+            ...input.tags !== void 0 ? { tags: input.tags } : {},
+            ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
+            ...input.sourceSystem !== void 0 ? { sourceSystem: input.sourceSystem } : {},
+            ...input.phaseId !== void 0 ? { phaseId: input.phaseId } : {},
+            ...input.includeCompletedTasks !== void 0 ? { includeCompletedTasks: input.includeCompletedTasks } : {},
+            ...input.archiveMissingTasks !== void 0 ? { archiveMissingTasks: input.archiveMissingTasks } : {},
+            ...input.preserveManualDependencies !== void 0 ? { preserveManualDependencies: input.preserveManualDependencies } : {}
+          });
+          return result ? {
+            ok: true,
+            message: `Task graph synced: ${result.createdTaskIds.length} created, ${result.updatedTaskIds.length} updated, ${result.archivedTaskIds.length} archived.`,
+            board: result.board
+          } : fail("Board not found.");
+        }
+        case "search_tasks": {
+          const tasks = await searchKanban(projectRoot, {
+            query: input.query,
+            boardId: input.boardId,
+            assignedAgent: input.agentId,
+            status: input.status,
+            priority: input.priority,
+            label: input.labels?.[0],
+            chainId: input.chainId
+          });
+          return { ok: true, message: `${tasks.length} task(s) matched.`, tasks };
+        }
+        case "ready_tasks": {
+          const tasks = await listReadyTasks(projectRoot, {
+            query: input.query,
+            boardId: input.boardId,
+            assignedAgent: input.agentId,
+            priority: input.priority,
+            label: input.labels?.[0],
+            chainId: input.chainId,
+            limit: input.limit
+          });
+          return { ok: true, message: `${tasks.length} ready task(s).`, tasks };
+        }
+        case "snapshot": {
+          const snapshot = await getKanbanOrchestrationSnapshot(projectRoot, {
+            query: input.query,
+            boardId: input.boardId,
+            assignedAgent: input.agentId,
+            status: input.status,
+            priority: input.priority,
+            label: input.labels?.[0],
+            chainId: input.chainId
+          });
+          return {
+            ok: true,
+            message: `${snapshot.ready.length} ready, ${snapshot.running.length} running, ${snapshot.blocked.length} blocked.`,
+            snapshot
+          };
+        }
+        case "add_column": {
+          if (!input.boardId || !input.title) return fail("add_column requires boardId and title.");
+          const result = await addColumn(projectRoot, input.boardId, {
+            title: input.title,
+            ...input.description !== void 0 ? { description: input.description } : {}
+          });
+          return result ? okBoard(result.board, "Column added.") : fail("Board not found.");
+        }
+        case "update_column": {
+          if (!input.boardId || !input.columnId)
+            return fail("update_column requires boardId and columnId.");
+          const board = await updateColumn(projectRoot, input.boardId, input.columnId, {
+            ...input.title !== void 0 ? { title: input.title } : {},
+            ...input.description !== void 0 ? { description: input.description } : {},
+            ...input.order !== void 0 ? { order: input.order } : {}
+          });
+          return board ? okBoard(board, "Column updated.") : fail("Column not found.");
+        }
+        case "delete_column": {
+          if (!input.boardId || !input.columnId)
+            return fail("delete_column requires boardId and columnId.");
+          const board = await removeColumn(projectRoot, input.boardId, input.columnId, {
+            moveTasksToColumnId: input.moveTasksToColumnId
+          });
+          return board ? okBoard(board, "Column deleted.") : fail("Column not found.");
+        }
+        case "add_task": {
+          if (!input.boardId || !input.title) return fail("add_task requires boardId and title.");
+          const result = await addTask(projectRoot, input.boardId, taskInput(input));
+          return result ? okTask(result.board, result.task, "Task added.") : fail("Board not found.");
+        }
+        case "split_task": {
+          if (!input.boardId || !input.taskId || !input.childTitles?.length) {
+            return fail("split_task requires boardId, taskId, and childTitles.");
+          }
+          const result = await splitTask(projectRoot, input.boardId, input.taskId, {
+            titles: input.childTitles,
+            ...input.targetColumnId !== void 0 ? { columnId: input.targetColumnId } : {},
+            ...input.inheritAssignment !== void 0 ? { inheritAssignment: input.inheritAssignment } : {},
+            ...input.inheritLabels !== void 0 ? { inheritLabels: input.inheritLabels } : {},
+            ...input.inheritSuccessCriteria !== void 0 ? { inheritSuccessCriteria: input.inheritSuccessCriteria } : {},
+            ...input.inheritGoalMetrics !== void 0 ? { inheritGoalMetrics: input.inheritGoalMetrics } : {},
+            ...input.inheritDependencies !== void 0 ? { inheritDependencies: input.inheritDependencies } : {},
+            ...input.chainChildren !== void 0 ? { chainChildren: input.chainChildren } : {},
+            ...input.rewireDependents !== void 0 ? { rewireDependents: input.rewireDependents } : {}
+          });
+          return result ? {
+            ok: true,
+            message: `${result.children.length} child task(s) created.`,
+            board: result.board,
+            task: result.parent,
+            children: result.children
+          } : fail("Task not found.");
+        }
+        case "merge_tasks": {
+          if (!input.boardId || !input.taskIds?.length || !input.title) {
+            return fail("merge_tasks requires boardId, taskIds, and title.");
+          }
+          const result = await mergeTasks(projectRoot, input.boardId, {
+            taskIds: input.taskIds,
+            title: input.title,
+            ...input.description !== void 0 ? { description: input.description } : {},
+            ...input.targetColumnId !== void 0 ? { targetColumnId: input.targetColumnId } : {},
+            ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {},
+            ...input.closeSourceTasks !== void 0 ? { closeSourceTasks: input.closeSourceTasks } : {}
+          });
+          return result ? okTask(result.board, result.task, "Tasks merged.") : fail("Board or task not found.");
+        }
+        case "copy_task": {
+          if (!input.boardId || !input.taskId || !input.targetBoardId) {
+            return fail("copy_task requires boardId, taskId, and targetBoardId.");
+          }
+          const result = await copyTaskToBoard(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            input.targetBoardId,
+            {
+              ...input.targetColumnId !== void 0 ? { targetColumnId: input.targetColumnId } : {},
+              ...input.order !== void 0 ? { targetOrder: input.order } : {},
+              ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {},
+              ...input.preserveDependencies !== void 0 ? { preserveDependencies: input.preserveDependencies } : {}
+            }
+          );
+          return result ? okTask(result.targetBoard, result.task, "Task copied to target board.") : fail("Board or task not found.");
+        }
+        case "transfer_task": {
+          if (!input.boardId || !input.taskId || !input.targetBoardId) {
+            return fail("transfer_task requires boardId, taskId, and targetBoardId.");
+          }
+          const result = await transferTaskToBoard(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            input.targetBoardId,
+            {
+              ...input.targetColumnId !== void 0 ? { targetColumnId: input.targetColumnId } : {},
+              ...input.order !== void 0 ? { targetOrder: input.order } : {},
+              ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {},
+              ...input.preserveDependencies !== void 0 ? { preserveDependencies: input.preserveDependencies } : {}
+            }
+          );
+          return result ? okTask(result.targetBoard, result.task, "Task transferred to target board.") : fail("Board or task not found.");
+        }
+        case "get_task": {
+          if (!input.boardId || !input.taskId) return fail("get_task requires boardId and taskId.");
+          const task = await getTask(projectRoot, input.boardId, input.taskId);
+          return task ? { ok: true, message: "Task loaded.", task } : fail("Task not found.");
+        }
+        case "update_task": {
+          if (!input.boardId || !input.taskId)
+            return fail("update_task requires boardId and taskId.");
+          const board = await updateTask(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            taskPatch(input)
+          );
+          return board ? okBoard(board, "Task updated.") : fail("Task not found.");
+        }
+        case "move_task": {
+          if (!input.boardId || !input.taskId || !input.targetColumnId) {
+            return fail("move_task requires boardId, taskId, and targetColumnId.");
+          }
+          const board = await moveTask(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            input.targetColumnId,
+            input.order
+          );
+          return board ? okBoard(board, "Task moved.") : fail("Move failed.");
+        }
+        case "delete_task": {
+          if (!input.boardId || !input.taskId)
+            return fail("delete_task requires boardId and taskId.");
+          const board = await removeTask(projectRoot, input.boardId, input.taskId);
+          return board ? okBoard(board, "Task deleted.") : fail("Task not found.");
+        }
+        case "set_chain": {
+          if (!input.boardId || !input.taskIds?.length) {
+            return fail("set_chain requires boardId and taskIds.");
+          }
+          const result = await setTaskChain(projectRoot, input.boardId, {
+            taskIds: input.taskIds,
+            ...input.chainId !== void 0 ? { chainId: input.chainId } : {},
+            ...input.enforceDependencies !== void 0 ? { enforceDependencies: input.enforceDependencies } : {}
+          });
+          return result ? {
+            ok: true,
+            message: `Chain set: ${result.chainId}`,
+            board: result.board,
+            chain: result.tasks
+          } : fail("Board or task not found.");
+        }
+        case "get_chain": {
+          if (!input.boardId || !(input.taskId || input.chainId)) {
+            return fail("get_chain requires boardId and taskId or chainId.");
+          }
+          const result = await getTaskChain(
+            projectRoot,
+            input.boardId,
+            input.taskId ?? input.chainId ?? ""
+          );
+          return result ? {
+            ok: true,
+            message: `Chain loaded: ${result.chainId}`,
+            board: result.board,
+            chain: result.tasks
+          } : fail("Chain not found.");
+        }
+        case "claim_task": {
+          const result = await claimReadyTask(projectRoot, {
+            ...input.boardId !== void 0 ? { boardId: input.boardId } : {},
+            ...input.taskId !== void 0 ? { taskId: input.taskId } : {},
+            ...assignmentInput(input),
+            status: input.assignmentStatus ?? "queued"
+          });
+          return result ? okTask(result.board, result.task, "Task claimed.") : fail("No ready kanban task matched the claim.");
+        }
+        case "release_task": {
+          if (!input.boardId || !input.taskId) {
+            return fail("release_task requires boardId and taskId.");
+          }
+          const board = await releaseTaskClaim(projectRoot, input.boardId, input.taskId, {
+            ...input.releaseStatus !== void 0 ? { status: input.releaseStatus } : {},
+            ...input.releaseReason !== void 0 ? { reason: input.releaseReason } : {},
+            ...input.clearAssignee !== void 0 ? { clearAssignee: input.clearAssignee } : {}
+          });
+          return board ? okBoard(board, "Task claim released.") : fail("Task not found.");
+        }
+        case "assign_task": {
+          if (!input.boardId || !input.taskId)
+            return fail("assign_task requires boardId and taskId.");
+          const board = await assignTask(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            assignmentInput(input)
+          );
+          return board ? okBoard(board, "Task assigned.") : fail("Task not found.");
+        }
+        case "mark_assignment": {
+          if (!input.boardId || !input.taskId)
+            return fail("mark_assignment requires boardId and taskId.");
+          const assignmentStatus = input.assignmentStatus ?? (input.status === "completed" ? "completed" : input.error ? "failed" : void 0);
+          const board = await updateTaskAssignment(projectRoot, input.boardId, input.taskId, {
+            ...assignmentStatus !== void 0 ? { status: assignmentStatus } : {},
+            ...input.subagentId !== void 0 ? { subagentId: input.subagentId } : {},
+            ...input.runTaskId !== void 0 ? { runTaskId: input.runTaskId } : {},
+            ...input.lastResult !== void 0 ? { lastResult: input.lastResult } : {},
+            ...input.error !== void 0 ? { error: input.error } : {},
+            ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
+            ...input.leaseId !== void 0 ? { leaseId: input.leaseId } : {},
+            ...input.claimedAt !== void 0 ? { claimedAt: input.claimedAt } : {},
+            ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
+            ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
+            ...input.attempt !== void 0 ? { attempt: input.attempt } : {},
+            ...input.maxAttempts !== void 0 ? { maxAttempts: input.maxAttempts } : {}
+          });
+          return board ? okBoard(board, "Assignment updated.") : fail("Task not found.");
+        }
+        case "heartbeat_assignment": {
+          if (!input.boardId || !input.taskId) {
+            return fail("heartbeat_assignment requires boardId and taskId.");
+          }
+          const board = await heartbeatTaskAssignment(projectRoot, input.boardId, input.taskId, {
+            ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
+            ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {}
+          });
+          return board ? okBoard(board, "Assignment heartbeat updated.") : fail("Task assignment not found.");
+        }
+        case "recover_stale": {
+          if (!input.boardId) return fail("recover_stale requires boardId.");
+          const policyFields = [
+            input.recoveryPolicyFailOnCostCeiling !== void 0,
+            input.recoveryPolicyReleaseOnFailureKinds !== void 0,
+            input.recoveryPolicyReleaseOnHeartbeatDue !== void 0,
+            input.recoveryPolicyRetryPolicyOverride !== void 0
+          ].some(Boolean);
+          const result = await recoverStaleTaskAssignments(projectRoot, input.boardId, {
+            ...input.recoveryMode !== void 0 ? { mode: input.recoveryMode } : {},
+            ...input.recoveryNow !== void 0 ? { now: input.recoveryNow } : {},
+            ...input.releaseReason !== void 0 ? { reason: input.releaseReason } : {},
+            ...input.clearAssignee !== void 0 ? { clearAssignee: input.clearAssignee } : {},
+            ...policyFields ? {
+              policy: {
+                ...input.recoveryPolicyFailOnCostCeiling !== void 0 ? { failWhenCostCeilingSet: input.recoveryPolicyFailOnCostCeiling } : {},
+                ...input.recoveryPolicyReleaseOnFailureKinds !== void 0 ? {
+                  releaseOnFailureKinds: input.recoveryPolicyReleaseOnFailureKinds
+                } : {},
+                ...input.recoveryPolicyReleaseOnHeartbeatDue !== void 0 ? {
+                  releaseOnHeartbeatDue: input.recoveryPolicyReleaseOnHeartbeatDue
+                } : {},
+                ...input.recoveryPolicyRetryPolicyOverride !== void 0 ? {
+                  retryPolicyOverride: input.recoveryPolicyRetryPolicyOverride
+                } : {}
+              }
+            } : {}
+          });
+          return result ? {
+            ok: true,
+            message: `Recovered ${result.tasks.length} stale assignment(s).`,
+            board: result.board,
+            recoveredTasks: result.tasks
+          } : { ok: true, message: "No stale assignment matched.", recoveredTasks: [] };
+        }
+        case "events": {
+          if (!input.boardId) return fail("events requires boardId.");
+          const eventList = await listKanbanEvents(projectRoot, input.boardId);
+          return {
+            ok: true,
+            message: `${eventList.length} event(s).`,
+            events: eventList
+          };
+        }
+        case "queue_health": {
+          const health = await getKanbanQueueHealth(projectRoot, {
+            ...input.boardId !== void 0 ? { boardId: input.boardId } : {}
+          });
+          return {
+            ok: true,
+            message: `Counts: ready=${health.counts.ready}, running=${health.counts.running}, stale=${health.staleAssignments.count}.`,
+            queueHealth: health
+          };
+        }
+        case "add_dependency": {
+          if (!input.boardId || !input.taskId || !input.dependencyTaskId) {
+            return fail("add_dependency requires boardId, taskId, and dependencyTaskId.");
+          }
+          const board = await addDependency(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            input.dependencyTaskId
+          );
+          return board ? okBoard(board, "Dependency added.") : fail("Task not found.");
+        }
+        case "add_goal_metric": {
+          if (!input.boardId || !input.taskId || !input.metricName) {
+            return fail("add_goal_metric requires boardId, taskId, and metricName.");
+          }
+          const board = await addGoalMetricToTask(projectRoot, input.boardId, input.taskId, {
+            name: input.metricName,
+            ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
+            ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
+            ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+            ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
+            ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
+          });
+          return board ? okBoard(board, "Goal metric added.") : fail("Task not found.");
+        }
+        case "update_goal_metric": {
+          if (!input.boardId || !input.taskId || !input.metricId) {
+            return fail("update_goal_metric requires boardId, taskId, and metricId.");
+          }
+          const board = await updateGoalMetricOnTask(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            input.metricId,
+            {
+              ...input.metricName !== void 0 ? { name: input.metricName } : {},
+              ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
+              ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
+              ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+              ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
+              ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
+            }
+          );
+          return board ? okBoard(board, "Goal metric updated.") : fail("Metric not found.");
+        }
+        case "add_check": {
+          if (!input.boardId || !input.taskId || !input.checkDescription) {
+            return fail("add_check requires boardId, taskId, and checkDescription.");
+          }
+          const board = await addCheckToTask(projectRoot, input.boardId, input.taskId, {
+            description: input.checkDescription,
+            type: "manual",
+            status: input.checkStatus
+          });
+          return board ? okBoard(board, "Check added.") : fail("Task not found.");
+        }
+        case "update_check": {
+          if (!input.boardId || !input.taskId || !input.checkId) {
+            return fail("update_check requires boardId, taskId, and checkId.");
+          }
+          const board = await updateCheckOnTask(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            input.checkId,
+            {
+              ...input.checkDescription !== void 0 ? { description: input.checkDescription } : {},
+              ...input.checkStatus !== void 0 ? { status: input.checkStatus } : {}
+            }
+          );
+          return board ? okBoard(board, "Check updated.") : fail("Check not found.");
+        }
+        case "add_note": {
+          if (!input.boardId || !input.taskId || !input.note)
+            return fail("add_note requires boardId, taskId, and note.");
+          const board = await addNoteToTask(projectRoot, input.boardId, input.taskId, {
+            author: input.author ?? "agent",
+            content: input.note
+          });
+          return board ? okBoard(board, "Note added.") : fail("Task not found.");
+        }
+        case "add_link": {
+          if (!input.boardId || !input.taskId || !input.url)
+            return fail("add_link requires boardId, taskId, and url.");
+          const board = await addLinkToTask(projectRoot, input.boardId, input.taskId, {
+            url: input.url,
+            type: input.linkType ?? "url",
+            ...input.linkTitle !== void 0 ? { title: input.linkTitle } : {}
+          });
+          return board ? okBoard(board, "Link added.") : fail("Task not found.");
+        }
+        default:
+          return fail(`Unknown kanban action: ${input.action}`);
+      }
+    } catch (err) {
+      return fail(err instanceof Error ? err.message : String(err));
+    }
+  }
+};
+function fail(message) {
+  return { ok: false, message };
+}
+function okBoard(board, message = "Board loaded.") {
+  return { ok: true, message, board };
+}
+function okTask(board, task, message) {
+  return { ok: true, message, board, task };
+}
+async function requireBoard(projectRoot, boardId) {
+  return boardId ? getBoard(projectRoot, boardId) : null;
+}
+function taskInput(input) {
+  const assignment = hasAssignmentInput(input) ? assignmentForTaskCreate(input) : void 0;
+  return {
+    title: input.title ?? "",
+    columnId: input.columnId,
+    description: input.description,
+    priority: input.priority,
+    status: input.status,
+    labels: input.labels,
+    ...assignment?.agentId ?? assignment?.role ?? assignment?.name ? { assignedAgent: assignment.agentId ?? assignment.role ?? assignment.name } : {},
+    ...input.assignee ?? assignment?.name ?? assignment?.agentId ? { assignee: input.assignee ?? assignment?.name ?? assignment?.agentId } : {},
+    ...input.dependencyTaskId !== void 0 ? { dependsOn: [input.dependencyTaskId] } : {},
+    ...assignment ? { assignment } : {}
+  };
+}
+function taskPatch(input) {
+  return {
+    title: input.title,
+    description: input.description,
+    columnId: input.columnId,
+    order: input.order,
+    priority: input.priority,
+    status: input.status,
+    labels: input.labels,
+    assignedAgent: input.agentId,
+    ...input.dependencyTaskId !== void 0 ? { dependsOn: [input.dependencyTaskId] } : {}
+  };
+}
+function assignmentInput(input) {
+  return {
+    agentId: input.agentId,
+    name: input.name,
+    role: input.role,
+    provider: input.provider,
+    model: input.model,
+    fallbackProfile: input.fallbackProfile,
+    fallbackModels: input.fallbackModels,
+    tools: input.tools,
+    allowedCapabilities: input.allowedCapabilities,
+    assignee: input.assignee,
+    leaseId: input.leaseId,
+    claimedAt: input.claimedAt,
+    heartbeatAt: input.heartbeatAt,
+    leaseExpiresAt: input.leaseExpiresAt,
+    attempt: input.attempt,
+    maxAttempts: input.maxAttempts,
+    costCeilingUsd: input.costCeilingUsd,
+    retryPolicy: input.retryPolicy,
+    lastFailureKind: input.lastFailureKind
+  };
+}
+function hasAssignmentInput(input) {
+  return input.agentId !== void 0 || input.name !== void 0 || input.role !== void 0 || input.provider !== void 0 || input.model !== void 0 || input.fallbackProfile !== void 0 || input.fallbackModels !== void 0 || input.tools !== void 0 || input.allowedCapabilities !== void 0 || input.assignee !== void 0 || input.leaseId !== void 0 || input.claimedAt !== void 0 || input.heartbeatAt !== void 0 || input.leaseExpiresAt !== void 0 || input.attempt !== void 0 || input.maxAttempts !== void 0 || input.costCeilingUsd !== void 0 || input.retryPolicy !== void 0 || input.lastFailureKind !== void 0 || input.assignmentStatus !== void 0;
+}
+function assignmentForTaskCreate(input) {
+  return {
+    status: input.assignmentStatus ?? "assigned",
+    ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
+    ...input.name !== void 0 ? { name: input.name } : {},
+    ...input.role !== void 0 ? { role: input.role } : {},
+    ...input.provider !== void 0 ? { provider: input.provider } : {},
+    ...input.model !== void 0 ? { model: input.model } : {},
+    ...input.fallbackProfile !== void 0 ? { fallbackProfile: input.fallbackProfile } : {},
+    ...input.fallbackModels !== void 0 ? { fallbackModels: input.fallbackModels } : {},
+    ...input.tools !== void 0 ? { tools: input.tools } : {},
+    ...input.allowedCapabilities !== void 0 ? { allowedCapabilities: input.allowedCapabilities } : {},
+    ...input.leaseId !== void 0 ? { leaseId: input.leaseId } : {},
+    ...input.claimedAt !== void 0 ? { claimedAt: input.claimedAt } : {},
+    ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
+    ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
+    ...input.attempt !== void 0 ? { attempt: input.attempt } : {},
+    ...input.maxAttempts !== void 0 ? { maxAttempts: input.maxAttempts } : {},
+    ...input.costCeilingUsd !== void 0 ? { costCeilingUsd: input.costCeilingUsd } : {},
+    ...input.retryPolicy !== void 0 ? { retryPolicy: input.retryPolicy } : {},
+    ...input.lastFailureKind !== void 0 ? { lastFailureKind: input.lastFailureKind } : {}
+  };
+}
+export {
+  kanbanTool
+};
+//# sourceMappingURL=kanban.js.map