@wrongstack/tools 0.295.1 → 0.296.2

package/dist/kanban.js

@@ -1,15 +1,10 @@
 // src/kanban.ts
-import { randomUUID } from "node:crypto";
 import { deserializeTaskGraph as deserializeTaskGraph2, serializeTaskGraph } from "@wrongstack/core/tasking";
 import { loadTasks as loadTasks2 } from "@wrongstack/core/storage";
 import {
-  addCheckToTask,
   addColumn,
-  addDependency,
-  addGoalMetricToTask,
-  addLinkToTask,
-  addNoteToTask,
   addTask,
+  adoptManagedLifecycle,
   assignTask,
   claimReadyTask,
   copyTaskToBoard,
@@ -19,7 +14,7 @@ import {
   exportBoardAsMarkdown,
   exportBoardToTaskGraph,
   createBoardFromText,
-  getBoard as getBoard2,
+  getBoard as getBoard3,
   getKanbanOrchestrationSnapshot,
   getKanbanQueueHealth,
   getTask,
@@ -32,27 +27,22 @@ import {
   moveTask,
   parseLinesIntoTasks,
   recoverStaleTaskAssignments,
+  repairManagedTaskProjection,
   releaseTaskClaim,
   removeBoard as removeBoard2,
   removeColumn,
   removeTask,
   searchKanban,
   setTaskChain,
-  splitTask,
   syncBoardFromTaskGraph as syncBoardFromTaskGraph2,
   transitionTask,
   transferTaskToBoard,
-  touchKanbanPresence as touchKanbanPresence2,
   updateBoard as updateBoard2,
-  updateCheckOnTask,
   updateColumn,
-  updateGoalMetricOnTask,
-  updateTask,
+  updateTask as updateTask2,
   updateTaskAssignment,
-  verifyTaskCompletion,
-  finalizeTaskCompletion,
-  assessTaskAtomicity,
-  proposeTaskDecomposition
+  verifyTaskCompletion as verifyTaskCompletion2,
+  finalizeTaskCompletion
 } from "@wrongstack/kanban";
 
 // src/kanban-evidence-bridge.ts
@@ -78,409 +68,882 @@ function recordKanbanVerificationEvidence(ctx, report) {
   }
 }
 
-// src/session-kanban.ts
-import { GlobalMailbox } from "@wrongstack/core/coordination";
+// src/kanban-decomposition-actions.ts
 import {
-  loadPlan,
-  loadTasks,
-  mutatePlan,
-  mutateTasks
-} from "@wrongstack/core/storage";
-import { deserializeTaskGraph } from "@wrongstack/core/tasking";
-import { resolveWstackPaths } from "@wrongstack/core/utils";
+  assessTaskAtomicity,
+  proposeTaskDecomposition,
+  updateTask,
+  verifyTaskCompletion
+} from "@wrongstack/kanban";
+
+// src/kanban-tool-results.ts
+function atomicityNudge(task) {
+  if (task.atomicityAssessment?.verdict !== "needs_decomposition") return "";
+  const reasons = task.atomicityAssessment.criteria.filter((entry) => entry.score < 1).map((entry) => entry.reason).join(" | ");
+  return ` Atomicity: needs_decomposition (score ${task.atomicityAssessment.score}) \u2014 call propose_decomposition with 2+ subtasks before dispatch. Reasons: ${reasons}`;
+}
+function readEnvGateEnforcement() {
+  const raw = process.env["WRONGSTACK_KANBAN_GATE"]?.trim().toLowerCase();
+  return raw === "strict" || raw === "soft" || raw === "off" ? raw : void 0;
+}
+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 };
+}
+
+// src/kanban-decomposition-actions.ts
+async function handleKanbanDecompositionAction(projectRoot, input, ctx) {
+  switch (input.action) {
+    case "assess_atomicity": {
+      if (!input.boardId || !input.taskId) {
+        return fail("assess_atomicity requires boardId and taskId.");
+      }
+      const result = await assessTaskAtomicity(projectRoot, input.boardId, input.taskId, {
+        assessedBy: "agent",
+        ...ctx.agentId !== void 0 ? { eventContext: { actor: ctx.agentId } } : {}
+      });
+      if (!result) return fail("Task not found.");
+      const failing = result.assessment.criteria.filter((entry) => entry.score < 1).map((entry) => entry.reason);
+      const guidance = result.assessment.verdict === "needs_decomposition" ? ` This task should be split before dispatch \u2014 call propose_decomposition with 2+ subtasks (each with one verifiable success criterion). Reasons: ${failing.join(" | ")}` : result.assessment.verdict === "composite" ? " Container task: work happens in its children; it is verified via subtask aggregation." : "";
+      return okTask(
+        result.board,
+        result.task,
+        `Atomicity verdict: ${result.assessment.verdict} (score ${result.assessment.score}).${guidance}`
+      );
+    }
+    case "propose_decomposition": {
+      if (!input.boardId || !input.taskId || !input.subtasks?.length) {
+        return fail("propose_decomposition requires boardId, taskId, and subtasks (2+).");
+      }
+      if (input.subtasks.length < 2) {
+        return fail("propose_decomposition requires at least two subtasks.");
+      }
+      const invalid = input.subtasks.find(
+        (subtask) => typeof subtask?.title !== "string" || !subtask.title.trim()
+      );
+      if (invalid) return fail("Every proposed subtask needs a non-blank title.");
+      const result = await proposeTaskDecomposition(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        {
+          subtasks: input.subtasks,
+          ...input.note !== void 0 ? { rationale: input.note } : {},
+          ...ctx.agentId !== void 0 ? { proposedBy: ctx.agentId } : {}
+        },
+        ctx.agentId !== void 0 ? { actor: ctx.agentId } : {}
+      );
+      if (!result) return fail("Task not found.");
+      const message = result.proposal.status === "applied" ? `Decomposition applied: ${result.proposal.appliedChildTaskIds?.length ?? 0} child tasks created (parent marked atomic).` : 'Decomposition proposal recorded \u2014 awaiting approval (board policy is "propose"). It can be approved from the WebUI or via update_task.';
+      return okTask(result.board, result.task, message);
+    }
+    case "verify_completion": {
+      if (!input.boardId || !input.taskId) {
+        return fail("verify_completion requires boardId and taskId.");
+      }
+      const verResult = await verifyTaskCompletion(projectRoot, input.boardId, input.taskId);
+      const persistedBoard = await updateTask(projectRoot, input.boardId, input.taskId, {
+        verificationReport: verResult.report,
+        successCriteria: verResult.task.successCriteria
+      });
+      if (!persistedBoard) {
+        return {
+          ok: false,
+          verdict: verResult.report.verdict,
+          message: `Verification succeeded but persist failed: ${verResult.report.markdownSummary}. Board may be stale \u2014 re-run verify_completion.`,
+          board: verResult.board
+        };
+      }
+      recordKanbanVerificationEvidence(ctx, verResult.report);
+      const freshTask = persistedBoard.tasks?.find((t) => t.id === input.taskId);
+      const deterministicVerdicts = ["passed", "failed", "needs_human", "incomplete"];
+      return {
+        ok: deterministicVerdicts.includes(
+          verResult.report.verdict
+        ),
+        verdict: verResult.report.verdict,
+        message: verResult.report.markdownSummary,
+        board: persistedBoard,
+        task: freshTask ?? verResult.task
+      };
+    }
+    default:
+      return void 0;
+  }
+}
+
+// src/kanban-detail-actions.ts
 import {
-  createBoard,
-  getBoard,
-  getKanbanDir,
-  listBoards,
-  removeBoard,
-  syncBoardFromTaskGraph,
-  touchKanbanPresence,
-  updateBoard
+  addCheckToTask,
+  addDependency,
+  addGoalMetricToTask,
+  addLinkToTask,
+  addNoteToTask,
+  updateCheckOnTask,
+  updateGoalMetricOnTask
 } from "@wrongstack/kanban";
-function taskFileToSerializedGraph(tasks, sessionId) {
-  const ids = new Set(tasks.map((task) => task.id));
-  const nodes = tasks.map((task, index) => ({
-    id: task.id,
-    title: task.title,
-    description: task.description ?? "",
-    type: task.type,
-    priority: task.priority,
-    status: task.status,
-    ...task.assignee ? { assignee: task.assignee } : {},
-    ...task.estimateHours !== void 0 ? { estimateHours: task.estimateHours } : {},
-    createdAt: index,
-    updatedAt: index
-  }));
-  const edges = tasks.flatMap(
-    (task) => (task.dependsOn ?? []).filter((dependency) => ids.has(dependency)).map((dependency) => ({
-      id: `${dependency}->${task.id}`,
-      from: dependency,
-      to: task.id,
-      type: "depends_on"
-    }))
-  );
-  const hasIncoming = new Set(edges.map((edge) => edge.to));
-  const rootNodes = nodes.filter((node) => !hasIncoming.has(node.id)).map((node) => node.id);
+
+// src/kanban-split-task-handler.ts
+import { getBoard, splitTask } from "@wrongstack/kanban";
+async function handleSplitTask(projectRoot, input, extraSplitOptions) {
+  const boardId = input.boardId;
+  const taskId = input.taskId;
+  const childTitles = input.childTitles;
+  if (!boardId || !taskId || !childTitles?.length) {
+    return fail("split requires boardId, taskId, and at least one childTitles.");
+  }
+  const {
+    targetColumnId,
+    inheritAssignment,
+    inheritLabels,
+    inheritSuccessCriteria,
+    inheritGoalMetrics,
+    inheritDependencies,
+    chainChildren,
+    rewireDependents
+  } = input;
+  const result = await splitTask(projectRoot, boardId, taskId, {
+    titles: childTitles,
+    ...extraSplitOptions,
+    ...targetColumnId !== void 0 ? { columnId: targetColumnId } : {},
+    ...inheritAssignment !== void 0 ? { inheritAssignment } : {},
+    ...inheritLabels !== void 0 ? { inheritLabels } : {},
+    ...inheritSuccessCriteria !== void 0 ? { inheritSuccessCriteria } : {},
+    ...inheritGoalMetrics !== void 0 ? { inheritGoalMetrics } : {},
+    ...inheritDependencies !== void 0 ? { inheritDependencies } : {},
+    ...chainChildren !== void 0 ? { chainChildren } : {},
+    ...rewireDependents !== void 0 ? { rewireDependents } : {}
+  });
+  if (!result) return fail("Task not found.");
+  const freshParent = result.board.tasks?.find((t) => t.id === taskId);
+  if (!freshParent) {
+    return fail(
+      `Split succeeded but parent ${taskId} not found in returned board. Children: [${result.children.map((c) => c.id).join(", ")}].`
+    );
+  }
   return {
-    // Keep the historical graph id so existing mirrored task cards are reused.
-    id: `session:${sessionId}`,
-    specId: `session:${sessionId}`,
-    title: "Session tasks",
-    nodes,
-    edges,
-    rootNodes: rootNodes.length ? rootNodes : nodes[0] ? [nodes[0].id] : [],
-    createdAt: 0,
-    updatedAt: 0
+    ok: true,
+    message: `${result.children.length} child task(s) created.`,
+    board: result.board,
+    task: freshParent,
+    children: result.children
   };
 }
+async function requireBoard(projectRoot, boardId) {
+  return boardId ? getBoard(projectRoot, boardId) : null;
+}
 
-// src/kanban.ts
-var kanbanTool = {
-  name: "kanban",
-  category: "Project",
-  description: "Manage and audit project-scoped multi-kanban boards stored under .wrongstack/kanbans. Managed cards enforce fully specified details and adjacent Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions with persistent comments and evidence. Successful board access records live agent/session presence. Use verify_completion to validate a task against its success criteria and persist the verification report. Use split_atomic to split a task into child tasks with parent.atomic=true in a single atomic board mutation, enforcing subtree verification before the parent can complete.",
-  usageHint: "Use this for durable project kanban state. Reassess with get_board whenever evidence changes; agents may add, update, split, merge, reprioritize, or remove tasks so the board remains a live plan. Presence includes active/last-seen session and agent metadata. For managed boards, fully fill card details, use transition_task after every material step, attach truthful evidence, and never use update_task/move_task to bypass lifecycle guards. Worker completion enters Review; only passed acceptance criteria plus review evidence allow Done. Use verify_completion to generate a verification report (persisted automatically) and split_atomic to atomically create child subtasks with the atomic flag pre-set.",
-  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",
-          "create_from_graph",
-          "import_session_tasks",
-          "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",
-          "transition_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",
-          "verify_completion",
-          "split_atomic",
-          "assess_atomicity",
-          "propose_decomposition"
-        ]
-      },
-      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" },
-      dueDate: { type: "string" },
-      tags: { type: "array", items: { type: "string" } },
-      labels: { type: "array", items: { type: "string" } },
-      priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
-      taskType: {
-        type: "string",
-        enum: ["feature", "bugfix", "refactor", "docs", "test", "chore"]
-      },
-      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" },
-      expectedLeaseId: { type: "string" },
-      assignmentStatus: {
-        type: "string",
-        enum: ["assigned", "queued", "running", "completed", "failed", "cancelled"]
-      },
-      lifecycleStage: {
-        type: "string",
-        enum: ["backlog", "todo", "running", "review", "done"]
-      },
-      transitionAction: { type: "string" },
-      transitionComment: { type: "string" },
-      attachmentUrl: { type: "string" },
-      attachmentTitle: { type: "string" },
-      attachmentType: {
-        type: "string",
-        enum: ["issue", "pr", "doc", "commit", "design", "file", "url", "other"]
-      },
-      releaseStatus: { type: "string", enum: ["pending", "ready", "blocked"] },
-      releaseReason: { type: "string" },
-      clearAssignee: { type: "boolean" },
-      recoveryMode: { type: "string", enum: ["auto", "release", "retry", "fail"] },
-      recoveryNow: { type: "string" },
-      recoveryPolicyFailOnCostCeiling: { type: "boolean" },
-      recoveryPolicyReleaseOnFailureKinds: { type: "array", items: { type: "string" } },
-      recoveryPolicyReleaseOnHeartbeatDue: { type: "boolean" },
-      recoveryPolicyRetryPolicyOverride: {
-        type: "string",
-        enum: ["off", "incremental", "exponential"]
-      },
-      assignee: { type: "string" },
-      costCeilingUsd: { type: "number" },
-      retryPolicy: { type: "string", enum: ["off", "incremental", "exponential"] },
-      lastFailureKind: { type: "string" },
-      dependsOn: { type: "array", items: { type: "string" } },
-      estimatedHours: { type: "number" },
-      actualHours: { type: "number" },
-      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" },
-      atomicityMode: { type: "string", enum: ["off", "assess", "enforce"] },
-      atomicityDecomposition: { type: "string", enum: ["auto", "propose"] },
-      gateEnforcement: { type: "string", enum: ["strict", "soft", "off"] },
-      subtasks: {
-        type: "array",
-        minItems: 2,
-        items: {
-          type: "object",
-          properties: {
-            title: { type: "string" },
-            description: { type: "string" },
-            successCriteria: { type: "array", items: { type: "string" } },
-            dependsOnIndex: { type: "array", items: { type: "number" } }
-          },
-          required: ["title"]
+// src/kanban-detail-actions.ts
+async function handleKanbanDetailAction(projectRoot, input) {
+  switch (input.action) {
+    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.");
       }
-    },
-    required: ["action"]
-  },
-  async execute(input, ctx) {
-    const projectRoot = ctx.projectRoot;
-    if (!projectRoot) return fail("No project root is available.");
-    const withPresence = async (result) => {
-      const boardId = result.board?.id ?? input.boardId;
-      if (!result.ok || !boardId || !ctx.session?.id || !ctx.agentId) return result;
-      try {
-        const board = await touchKanbanPresence2(projectRoot, boardId, {
-          sessionId: ctx.session.id,
-          agentId: ctx.agentId,
-          agentName: ctx.agentName,
-          taskId: input.taskId ?? result.task?.id,
-          runTaskId: input.runTaskId
-        });
-        return board ? { ...result, board } : result;
-      } catch {
-        return result;
+      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.");
       }
-    };
-    try {
-      const result = await (async () => {
-        switch (input.action) {
-          case "list_boards": {
-            const boards = await listBoards2(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 createBoard2(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 } : {},
-              ...input.atomicityMode !== void 0 ? {
-                atomicity: {
-                  mode: input.atomicityMode,
-                  decomposition: input.atomicityDecomposition ?? "propose"
-                }
-              } : {},
-              ...input.gateEnforcement !== void 0 ? { completionGate: { enforcement: input.gateEnforcement } } : {}
-            });
-            return { ok: true, message: `Board created: ${board.title}`, board };
-          }
-          case "update_board": {
-            if (!input.boardId) return fail("update_board requires boardId.");
-            const board = await updateBoard2(projectRoot, input.boardId, {
-              ...input.title !== void 0 ? { title: input.title } : {},
-              ...input.description !== void 0 ? { description: input.description } : {},
-              ...input.tags !== void 0 ? { tags: input.tags } : {},
-              ...input.atomicityMode !== void 0 ? {
-                atomicity: {
-                  mode: input.atomicityMode,
-                  decomposition: input.atomicityDecomposition ?? "propose"
-                }
-              } : {},
-              ...input.gateEnforcement !== void 0 ? { completionGate: { enforcement: input.gateEnforcement } } : {}
-            });
-            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 removeBoard2(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 = createBoardFromText({
-              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 createBoard2(projectRoot, boardInput);
-            for (const taskInput2 of parseLinesIntoTasks(
-              input.description,
-              board.columns[0]?.id ?? "backlog"
-            )) {
-              await addTask(projectRoot, board.id, taskInput2);
-            }
-            return okBoard(await getBoard2(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": {
+      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.");
+    }
+    case "split_atomic": {
+      if (!input.boardId || !input.taskId || !input.childTitles?.length) {
+        return fail("split_atomic requires boardId, taskId, and childTitles (at least one).");
+      }
+      return handleSplitTask(projectRoot, input, { atomic: true });
+    }
+    default:
+      return void 0;
+  }
+}
+
+// src/kanban-board-inputs.ts
+function boardCreateInput(input, title) {
+  return {
+    title,
+    ...input.description !== void 0 ? { description: input.description } : {},
+    ...input.tags !== void 0 ? { tags: input.tags } : {},
+    ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
+    ...input.atomicityMode !== void 0 ? {
+      atomicity: {
+        mode: input.atomicityMode,
+        decomposition: input.atomicityDecomposition ?? "propose"
+      }
+    } : {},
+    ...input.gateEnforcement !== void 0 ? { completionGate: { enforcement: input.gateEnforcement } } : {}
+  };
+}
+function boardUpdatePatch(input) {
+  return {
+    ...input.title !== void 0 ? { title: input.title } : {},
+    ...input.description !== void 0 ? { description: input.description } : {},
+    ...input.tags !== void 0 ? { tags: input.tags } : {},
+    ...input.atomicityMode !== void 0 ? {
+      atomicity: {
+        mode: input.atomicityMode,
+        decomposition: input.atomicityDecomposition ?? "propose"
+      }
+    } : {},
+    ...input.gateEnforcement !== void 0 ? { completionGate: { enforcement: input.gateEnforcement } } : {}
+  };
+}
+function duplicateBoardOptions(input) {
+  return {
+    ...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 } : {}
+  };
+}
+
+// src/kanban-task-inputs.ts
+import { randomUUID } from "node:crypto";
+function taskInput(input) {
+  const assignment = hasAssignmentInput(input) ? assignmentForTaskCreate(input) : void 0;
+  return {
+    title: input.title ?? "",
+    columnId: input.columnId,
+    description: input.description,
+    dueDate: input.dueDate,
+    priority: input.priority,
+    ...input.taskType !== void 0 ? { type: input.taskType } : {},
+    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 } : {},
+    ...mergedDependsOn(input) ? { dependsOn: mergedDependsOn(input) } : {},
+    ...input.estimatedHours !== void 0 ? { estimatedHours: input.estimatedHours } : {},
+    ...input.actualHours !== void 0 ? { actualHours: input.actualHours } : {},
+    ...assignment ? { assignment } : {},
+    ...input.order !== void 0 ? { order: input.order } : {},
+    ...input.retryPolicy !== void 0 ? { retryPolicy: input.retryPolicy } : {},
+    ...input.costCeilingUsd !== void 0 ? { costCeilingUsd: input.costCeilingUsd } : {},
+    ...input.childTitles !== void 0 ? { childTaskIds: input.childTitles } : {},
+    ...input.checkDescription !== void 0 ? {
+      successCriteria: [
+        {
+          id: randomUUID(),
+          description: input.checkDescription,
+          type: "manual",
+          status: input.checkStatus ?? "pending"
+        }
+      ]
+    } : {},
+    ...input.metricName !== void 0 ? {
+      goalMetrics: [
+        {
+          id: randomUUID(),
+          name: input.metricName,
+          status: input.metricStatus ?? "pending",
+          ...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 } : {}
+        }
+      ]
+    } : {},
+    ...input.url !== void 0 ? {
+      links: [
+        {
+          url: input.url,
+          type: input.linkType ?? "url",
+          ...input.linkTitle !== void 0 ? { title: input.linkTitle } : {}
+        }
+      ]
+    } : {},
+    ...input.note !== void 0 ? {
+      notes: [
+        {
+          id: randomUUID(),
+          author: input.author ?? "agent",
+          content: input.note,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      ]
+    } : {},
+    ...input.graphId !== void 0 ? {
+      origin: {
+        system: input.sourceSystem ?? "kanban-tool",
+        ...input.graphId !== void 0 ? { graphId: input.graphId } : {},
+        ...input.specId !== void 0 ? { specId: input.specId } : {},
+        ...input.phaseId !== void 0 ? { phaseId: input.phaseId } : {}
+      }
+    } : {}
+  };
+}
+function mergedDependsOn(input) {
+  const ids = [
+    ...input.dependsOn ?? [],
+    ...input.dependencyTaskId !== void 0 ? [input.dependencyTaskId] : []
+  ].filter((id, i, arr) => id && arr.indexOf(id) === i);
+  return ids.length > 0 ? ids : void 0;
+}
+function taskPatch(input) {
+  return {
+    title: input.title,
+    description: input.description,
+    dueDate: input.dueDate,
+    columnId: input.columnId,
+    order: input.order,
+    priority: input.priority,
+    ...input.taskType !== void 0 ? { type: input.taskType } : {},
+    status: input.status,
+    labels: input.labels,
+    assignedAgent: input.agentId,
+    ...mergedDependsOn(input) ? { dependsOn: mergedDependsOn(input) } : {},
+    ...input.estimatedHours !== void 0 ? { estimatedHours: input.estimatedHours } : {},
+    ...input.actualHours !== void 0 ? { actualHours: input.actualHours } : {}
+  };
+}
+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 } : {}
+  };
+}
+
+// src/kanban-tool-schema.ts
+var KANBAN_TOOL_DESCRIPTION = "Manage and audit project-scoped multi-kanban boards through the shared IPC Kanban server and its SQLite store. Managed cards enforce fully specified details and adjacent Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions with persistent comments and evidence. Successful board access records live agent/session presence. Use verify_completion to validate a task against its success criteria and persist the verification report. Use split_atomic to split a task into child tasks with parent.atomic=true in a single atomic board mutation, enforcing subtree verification before the parent can complete.";
+var KANBAN_TOOL_USAGE_HINT = "Use this for durable project kanban state. Reassess with get_board whenever evidence changes; agents may add, update, split, merge, reprioritize, or remove tasks so the board remains a live plan. Presence includes active/last-seen session and agent metadata. For managed boards, fully fill card details, use transition_task after every material step, attach truthful evidence, and never use update_task/move_task to bypass lifecycle guards. Worker completion enters Review; only passed acceptance criteria plus review evidence allow Done. Use verify_completion to generate a verification report (persisted automatically) and split_atomic to atomically create child subtasks with the atomic flag pre-set.";
+var KANBAN_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      enum: [
+        "list_boards",
+        "get_board",
+        "create_board",
+        "duplicate_board",
+        "update_board",
+        "adopt_managed_lifecycle",
+        "delete_board",
+        "generate_board",
+        "export_markdown",
+        "export_task_graph",
+        "sync_task_graph",
+        "create_from_graph",
+        "import_session_tasks",
+        "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",
+        "transition_task",
+        "repair_managed_projection",
+        "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",
+        "verify_completion",
+        "split_atomic",
+        "assess_atomicity",
+        "propose_decomposition"
+      ]
+    },
+    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" },
+    dueDate: { type: "string" },
+    tags: { type: "array", items: { type: "string" } },
+    labels: { type: "array", items: { type: "string" } },
+    priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
+    taskType: {
+      type: "string",
+      enum: ["feature", "bugfix", "refactor", "docs", "test", "chore"]
+    },
+    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" },
+    expectedLeaseId: { type: "string" },
+    assignmentStatus: {
+      type: "string",
+      enum: ["assigned", "queued", "running", "completed", "failed", "cancelled"]
+    },
+    lifecycleStage: {
+      type: "string",
+      enum: ["backlog", "todo", "running", "review", "done"]
+    },
+    transitionAction: { type: "string" },
+    transitionComment: { type: "string" },
+    attachmentUrl: { type: "string" },
+    attachmentTitle: { type: "string" },
+    attachmentType: {
+      type: "string",
+      enum: ["issue", "pr", "doc", "commit", "design", "file", "url", "other"]
+    },
+    releaseStatus: { type: "string", enum: ["pending", "ready", "blocked"] },
+    releaseReason: { type: "string" },
+    clearAssignee: { type: "boolean" },
+    recoveryMode: { type: "string", enum: ["auto", "release", "retry", "fail"] },
+    recoveryNow: { type: "string" },
+    recoveryPolicyFailOnCostCeiling: { type: "boolean" },
+    recoveryPolicyReleaseOnFailureKinds: { type: "array", items: { type: "string" } },
+    recoveryPolicyReleaseOnHeartbeatDue: { type: "boolean" },
+    recoveryPolicyRetryPolicyOverride: {
+      type: "string",
+      enum: ["off", "incremental", "exponential"]
+    },
+    assignee: { type: "string" },
+    costCeilingUsd: { type: "number" },
+    retryPolicy: { type: "string", enum: ["off", "incremental", "exponential"] },
+    lastFailureKind: { type: "string" },
+    dependsOn: { type: "array", items: { type: "string" } },
+    estimatedHours: { type: "number" },
+    actualHours: { type: "number" },
+    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" },
+    atomicityMode: { type: "string", enum: ["off", "assess", "enforce"] },
+    atomicityDecomposition: { type: "string", enum: ["auto", "propose"] },
+    gateEnforcement: { type: "string", enum: ["strict", "soft", "off"] },
+    subtasks: {
+      type: "array",
+      minItems: 2,
+      items: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+          description: { type: "string" },
+          successCriteria: { type: "array", items: { type: "string" } },
+          dependsOnIndex: { type: "array", items: { type: "number" } }
+        },
+        required: ["title"]
+      }
+    }
+  },
+  required: ["action"]
+};
+
+// src/kanban-presence.ts
+import { touchKanbanPresence } from "@wrongstack/kanban";
+function createKanbanPresenceWrapper(projectRoot, input, ctx) {
+  return async (result) => {
+    const boardId = result.board?.id ?? input.boardId;
+    if (!result.ok || !boardId || !ctx.session?.id || !ctx.agentId) return result;
+    try {
+      const board = await touchKanbanPresence(projectRoot, boardId, {
+        sessionId: ctx.session.id,
+        agentId: ctx.agentId,
+        agentName: ctx.agentName,
+        taskId: input.taskId ?? result.task?.id,
+        runTaskId: input.runTaskId
+      });
+      return board ? { ...result, board } : result;
+    } catch {
+      return result;
+    }
+  };
+}
+
+// src/session-kanban.ts
+import { getSharedProjectMailbox } from "@wrongstack/core/coordination";
+import {
+  loadPlan,
+  loadTasks,
+  mutatePlan,
+  mutateTasks
+} from "@wrongstack/core/storage";
+import { deserializeTaskGraph } from "@wrongstack/core/tasking";
+import { resolveWstackPaths } from "@wrongstack/core/utils";
+import {
+  bridgeKanbanSupervisor,
+  createBoard,
+  getBoard as getBoard2,
+  listBoards,
+  removeBoard,
+  syncBoardFromTaskGraph,
+  touchKanbanPresence as touchKanbanPresence2,
+  updateBoard
+} from "@wrongstack/kanban";
+function taskFileToSerializedGraph(tasks, sessionId) {
+  const ids = new Set(tasks.map((task) => task.id));
+  const nodes = tasks.map((task, index) => ({
+    id: task.id,
+    title: task.title,
+    description: task.description ?? "",
+    type: task.type,
+    priority: task.priority,
+    status: task.status,
+    ...task.assignee ? { assignee: task.assignee } : {},
+    ...task.estimateHours !== void 0 ? { estimateHours: task.estimateHours } : {},
+    createdAt: index,
+    updatedAt: index
+  }));
+  const edges = tasks.flatMap(
+    (task) => (task.dependsOn ?? []).filter((dependency) => ids.has(dependency)).map((dependency) => ({
+      id: `${dependency}->${task.id}`,
+      from: dependency,
+      to: task.id,
+      type: "depends_on"
+    }))
+  );
+  const hasIncoming = new Set(edges.map((edge) => edge.to));
+  const rootNodes = nodes.filter((node) => !hasIncoming.has(node.id)).map((node) => node.id);
+  return {
+    // Keep the historical graph id so existing mirrored task cards are reused.
+    id: `session:${sessionId}`,
+    specId: `session:${sessionId}`,
+    title: "Session tasks",
+    nodes,
+    edges,
+    rootNodes: rootNodes.length ? rootNodes : nodes[0] ? [nodes[0].id] : [],
+    createdAt: 0,
+    updatedAt: 0
+  };
+}
+
+// src/kanban.ts
+var kanbanTool = {
+  name: "kanban",
+  category: "Project",
+  description: KANBAN_TOOL_DESCRIPTION,
+  usageHint: KANBAN_TOOL_USAGE_HINT,
+  permission: "confirm",
+  mutating: true,
+  capabilities: ["fs.write"],
+  icon: "task",
+  timeoutMs: 3e4,
+  inputSchema: KANBAN_INPUT_SCHEMA,
+  async execute(input, ctx) {
+    const projectRoot = ctx.projectRoot;
+    if (!projectRoot) return fail("No project root is available.");
+    const withPresence = createKanbanPresenceWrapper(projectRoot, input, ctx);
+    try {
+      const result = await (async () => {
+        const decompositionResult = await handleKanbanDecompositionAction(projectRoot, input, ctx);
+        if (decompositionResult !== void 0) return decompositionResult;
+        switch (input.action) {
+          case "list_boards": {
+            const boards = await listBoards2(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 createBoard2(projectRoot, boardCreateInput(input, input.title));
+            return { ok: true, message: `Board created: ${board.title}`, board };
+          }
+          case "update_board": {
+            if (!input.boardId) return fail("update_board requires boardId.");
+            const board = await updateBoard2(projectRoot, input.boardId, boardUpdatePatch(input));
+            return board ? okBoard(board, "Board updated.") : fail("Board not found.");
+          }
+          case "adopt_managed_lifecycle": {
+            if (!input.boardId || !input.author || !input.transitionComment) {
+              return fail(
+                "adopt_managed_lifecycle requires boardId, author, transitionComment, and five ordered columns."
+              );
+            }
+            if (input.columns?.length !== 5) {
+              return fail(
+                "adopt_managed_lifecycle columns must be ordered as backlog, todo, running, review, done."
+              );
+            }
+            const [backlog, todo, running, review, done] = input.columns;
+            if (!backlog || !todo || !running || !review || !done) {
+              return fail("adopt_managed_lifecycle columns must contain five nonblank ids.");
+            }
+            const board = await adoptManagedLifecycle(projectRoot, input.boardId, {
+              columns: { backlog, todo, running, review, done },
+              actor: input.author,
+              comment: input.transitionComment
+            });
+            return board ? okBoard(board, "Managed lifecycle adopted without moving existing cards.") : fail("Board not found.");
+          }
+          case "duplicate_board": {
+            if (!input.boardId) return fail("duplicate_board requires boardId.");
+            const board = await duplicateBoard(projectRoot, input.boardId, duplicateBoardOptions(input));
+            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 removeBoard2(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 = createBoardFromText({
+              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 createBoard2(projectRoot, boardInput);
+            for (const taskInput2 of parseLinesIntoTasks(
+              input.description,
+              board.columns[0]?.id ?? "backlog"
+            )) {
+              await addTask(projectRoot, board.id, taskInput2);
+            }
+            return okBoard(await getBoard3(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.");
             }
@@ -695,7 +1158,7 @@ var kanbanTool = {
           case "update_task": {
             if (!input.boardId || !input.taskId)
               return fail("update_task requires boardId and taskId.");
-            const board = await updateTask(
+            const board = await updateTask2(
               projectRoot,
               input.boardId,
               input.taskId,
@@ -710,13 +1173,13 @@ var kanbanTool = {
               );
             }
             if (input.lifecycleStage === "done") {
-              const boardBefore = await getBoard2(projectRoot, input.boardId);
+              const boardBefore = await getBoard3(projectRoot, input.boardId);
               const taskBefore = boardBefore ? await getTask(projectRoot, input.boardId, input.taskId) : null;
               if (boardBefore && taskBefore && !taskBefore.verificationReport && (taskBefore.atomic || Boolean(taskBefore.successCriteria?.length))) {
-                const preGate = await verifyTaskCompletion(projectRoot, input.boardId, taskBefore.id, {
+                const preGate = await verifyTaskCompletion2(projectRoot, input.boardId, taskBefore.id, {
                   persist: false
                 });
-                await updateTask(projectRoot, input.boardId, taskBefore.id, {
+                await updateTask2(projectRoot, input.boardId, taskBefore.id, {
                   verificationReport: preGate.report,
                   successCriteria: preGate.task.successCriteria
                 });
@@ -741,6 +1204,18 @@ var kanbanTool = {
             }
             return result2 ? okTask(result2.board, result2.task, `Task advanced to ${result2.transition.to}.`) : fail("Board or task not found.");
           }
+          case "repair_managed_projection": {
+            if (!input.boardId || !input.taskId || !input.author || !input.transitionComment) {
+              return fail(
+                "repair_managed_projection requires boardId, taskId, author, and transitionComment."
+              );
+            }
+            const result2 = await repairManagedTaskProjection(projectRoot, input.boardId, input.taskId, {
+              actor: input.author,
+              comment: input.transitionComment
+            });
+            return result2 ? okTask(result2.board, result2.task, "Managed card projection repaired from lifecycle history.") : fail("Board or task not found.");
+          }
           case "move_task": {
             if (!input.boardId || !input.taskId || !input.targetColumnId) {
               return fail("move_task requires boardId, taskId, and targetColumnId.");
@@ -853,7 +1328,7 @@ var kanbanTool = {
               input.expectedLeaseId !== void 0 ? { expectedLeaseId: input.expectedLeaseId } : {}
             );
             if (!board) return fail("Task not found.");
-            if (assignmentStatus === "completed") {
+            if (assignmentStatus === "completed" && board.lifecycle?.mode !== "managed") {
               const envGate = readEnvGateEnforcement();
               const finalized = await finalizeTaskCompletion(projectRoot, board.id, input.taskId, {
                 ...board.completionGate === void 0 && envGate !== void 0 ? { enforcement: envGate } : {},
@@ -875,6 +1350,117 @@ var kanbanTool = {
                   gate: gateSummary
                 };
               }
+            } else if (board.lifecycle?.mode === "managed") {
+              const managedTask = board.tasks.find(
+                (candidate) => candidate.id === input.taskId
+              );
+              const stage = managedTask?.lifecycle?.currentStage;
+              const actor = ctx.agentId ?? "kanban-agent";
+              let transitionResult = null;
+              const lifecycleWarnings = [];
+              if (assignmentStatus === "running" && stage === "todo") {
+                try {
+                  transitionResult = await transitionTask(
+                    projectRoot,
+                    board.id,
+                    input.taskId,
+                    { to: "running", actor, comment: "Work started." }
+                  );
+                } catch (err) {
+                  lifecycleWarnings.push(
+                    `Lifecycle transition to Running deferred: ${err instanceof Error ? err.message : String(err)}`
+                  );
+                }
+              }
+              if (assignmentStatus === "completed" && stage === "running") {
+                const comment = typeof input.lastResult === "string" && input.lastResult.trim().length > 0 ? input.lastResult.trim().slice(0, 1e3) : "Work completed.";
+                try {
+                  transitionResult = await transitionTask(
+                    projectRoot,
+                    board.id,
+                    input.taskId,
+                    {
+                      to: "review",
+                      actor,
+                      comment,
+                      attachment: {
+                        url: `kanban://task/${input.taskId}/result`,
+                        title: "Worker completion result",
+                        type: "file"
+                      },
+                      patch: {
+                        // Only patch non-description fields so the
+                        // original card description is preserved.
+                        ...input.agentId !== void 0 ? { assignedAgent: input.agentId } : {}
+                      }
+                    }
+                  );
+                } catch (err) {
+                  lifecycleWarnings.push(
+                    `Lifecycle transition to Review failed: ${err instanceof Error ? err.message : String(err)}`
+                  );
+                }
+                if (transitionResult) {
+                  const hasCriteria = (transitionResult.task.successCriteria?.length ?? 0) > 0 || transitionResult.task.atomic === true;
+                  if (hasCriteria) {
+                    try {
+                      const verResult = await verifyTaskCompletion2(
+                        projectRoot,
+                        board.id,
+                        input.taskId
+                      );
+                      if (verResult.report) {
+                        recordKanbanVerificationEvidence(ctx, verResult.report);
+                      }
+                      const verdict = verResult.report.verdict;
+                      if (verdict === "passed") {
+                        try {
+                          const doneResult = await transitionTask(
+                            projectRoot,
+                            board.id,
+                            input.taskId,
+                            {
+                              to: "done",
+                              actor,
+                              comment: "Auto-accepted: verification passed.",
+                              attachment: {
+                                url: `kanban://task/${input.taskId}/verification`,
+                                title: "Auto-verification result",
+                                type: "file"
+                              }
+                            }
+                          );
+                          transitionResult = doneResult;
+                        } catch (acceptErr) {
+                          lifecycleWarnings.push(
+                            `Auto-accept to Done deferred: ${acceptErr instanceof Error ? acceptErr.message : String(acceptErr)}`
+                          );
+                        }
+                      } else {
+                        lifecycleWarnings.push(
+                          `Verification verdict: ${verdict} \u2014 card left in Review for manual acceptance.`
+                        );
+                      }
+                    } catch (verifyErr) {
+                      lifecycleWarnings.push(
+                        `Auto-verification error: ${verifyErr instanceof Error ? verifyErr.message : String(verifyErr)}`
+                      );
+                    }
+                  } else {
+                    lifecycleWarnings.push(
+                      "No automatic success criteria \u2014 card left in Review for manual verification."
+                    );
+                  }
+                }
+              }
+              const responseBoard = transitionResult?.board ?? board;
+              const responseTask = transitionResult?.task ?? managedTask;
+              const msgParts = ["Assignment updated."];
+              if (transitionResult) {
+                msgParts.push(`Card advanced to ${transitionResult.transition.to}.`);
+              }
+              for (const w of lifecycleWarnings) msgParts.push(`Warning: ${w}`);
+              return okTask(responseBoard, responseTask, msgParts.join(" "));
             }
             return okBoard(board, "Assignment updated.");
           }
@@ -915,209 +1501,44 @@ var kanbanTool = {
                   } : {},
                   ...input.recoveryPolicyReleaseOnHeartbeatDue !== void 0 ? {
                     releaseOnHeartbeatDue: input.recoveryPolicyReleaseOnHeartbeatDue
-                  } : {},
-                  ...input.recoveryPolicyRetryPolicyOverride !== void 0 ? {
-                    retryPolicyOverride: input.recoveryPolicyRetryPolicyOverride
-                  } : {}
-                }
-              } : {}
-            });
-            return result2 ? {
-              ok: true,
-              message: `Recovered ${result2.tasks.length} stale assignment(s).`,
-              board: result2.board,
-              recoveredTasks: result2.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.");
-          }
-          case "assess_atomicity": {
-            if (!input.boardId || !input.taskId) {
-              return fail("assess_atomicity requires boardId and taskId.");
-            }
-            const result2 = await assessTaskAtomicity(projectRoot, input.boardId, input.taskId, {
-              assessedBy: "agent",
-              ...ctx.agentId !== void 0 ? { eventContext: { actor: ctx.agentId } } : {}
+                  } : {},
+                  ...input.recoveryPolicyRetryPolicyOverride !== void 0 ? {
+                    retryPolicyOverride: input.recoveryPolicyRetryPolicyOverride
+                  } : {}
+                }
+              } : {}
             });
-            if (!result2) return fail("Task not found.");
-            const failing = result2.assessment.criteria.filter((entry) => entry.score < 1).map((entry) => entry.reason);
-            const guidance = result2.assessment.verdict === "needs_decomposition" ? ` This task should be split before dispatch \u2014 call propose_decomposition with 2+ subtasks (each with one verifiable success criterion). Reasons: ${failing.join(" | ")}` : result2.assessment.verdict === "composite" ? " Container task: work happens in its children; it is verified via subtask aggregation." : "";
-            return okTask(
-              result2.board,
-              result2.task,
-              `Atomicity verdict: ${result2.assessment.verdict} (score ${result2.assessment.score}).${guidance}`
-            );
+            return result2 ? {
+              ok: true,
+              message: `Recovered ${result2.tasks.length} stale assignment(s).`,
+              board: result2.board,
+              recoveredTasks: result2.tasks
+            } : { ok: true, message: "No stale assignment matched.", recoveredTasks: [] };
           }
-          case "propose_decomposition": {
-            if (!input.boardId || !input.taskId || !input.subtasks?.length) {
-              return fail("propose_decomposition requires boardId, taskId, and subtasks (2+).");
-            }
-            if (input.subtasks.length < 2) {
-              return fail("propose_decomposition requires at least two subtasks.");
-            }
-            const invalid = input.subtasks.find(
-              (subtask) => typeof subtask?.title !== "string" || !subtask.title.trim()
-            );
-            if (invalid) return fail("Every proposed subtask needs a non-blank title.");
-            const result2 = await proposeTaskDecomposition(
-              projectRoot,
-              input.boardId,
-              input.taskId,
-              {
-                subtasks: input.subtasks,
-                ...input.note !== void 0 ? { rationale: input.note } : {},
-                ...ctx.agentId !== void 0 ? { proposedBy: ctx.agentId } : {}
-              },
-              ctx.agentId !== void 0 ? { actor: ctx.agentId } : {}
-            );
-            if (!result2) return fail("Task not found.");
-            const message = result2.proposal.status === "applied" ? `Decomposition applied: ${result2.proposal.appliedChildTaskIds?.length ?? 0} child tasks created (parent marked atomic).` : 'Decomposition proposal recorded \u2014 awaiting approval (board policy is "propose"). It can be approved from the WebUI or via update_task.';
-            return okTask(result2.board, result2.task, message);
+          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 "verify_completion": {
-            if (!input.boardId || !input.taskId) {
-              return fail("verify_completion requires boardId and taskId.");
-            }
-            const verResult = await verifyTaskCompletion(projectRoot, input.boardId, input.taskId);
-            const persistedBoard = await updateTask(projectRoot, input.boardId, input.taskId, {
-              verificationReport: verResult.report,
-              successCriteria: verResult.task.successCriteria
+          case "queue_health": {
+            const health = await getKanbanQueueHealth(projectRoot, {
+              ...input.boardId !== void 0 ? { boardId: input.boardId } : {}
             });
-            if (!persistedBoard) {
-              return {
-                ok: false,
-                verdict: verResult.report.verdict,
-                message: `Verification succeeded but persist failed: ${verResult.report.markdownSummary}. Board may be stale \u2014 re-run verify_completion.`,
-                board: verResult.board
-              };
-            }
-            recordKanbanVerificationEvidence(ctx, verResult.report);
-            const freshTask = persistedBoard.tasks?.find((t) => t.id === input.taskId);
-            const deterministicVerdicts = ["passed", "failed", "needs_human", "incomplete"];
             return {
-              ok: deterministicVerdicts.includes(verResult.report.verdict),
-              verdict: verResult.report.verdict,
-              message: verResult.report.markdownSummary,
-              board: persistedBoard,
-              task: freshTask ?? verResult.task
+              ok: true,
+              message: `Counts: ready=${health.counts.ready}, running=${health.counts.running}, stale=${health.staleAssignments.count}.`,
+              queueHealth: health
             };
           }
-          case "split_atomic": {
-            if (!input.boardId || !input.taskId || !input.childTitles?.length) {
-              return fail("split_atomic requires boardId, taskId, and childTitles (at least one).");
-            }
-            return handleSplitTask(projectRoot, input, { atomic: true });
-          }
           default:
+            {
+              const detailResult = await handleKanbanDetailAction(projectRoot, input);
+              if (detailResult !== void 0) return detailResult;
+            }
             return fail(`Unknown kanban action: ${input.action}`);
         }
       })();
@@ -1127,222 +1548,6 @@ var kanbanTool = {
     }
   }
 };
-function atomicityNudge(task) {
-  if (task.atomicityAssessment?.verdict !== "needs_decomposition") return "";
-  const reasons = task.atomicityAssessment.criteria.filter((entry) => entry.score < 1).map((entry) => entry.reason).join(" | ");
-  return ` Atomicity: needs_decomposition (score ${task.atomicityAssessment.score}) \u2014 call propose_decomposition with 2+ subtasks before dispatch. Reasons: ${reasons}`;
-}
-function readEnvGateEnforcement() {
-  const raw = process.env["WRONGSTACK_KANBAN_GATE"]?.trim().toLowerCase();
-  return raw === "strict" || raw === "soft" || raw === "off" ? raw : void 0;
-}
-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 handleSplitTask(projectRoot, input, extraSplitOptions) {
-  const boardId = input.boardId;
-  const taskId = input.taskId;
-  const childTitles = input.childTitles;
-  if (!boardId || !taskId || !childTitles?.length) {
-    return fail("split requires boardId, taskId, and at least one childTitles.");
-  }
-  const {
-    targetColumnId,
-    inheritAssignment,
-    inheritLabels,
-    inheritSuccessCriteria,
-    inheritGoalMetrics,
-    inheritDependencies,
-    chainChildren,
-    rewireDependents
-  } = input;
-  const result = await splitTask(projectRoot, boardId, taskId, {
-    titles: childTitles,
-    ...extraSplitOptions,
-    ...targetColumnId !== void 0 ? { columnId: targetColumnId } : {},
-    ...inheritAssignment !== void 0 ? { inheritAssignment } : {},
-    ...inheritLabels !== void 0 ? { inheritLabels } : {},
-    ...inheritSuccessCriteria !== void 0 ? { inheritSuccessCriteria } : {},
-    ...inheritGoalMetrics !== void 0 ? { inheritGoalMetrics } : {},
-    ...inheritDependencies !== void 0 ? { inheritDependencies } : {},
-    ...chainChildren !== void 0 ? { chainChildren } : {},
-    ...rewireDependents !== void 0 ? { rewireDependents } : {}
-  });
-  if (!result) return fail("Task not found.");
-  const freshParent = result.board.tasks?.find((t) => t.id === taskId);
-  if (!freshParent) {
-    return fail(
-      `Split succeeded but parent ${taskId} not found in returned board. Children: [${result.children.map((c) => c.id).join(", ")}].`
-    );
-  }
-  return {
-    ok: true,
-    message: `${result.children.length} child task(s) created.`,
-    board: result.board,
-    task: freshParent,
-    children: result.children
-  };
-}
-async function requireBoard(projectRoot, boardId) {
-  return boardId ? getBoard2(projectRoot, boardId) : null;
-}
-function taskInput(input) {
-  const assignment = hasAssignmentInput(input) ? assignmentForTaskCreate(input) : void 0;
-  return {
-    title: input.title ?? "",
-    columnId: input.columnId,
-    description: input.description,
-    dueDate: input.dueDate,
-    priority: input.priority,
-    ...input.taskType !== void 0 ? { type: input.taskType } : {},
-    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 } : {},
-    ...mergedDependsOn(input) ? { dependsOn: mergedDependsOn(input) } : {},
-    ...input.estimatedHours !== void 0 ? { estimatedHours: input.estimatedHours } : {},
-    ...input.actualHours !== void 0 ? { actualHours: input.actualHours } : {},
-    ...assignment ? { assignment } : {},
-    ...input.order !== void 0 ? { order: input.order } : {},
-    // Sprint 3 durable task-level fields
-    ...input.retryPolicy !== void 0 ? { retryPolicy: input.retryPolicy } : {},
-    ...input.costCeilingUsd !== void 0 ? { costCeilingUsd: input.costCeilingUsd } : {},
-    // Relationships — chainId alone cannot construct a KanbanTaskChainRef,
-    // so chain/previousTaskId/nextTaskId must be set via update_task.
-    ...input.childTitles !== void 0 ? { childTaskIds: input.childTitles } : {},
-    // Detail objects
-    ...input.checkDescription !== void 0 ? {
-      successCriteria: [
-        {
-          id: randomUUID(),
-          description: input.checkDescription,
-          type: "manual",
-          status: input.checkStatus ?? "pending"
-        }
-      ]
-    } : {},
-    ...input.metricName !== void 0 ? {
-      goalMetrics: [
-        {
-          id: randomUUID(),
-          name: input.metricName,
-          status: input.metricStatus ?? "pending",
-          ...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 } : {}
-        }
-      ]
-    } : {},
-    ...input.url !== void 0 ? {
-      links: [
-        {
-          url: input.url,
-          type: input.linkType ?? "url",
-          ...input.linkTitle !== void 0 ? { title: input.linkTitle } : {}
-        }
-      ]
-    } : {},
-    ...input.note !== void 0 ? {
-      notes: [
-        {
-          id: randomUUID(),
-          author: input.author ?? "agent",
-          content: input.note,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString()
-        }
-      ]
-    } : {},
-    // Origin tracking
-    ...input.graphId !== void 0 ? {
-      origin: {
-        system: input.sourceSystem ?? "kanban-tool",
-        ...input.graphId !== void 0 ? { graphId: input.graphId } : {},
-        ...input.specId !== void 0 ? { specId: input.specId } : {},
-        ...input.phaseId !== void 0 ? { phaseId: input.phaseId } : {}
-      }
-    } : {}
-  };
-}
-function mergedDependsOn(input) {
-  const ids = [
-    ...input.dependsOn ?? [],
-    ...input.dependencyTaskId !== void 0 ? [input.dependencyTaskId] : []
-  ].filter((id, i, arr) => id && arr.indexOf(id) === i);
-  return ids.length > 0 ? ids : void 0;
-}
-function taskPatch(input) {
-  return {
-    title: input.title,
-    description: input.description,
-    dueDate: input.dueDate,
-    columnId: input.columnId,
-    order: input.order,
-    priority: input.priority,
-    ...input.taskType !== void 0 ? { type: input.taskType } : {},
-    status: input.status,
-    labels: input.labels,
-    assignedAgent: input.agentId,
-    ...mergedDependsOn(input) ? { dependsOn: mergedDependsOn(input) } : {},
-    ...input.estimatedHours !== void 0 ? { estimatedHours: input.estimatedHours } : {},
-    ...input.actualHours !== void 0 ? { actualHours: input.actualHours } : {}
-  };
-}
-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
 };