@wrongstack/tools 0.302.0 → 0.303.0

package/dist/todo.js

@@ -1,5 +1,989 @@
 // src/todo.ts
-import { loadPlan as loadPlan2, loadTasks as loadTasks2, savePlan, saveTasks, setPlanItemStatus } from "@wrongstack/core/storage";
+import {
+  loadPlan as loadPlan2,
+  loadTasks as loadTasks3,
+  savePlan,
+  saveTasks,
+  setPlanItemStatus
+} from "@wrongstack/core/storage";
+import { getBoard as getBoard4 } from "@wrongstack/kanban";
+
+// src/kanban.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { loadTasks as loadTasks2 } from "@wrongstack/core/storage";
+import { deserializeTaskGraph as deserializeTaskGraph2, serializeTaskGraph } from "@wrongstack/core/tasking";
+import {
+  addColumn,
+  addTask,
+  adoptManagedLifecycle,
+  assignTask,
+  claimReadyTask,
+  copyTaskToBoard,
+  createBoard as createBoard2,
+  createBoardFromTaskGraph,
+  createBoardFromText,
+  duplicateBoard,
+  evaluateContractGraphReadiness,
+  exportBoardAsMarkdown,
+  exportBoardToTaskGraph,
+  finalizeTaskCompletion,
+  getBoard as getBoard3,
+  getKanbanOrchestrationSnapshot,
+  getKanbanQueueHealth,
+  getTask,
+  getTaskChain,
+  heartbeatTaskAssignment,
+  listBoards as listBoards2,
+  listKanbanEvents,
+  listReadyTasks,
+  mergeTasks,
+  moveTask,
+  parseLinesIntoTasks,
+  recoverStaleTaskAssignments,
+  releaseTaskClaim,
+  removeBoard as removeBoard2,
+  removeColumn,
+  removeTask,
+  repairManagedTaskProjection,
+  searchKanban,
+  setTaskChain,
+  syncBoardFromTaskGraph as syncBoardFromTaskGraph2,
+  transferTaskToBoard,
+  transitionTask,
+  updateBoard as updateBoard2,
+  updateColumn,
+  updateTask as updateTask2,
+  updateTaskAssignment,
+  verifyTaskCompletion as verifyTaskCompletion2
+} from "@wrongstack/kanban";
+
+// src/kanban-board-inputs.ts
+function agentSettableGate(enforcement) {
+  if (enforcement === void 0 || enforcement === "off") return {};
+  return { completionGate: { enforcement } };
+}
+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"
+      }
+    } : {},
+    ...agentSettableGate(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"
+      }
+    } : {},
+    ...agentSettableGate(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-decomposition-actions.ts
+import {
+  assessTaskAtomicity,
+  proposeTaskDecomposition,
+  updateTask,
+  verifyTaskCompletion
+} from "@wrongstack/kanban";
+
+// src/kanban-evidence-bridge.ts
+import { recordCompletedWorkEvidence } from "@wrongstack/core/utils";
+function kanbanEvidenceKey(boardId, taskId) {
+  return `kanban:${boardId}:${taskId}`;
+}
+function kanbanEvidencePointer(boardId, taskId) {
+  return `kanban://${boardId}/${taskId}#verificationReport`;
+}
+function recordKanbanVerificationEvidence(ctx, report) {
+  try {
+    const passed = report.checks.filter((check) => check.status === "passed").length;
+    const completedAt = Date.parse(report.completedAt);
+    recordCompletedWorkEvidence(ctx, {
+      key: kanbanEvidenceKey(report.boardId, report.taskId),
+      source: "verification",
+      summary: `${report.taskTitle} \u2014 verification ${report.verdict} (${passed}/${report.checks.length} checks)`,
+      ...Number.isFinite(completedAt) ? { completedAt } : {},
+      evidence: kanbanEvidencePointer(report.boardId, report.taskId)
+    });
+  } catch {
+  }
+}
+
+// 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 {
+  addCheckToTask,
+  addContractEdge,
+  addDependency,
+  addGoalMetricToTask,
+  addLinkToTask,
+  addNoteToTask,
+  configureContractGraph,
+  evaluateTaskContractGraph,
+  getContractGraph,
+  getKanbanWorkbench,
+  removeContractEdge,
+  removeContractNode,
+  updateCheckOnTask,
+  updateGoalMetricOnTask,
+  upsertContractNode
+} from "@wrongstack/kanban";
+
+// 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 {
+    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-detail-actions.ts
+async function handleKanbanDetailAction(projectRoot, input) {
+  switch (input.action) {
+    case "workbench": {
+      const workbench = await getKanbanWorkbench(projectRoot, {
+        ...input.limit !== void 0 ? { limitPerLane: input.limit, alertLimit: input.limit } : {}
+      });
+      return {
+        ok: true,
+        message: `${workbench.totals.now} now, ${workbench.totals.next} next, ${workbench.totals.blocked} blocked, ${workbench.totals.review} review; ${workbench.alertTotal} alert(s).`,
+        workbench
+      };
+    }
+    case "get_contract_graph": {
+      if (!input.boardId) return fail("get_contract_graph requires boardId.");
+      const result = await getContractGraph(projectRoot, input.boardId);
+      return result ? {
+        ok: true,
+        message: result.graph ? `${result.graph.nodes.length} contract node(s), ${result.graph.edges.length} edge(s).` : "Contract graph is not configured.",
+        board: result.board,
+        ...result.graph ? { contractGraph: result.graph } : {}
+      } : fail("Board not found.");
+    }
+    case "configure_contract_graph": {
+      if (!input.boardId || !input.contractGraphEnforcement) {
+        return fail("configure_contract_graph requires boardId and contractGraphEnforcement.");
+      }
+      const current = await getContractGraph(projectRoot, input.boardId);
+      if (!current) return fail("Board not found.");
+      if (input.contractGraphEnforcement === "strict" && current.graph?.enforcement !== "strict") {
+        return fail(
+          "Strict Contract Map enforcement is operator-owned. Autonomous agents may use advisory maps but may not turn them into an execution gate."
+        );
+      }
+      if (current.graph?.enforcement === "strict" && input.contractGraphEnforcement !== "strict") {
+        return fail("An autonomous agent may not loosen a strict contract graph.");
+      }
+      const board = await configureContractGraph(
+        projectRoot,
+        input.boardId,
+        input.contractGraphEnforcement
+      );
+      return board ? okBoard(board, "Contract graph configured.") : fail("Board not found.");
+    }
+    case "upsert_contract_node": {
+      if (!input.boardId || !input.taskId || !input.contractNodeKind || !input.title) {
+        return fail("upsert_contract_node requires boardId, taskId, contractNodeKind, and title.");
+      }
+      if (input.contractNodeState === "waived") {
+        return fail(
+          "The autonomous kanban tool may not waive contract nodes; a human-owned review surface must record that exception."
+        );
+      }
+      if (input.contractNodeId) {
+        const current = await getContractGraph(projectRoot, input.boardId);
+        const existing = current?.graph?.nodes.find((node) => node.id === input.contractNodeId);
+        if (current?.graph?.enforcement === "strict" && existing && (existing.kind !== input.contractNodeKind || input.contractEnforcement !== void 0 && input.contractEnforcement !== existing.enforcement)) {
+          return fail(
+            "The autonomous kanban tool may not change the kind or enforcement of an existing strict contract node."
+          );
+        }
+      }
+      const result = await upsertContractNode(projectRoot, input.boardId, {
+        ...input.contractNodeId ? { id: input.contractNodeId } : {},
+        taskId: input.taskId,
+        kind: input.contractNodeKind,
+        title: input.title,
+        ...input.description !== void 0 ? { description: input.description } : {},
+        ...input.contractEnforcement !== void 0 ? { enforcement: input.contractEnforcement } : {},
+        ...input.contractNodeState !== void 0 ? { state: input.contractNodeState } : {},
+        ...input.checkId !== void 0 ? { checkId: input.checkId } : {},
+        ...input.metricId !== void 0 ? { metricId: input.metricId } : {},
+        ...input.baseline !== void 0 ? { baseline: input.baseline } : {},
+        ...input.threshold !== void 0 ? { threshold: input.threshold } : {},
+        ...input.author !== void 0 ? { createdBy: input.author } : {}
+      });
+      return result ? {
+        ...okBoard(result.board, "Contract node saved."),
+        contractGraph: result.board.contractGraph
+      } : fail("Task not found.");
+    }
+    case "link_contract_nodes": {
+      if (!input.boardId || !input.fromNodeId || !input.toNodeId || !input.contractEdgeType) {
+        return fail(
+          "link_contract_nodes requires boardId, fromNodeId, toNodeId, and contractEdgeType."
+        );
+      }
+      const result = await addContractEdge(projectRoot, input.boardId, {
+        from: input.fromNodeId,
+        to: input.toNodeId,
+        type: input.contractEdgeType,
+        ...input.contractEdgeId ? { id: input.contractEdgeId } : {},
+        ...input.contractEnforcement ? { enforcement: input.contractEnforcement } : {},
+        ...input.contractRationale ? { rationale: input.contractRationale } : {},
+        ...input.author ? { createdBy: input.author } : {}
+      });
+      return result ? {
+        ...okBoard(result.board, "Contract edge added."),
+        contractGraph: result.board.contractGraph
+      } : fail("Board not found.");
+    }
+    case "remove_contract_node": {
+      if (!input.boardId || !input.contractNodeId) {
+        return fail("remove_contract_node requires boardId and contractNodeId.");
+      }
+      const current = await getContractGraph(projectRoot, input.boardId);
+      const node = current?.graph?.nodes.find((candidate) => candidate.id === input.contractNodeId);
+      if (current?.graph?.enforcement === "strict" && node?.enforcement === "blocking") {
+        return fail("The autonomous kanban tool may not remove a blocking strict contract node.");
+      }
+      const board = await removeContractNode(projectRoot, input.boardId, input.contractNodeId);
+      return board ? okBoard(board, "Contract node removed.") : fail("Contract node not found.");
+    }
+    case "remove_contract_edge": {
+      if (!input.boardId || !input.contractEdgeId) {
+        return fail("remove_contract_edge requires boardId and contractEdgeId.");
+      }
+      const current = await getContractGraph(projectRoot, input.boardId);
+      const edge = current?.graph?.edges.find((candidate) => candidate.id === input.contractEdgeId);
+      if (current?.graph?.enforcement === "strict" && edge?.enforcement === "blocking") {
+        return fail("The autonomous kanban tool may not remove a blocking strict contract edge.");
+      }
+      const board = await removeContractEdge(projectRoot, input.boardId, input.contractEdgeId);
+      return board ? okBoard(board, "Contract edge removed.") : fail("Contract edge not found.");
+    }
+    case "evaluate_contract_graph": {
+      if (!input.boardId || !input.taskId) {
+        return fail("evaluate_contract_graph requires boardId and taskId.");
+      }
+      const result = await evaluateTaskContractGraph(projectRoot, input.boardId, input.taskId);
+      return result ? {
+        ok: result.evaluation.allowed,
+        message: result.evaluation.allowed ? "Contract graph is closed." : `Contract graph has ${result.evaluation.issues.length} unresolved issue(s).`,
+        board: result.board,
+        contractGraph: result.board.contractGraph,
+        contractEvaluation: result.evaluation
+      } : fail("Task not found.");
+    }
+    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 "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-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/kanban-task-inputs.ts
+import { randomUUID } from "node:crypto";
+import { clampSubagentCapabilities } from "@wrongstack/core/security";
+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, input.specId, input.specRequirementId].some((value) => value !== void 0) ? {
+      origin: {
+        system: input.sourceSystem ?? "kanban-tool",
+        ...input.graphId !== void 0 ? { graphId: input.graphId } : {},
+        ...input.specId !== void 0 ? { specId: input.specId } : {},
+        ...input.specRequirementId !== void 0 ? { specRequirementId: input.specRequirementId } : {},
+        ...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 clampRequestedCapabilities(requested) {
+  if (requested === void 0) return void 0;
+  return clampSubagentCapabilities(requested).granted;
+}
+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: clampRequestedCapabilities(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: clampRequestedCapabilities(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. Contract Map actions are optional advisory metadata unless an operator explicitly enabled strict enforcement. Use verify_completion to validate executable success criteria before Done.";
+var KANBAN_TOOL_USAGE_HINT = "Use this for durable project kanban state. Read workbench when orienting across boards; it returns bounded Now, Next, Blocked, Review lanes and operational alerts. Before coding mutation, create a fully detailed card on a managed board with executable acceptance criteria, then call start_task. The runtime blocks product mutations until start_task binds a ready Running card. Do not create, inspect, repair, or enable a Contract Map during ordinary work; every map mode stays off the execution and completion path. Worker completion enters Review; Done requires passed acceptance criteria and review evidence. Surface existing strict-map findings for operator review without stopping work to repair them.";
+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",
+        "workbench",
+        "add_column",
+        "update_column",
+        "delete_column",
+        "add_task",
+        "split_task",
+        "merge_tasks",
+        "copy_task",
+        "transfer_task",
+        "get_task",
+        "start_task",
+        "update_task",
+        "transition_task",
+        "repair_managed_projection",
+        "move_task",
+        "delete_task",
+        "set_chain",
+        "get_chain",
+        "get_contract_graph",
+        "configure_contract_graph",
+        "upsert_contract_node",
+        "link_contract_nodes",
+        "remove_contract_node",
+        "remove_contract_edge",
+        "evaluate_contract_graph",
+        "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" },
+    contractNodeId: { type: "string" },
+    contractNodeKind: {
+      type: "string",
+      enum: ["objective", "guardrail", "risk", "component", "artifact", "verification"]
+    },
+    contractNodeState: {
+      type: "string",
+      enum: ["unknown", "active", "satisfied", "violated", "resolved"]
+    },
+    contractEnforcement: {
+      type: "string",
+      enum: ["blocking", "advisory", "informational"]
+    },
+    contractGraphEnforcement: { type: "string", enum: ["off", "advisory", "strict"] },
+    contractEdgeId: { type: "string" },
+    contractEdgeType: {
+      type: "string",
+      enum: [
+        "targets",
+        "affects",
+        "must_preserve",
+        "exposes",
+        "verified_by",
+        "conflicts_with",
+        "derived_from",
+        "relates_to"
+      ]
+    },
+    fromNodeId: { type: "string" },
+    toNodeId: { type: "string" },
+    contractRationale: { type: "string" },
+    baseline: { oneOf: [{ type: "string" }, { type: "number" }] },
+    threshold: { oneOf: [{ type: "string" }, { type: "number" }] },
+    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" },
+    specRequirementId: { 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",
+      // WS-023: `'off'` is deliberately absent. The agent whose work this gate
+      // checks must not be able to switch it off; it may only tighten. Turning
+      // a gate off stays a human decision, made through board config.
+      enum: ["strict", "soft"]
+    },
+    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/session-kanban.ts
 import { getSharedProjectMailbox } from "@wrongstack/core/coordination";
@@ -14,11 +998,11 @@ import { resolveWstackPaths } from "@wrongstack/core/utils";
 import {
   bridgeKanbanSupervisor,
   createBoard,
-  getBoard,
+  getBoard as getBoard2,
   listBoards,
   removeBoard,
   syncBoardFromTaskGraph,
-  touchKanbanPresence,
+  touchKanbanPresence as touchKanbanPresence2,
   updateBoard
 } from "@wrongstack/kanban";
 var SESSION_BOARD_TAG = "session-work";
@@ -33,6 +1017,7 @@ var boardQueue = /* @__PURE__ */ new Map();
 var boardEnsures = /* @__PURE__ */ new Map();
 var pendingMirrors = /* @__PURE__ */ new Map();
 var activeMirrors = /* @__PURE__ */ new Set();
+var suppressedTodoMirrors = /* @__PURE__ */ new WeakSet();
 function boardKey(projectRoot, sessionId) {
   return `${projectRoot}\0${sessionId}`;
 }
@@ -61,7 +1046,7 @@ async function ensureSessionKanbanBoard(projectRoot, sessionId) {
     const summary = (await listBoards(projectRoot)).find(
       (board2) => board2.tags?.includes(sessionTag(sessionId))
     );
-    let board = summary ? await getBoard(projectRoot, summary.id) : null;
+    let board = summary ? await getBoard2(projectRoot, summary.id) : null;
     if (!board) {
       return createBoard(projectRoot, {
         title: sessionBoardTitle(sessionId),
@@ -142,7 +1127,17 @@ function queueLatestMirror(projectRoot, sessionId, graph, sourceSystem) {
             pending.graph,
             pending.sourceSystem
           );
-        } catch {
+        } catch (error) {
+          console.warn(
+            JSON.stringify({
+              level: "warn",
+              event: "session-kanban.mirror-failed",
+              sessionId: pending.sessionId,
+              sourceSystem: pending.sourceSystem,
+              message: error instanceof Error ? error.message : String(error),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
         }
       }
     } finally {
@@ -161,6 +1156,7 @@ function queueLatestMirror(projectRoot, sessionId, graph, sourceSystem) {
   })();
 }
 function todoListToSerializedGraph(todos, sessionId) {
+  const graphId = `todo:${sessionId}`;
   const nodes = todos.map((todo, index) => ({
     id: todo.id,
     title: todo.content,
@@ -168,12 +1164,14 @@ function todoListToSerializedGraph(todos, sessionId) {
     type: "chore",
     priority: "medium",
     status: todo.status,
+    specRequirementId: `${graphId}:${todo.id}`,
     createdAt: index,
     updatedAt: index
   }));
   return {
-    id: `todo:${sessionId}`,
-    specId: `todo:${sessionId}`,
+    id: graphId,
+    specId: graphId,
+    requiredRequirementIds: nodes.map((node) => node.specRequirementId),
     title: "Session todos",
     nodes,
     edges: [],
@@ -182,6 +1180,87 @@ function todoListToSerializedGraph(todos, sessionId) {
     updatedAt: 0
   };
 }
+function taskFileToSerializedGraph(tasks, sessionId) {
+  const graphId = `session:${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,
+    specRequirementId: `${graphId}:${task.id}`,
+    ...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: graphId,
+    specId: graphId,
+    requiredRequirementIds: nodes.map((node) => node.specRequirementId),
+    title: "Session tasks",
+    nodes,
+    edges,
+    rootNodes: rootNodes.length ? rootNodes : nodes[0] ? [nodes[0].id] : [],
+    createdAt: 0,
+    updatedAt: 0
+  };
+}
+function broadcastTodoUpdate(context, todos) {
+  const sessionId = context.session?.id ?? "";
+  if (!context.agentId || !sessionId) return;
+  const statusCounts = { pending: 0, inProgress: 0, completed: 0 };
+  for (const todo of todos) {
+    if (todo.status === "completed") statusCounts.completed++;
+    else if (todo.status === "in_progress") statusCounts.inProgress++;
+    else statusCounts.pending++;
+  }
+  const projectDir = resolveWstackPaths({ projectRoot: context.projectRoot }).projectDir;
+  const mailbox = getSharedProjectMailbox(projectDir);
+  void mailbox.send({
+    from: context.agentId,
+    to: "*",
+    type: "status",
+    subject: `Kanban todo list updated (${todos.length} item${todos.length === 1 ? "" : "s"})`,
+    body: JSON.stringify({
+      kind: "kanban.todos.updated",
+      sessionId,
+      revision: context.state.revision,
+      todoCount: todos.length,
+      statusCounts
+    }),
+    priority: "normal",
+    senderSessionId: sessionId
+  }).catch(() => {
+  });
+}
+function notifyTodoUpdate(context, todos) {
+  const summary = todos.length ? todos.map((todo) => `- [${todo.status}] ${todo.content} (${todo.id})`).join("\n") : "- No active todos remain.";
+  const text = `[KANBAN TODO UPDATE]
+Another Kanban agent reassessed the shared board. The canonical todo list is now:
+${summary}
+Reassess your current plan before continuing; do not rely on the initial todo snapshot.`;
+  const state = context.state;
+  if (typeof state.appendBlockToLastUserMessage === "function") {
+    if (state.appendBlockToLastUserMessage({ type: "text", text })) return;
+  }
+  if (typeof state.appendMessage === "function") {
+    state.appendMessage({ role: "user", content: [{ type: "text", text }] });
+  }
+}
 function mirrorSessionTodosToKanban(projectRoot, todos, sessionId) {
   queueLatestMirror(
     projectRoot,
@@ -190,18 +1269,1011 @@ function mirrorSessionTodosToKanban(projectRoot, todos, sessionId) {
     "session-todo"
   );
 }
+function sourceStatus(task) {
+  if (task.status === "completed") return "completed";
+  if (task.status === "in_progress") return "in_progress";
+  if (task.status === "review") return "review";
+  if (task.status === "blocked") return "blocked";
+  if (task.status === "failed") return "failed";
+  return "pending";
+}
+function todoStatus(task) {
+  const status = sourceStatus(task);
+  if (status === "completed") return "completed";
+  if (status === "in_progress" || status === "review") return "in_progress";
+  return "pending";
+}
+function sessionTodoFromTask(task, boardId) {
+  return {
+    id: task.origin?.taskId ?? task.id,
+    content: task.title,
+    status: todoStatus(task),
+    kanbanBoardId: boardId,
+    kanbanTaskId: task.id,
+    ...task.description ? { activeForm: task.description } : {}
+  };
+}
+function managedTodoFromTask(task, boardId) {
+  return {
+    ...sessionTodoFromTask(task, boardId),
+    status: task.status === "completed" ? "completed" : task.status === "in_progress" ? "in_progress" : "pending"
+  };
+}
+function sameTodos(left, right) {
+  return left.length === right.length && left.every((todo, index) => {
+    const candidate = right[index];
+    return candidate?.id === todo.id && candidate.content === todo.content && candidate.status === todo.status && candidate.activeForm === todo.activeForm && candidate.promotedFromPlan === todo.promotedFromPlan && candidate.promotedFromTask === todo.promotedFromTask && candidate.kanbanBoardId === todo.kanbanBoardId && candidate.kanbanTaskId === todo.kanbanTaskId;
+  });
+}
+function applyManagedKanbanBoardToTodos(context, board) {
+  const metaKanban = context.meta["kanban"];
+  const metaBoardId = metaKanban && typeof metaKanban === "object" ? metaKanban["boardId"] : void 0;
+  const activeBoardId2 = context.currentKanbanBoardId ?? (typeof metaBoardId === "string" ? metaBoardId : void 0);
+  if (!activeBoardId2 || board.id !== activeBoardId2 || board.lifecycle?.mode !== "managed") {
+    return [...context.todos];
+  }
+  const projectedTodos = board.tasks.filter(
+    (task) => task.status !== "archived" && task.mergedIntoTaskId === void 0 && (!task.childTaskIds || task.childTaskIds.length === 0)
+  ).sort(
+    (left, right) => left.createdAt.localeCompare(right.createdAt) || left.order - right.order
+  ).map((task) => managedTodoFromTask(task, board.id));
+  if (sameTodos(context.todos, projectedTodos)) return [...context.todos];
+  suppressedTodoMirrors.add(context);
+  try {
+    context.state.replaceTodos(projectedTodos);
+  } finally {
+    suppressedTodoMirrors.delete(context);
+  }
+  notifyTodoUpdate(context, context.todos);
+  broadcastTodoUpdate(context, context.todos);
+  return [...context.todos];
+}
+
+// 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.");
+            }
+            const graph = deserializeTaskGraph2(input.taskGraph);
+            const result2 = await syncBoardFromTaskGraph2(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 result2 ? {
+              ok: true,
+              message: `Task graph synced: ${result2.createdTaskIds.length} created, ${result2.updatedTaskIds.length} updated, ${result2.archivedTaskIds.length} archived.`,
+              board: result2.board
+            } : fail("Board not found.");
+          }
+          case "create_from_graph": {
+            if (!input.taskGraph) return fail("create_from_graph requires taskGraph.");
+            const graph = deserializeTaskGraph2(input.taskGraph);
+            const { board } = await createBoardFromTaskGraph(projectRoot, 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 } : {}
+            });
+            return {
+              ok: true,
+              message: `Created board "${board.title}" from task graph with ${board.tasks.length} tasks.`,
+              board
+            };
+          }
+          case "import_session_tasks": {
+            const taskPath = ctx.meta?.["task.path"];
+            if (!taskPath) return fail("No session task file for this session.");
+            const file = await loadTasks2(taskPath);
+            if (!file || file.tasks.length === 0) return fail("No session tasks to import.");
+            const sessionId = ctx.session?.id ?? file.sessionId ?? "session";
+            const graph = deserializeTaskGraph2(taskFileToSerializedGraph(file.tasks, sessionId));
+            const tags = ["session", `session:${sessionId}`];
+            const existing = (await listBoards2(projectRoot)).find(
+              (b) => b.tags?.includes(`session:${sessionId}`)
+            );
+            if (existing) {
+              const result2 = await syncBoardFromTaskGraph2(projectRoot, existing.id, graph, {
+                sourceSystem: "session",
+                tags,
+                archiveMissingTasks: true,
+                includeCompletedTasks: true
+              });
+              return result2 ? {
+                ok: true,
+                message: `Synced ${file.tasks.length} session tasks into board "${result2.board.title}".`,
+                board: result2.board
+              } : fail("Session board vanished mid-sync.");
+            }
+            const { board } = await createBoardFromTaskGraph(projectRoot, graph, {
+              title: `Session tasks (${sessionId.slice(0, 8)})`,
+              sourceSystem: "session",
+              tags
+            });
+            return {
+              ok: true,
+              message: `Imported ${file.tasks.length} session tasks into new board "${board.title}".`,
+              board
+            };
+          }
+          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 result2 = await addColumn(projectRoot, input.boardId, {
+              title: input.title,
+              ...input.description !== void 0 ? { description: input.description } : {}
+            });
+            return result2 ? okBoard(result2.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 result2 = await addTask(projectRoot, input.boardId, taskInput(input));
+            if (!result2) return fail("Board not found.");
+            return okTask(result2.board, result2.task, `Task added.${atomicityNudge(result2.task)}`);
+          }
+          case "split_task": {
+            if (!input.boardId || !input.taskId || !input.childTitles?.length) {
+              return fail("split_task requires boardId, taskId, and childTitles.");
+            }
+            return handleSplitTask(projectRoot, input, {});
+          }
+          case "merge_tasks": {
+            if (!input.boardId || !input.taskIds?.length || !input.title) {
+              return fail("merge_tasks requires boardId, taskIds, and title.");
+            }
+            const result2 = 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 result2 ? okTask(result2.board, result2.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 result2 = 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 result2 ? okTask(result2.targetBoard, result2.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 result2 = 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 result2 ? okTask(result2.targetBoard, result2.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 "start_task": {
+            if (!input.boardId || !input.taskId || !input.author || !input.transitionComment) {
+              return fail("start_task requires boardId, taskId, author, and transitionComment.");
+            }
+            let board = await getBoard3(projectRoot, input.boardId);
+            let task = board?.tasks.find((candidate) => candidate.id === input.taskId);
+            if (!board || !task) return fail("Board or task not found.");
+            const readiness = evaluateContractGraphReadiness(board, task.id);
+            if (!readiness.ready) {
+              return fail(
+                `Task is not implementation-ready: ${readiness.issues.map((issue) => issue.message).join(" | ")}`
+              );
+            }
+            let stage = task.lifecycle?.currentStage;
+            if (stage === "backlog") {
+              const moved = await transitionTask(projectRoot, board.id, task.id, {
+                to: "todo",
+                actor: input.author,
+                comment: input.transitionComment
+              });
+              if (!moved) return fail("Task could not enter Todo.");
+              board = moved.board;
+              task = moved.task;
+              stage = task.lifecycle?.currentStage;
+            }
+            if (stage === "todo" || stage === "review") {
+              const now = /* @__PURE__ */ new Date();
+              const leaseId = input.leaseId ?? randomUUID2();
+              const assigned = await updateTaskAssignment(projectRoot, board.id, task.id, {
+                status: "running",
+                agentId: input.agentId ?? input.author,
+                leaseId,
+                claimedAt: input.claimedAt ?? now.toISOString(),
+                heartbeatAt: input.heartbeatAt ?? now.toISOString(),
+                leaseExpiresAt: input.leaseExpiresAt ?? new Date(now.getTime() + 15 * 6e4).toISOString(),
+                attempt: input.attempt ?? 1,
+                maxAttempts: input.maxAttempts ?? 3
+              });
+              if (!assigned) return fail("Task assignment could not be started.");
+              const moved = await transitionTask(projectRoot, board.id, task.id, {
+                to: "running",
+                actor: input.author,
+                comment: input.transitionComment
+              });
+              if (!moved) return fail("Task could not enter Running.");
+              board = moved.board;
+              task = moved.task;
+              stage = task.lifecycle?.currentStage;
+            }
+            if (stage !== "running" || task.assignment?.status !== "running") {
+              return fail(
+                `start_task only accepts Backlog, Todo, Review repair, or live Running cards (current: ${stage ?? "unknown"}).`
+              );
+            }
+            ctx.setCurrentKanbanTask(task.id, board.id);
+            return okTask(
+              board,
+              task,
+              "Task is active; runtime Kanban governance is now bound to this run."
+            );
+          }
+          case "update_task": {
+            if (!input.boardId || !input.taskId)
+              return fail("update_task requires boardId and taskId.");
+            const board = await updateTask2(
+              projectRoot,
+              input.boardId,
+              input.taskId,
+              taskPatch(input)
+            );
+            return board ? okBoard(board, "Task updated.") : fail("Task not found.");
+          }
+          case "transition_task": {
+            if (!input.boardId || !input.taskId || !input.lifecycleStage || !input.author || !input.transitionComment) {
+              return fail(
+                "transition_task requires boardId, taskId, lifecycleStage, author, and transitionComment."
+              );
+            }
+            if (input.lifecycleStage === "done") {
+              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 verifyTaskCompletion2(
+                  projectRoot,
+                  input.boardId,
+                  taskBefore.id,
+                  {
+                    persist: false
+                  }
+                );
+                await updateTask2(projectRoot, input.boardId, taskBefore.id, {
+                  verificationReport: preGate.report,
+                  successCriteria: preGate.task.successCriteria
+                });
+              }
+            }
+            const result2 = await transitionTask(projectRoot, input.boardId, input.taskId, {
+              to: input.lifecycleStage,
+              actor: input.author,
+              comment: input.transitionComment,
+              ...input.transitionAction !== void 0 ? { action: input.transitionAction } : {},
+              ...input.attachmentUrl !== void 0 ? {
+                attachment: {
+                  url: input.attachmentUrl,
+                  type: input.attachmentType ?? "url",
+                  ...input.attachmentTitle !== void 0 ? { title: input.attachmentTitle } : {}
+                }
+              } : {},
+              patch: taskPatch(input)
+            });
+            if (result2 && input.lifecycleStage === "done" && result2.task.verificationReport) {
+              recordKanbanVerificationEvidence(ctx, result2.task.verificationReport);
+            }
+            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.");
+            }
+            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 result2 = await setTaskChain(projectRoot, input.boardId, {
+              taskIds: input.taskIds,
+              ...input.chainId !== void 0 ? { chainId: input.chainId } : {},
+              ...input.enforceDependencies !== void 0 ? { enforceDependencies: input.enforceDependencies } : {}
+            });
+            return result2 ? {
+              ok: true,
+              message: `Chain set: ${result2.chainId}`,
+              board: result2.board,
+              chain: result2.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 result2 = await getTaskChain(
+              projectRoot,
+              input.boardId,
+              input.taskId ?? input.chainId ?? ""
+            );
+            return result2 ? {
+              ok: true,
+              message: `Chain loaded: ${result2.chainId}`,
+              board: result2.board,
+              chain: result2.tasks
+            } : fail("Chain not found.");
+          }
+          case "claim_task": {
+            const result2 = await claimReadyTask(projectRoot, {
+              ...input.boardId !== void 0 ? { boardId: input.boardId } : {},
+              ...input.taskId !== void 0 ? { taskId: input.taskId } : {},
+              ...assignmentInput(input),
+              status: input.assignmentStatus ?? "queued"
+            });
+            return result2 ? okTask(result2.board, result2.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 } : {}
+              },
+              // Ownership fence: when expectedLeaseId is supplied, the write is
+              // applied only if the current assignment still holds this lease.
+              // This prevents a recovered+reassigned stale worker's terminal
+              // mark_assignment from overwriting the successor's state. The check
+              // is atomic inside updateTaskAssignment's mutateBoard lock.
+              input.expectedLeaseId !== void 0 ? { expectedLeaseId: input.expectedLeaseId } : {}
+            );
+            if (!board) return fail("Task not found.");
+            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 } : {},
+                ...ctx.agentId !== void 0 ? { eventContext: { actor: ctx.agentId } } : {}
+              });
+              if (finalized) {
+                if (finalized.gate.report) {
+                  recordKanbanVerificationEvidence(ctx, finalized.gate.report);
+                }
+                const gateSummary = {
+                  enforcement: finalized.gate.enforcement,
+                  allowed: finalized.gate.allowed,
+                  verdict: finalized.gate.verdict,
+                  issues: finalized.gate.issues.map((issue) => issue.message)
+                };
+                const gateMessage = finalized.gate.allowed ? `Completion gate ${finalized.gate.verdict === "skipped" ? "skipped" : "passed"}; task completed.` : finalized.gate.enforcement === "strict" ? `Completion gate BLOCKED (verdict: ${finalized.gate.verdict}); task parked in review. Issues: ${gateSummary.issues.join(" | ")}` : `Completion gate failed softly (verdict: ${finalized.gate.verdict}); task completed with warnings. Issues: ${gateSummary.issues.join(" | ")}`;
+                return {
+                  ...okTask(finalized.board, finalized.task, `Assignment updated. ${gateMessage}`),
+                  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);
+                      }
+                      await updateTask2(projectRoot, board.id, input.taskId, {
+                        verificationReport: verResult.report,
+                        successCriteria: verResult.task.successCriteria
+                      });
+                      const verdict = verResult.report.verdict;
+                      if (verdict === "passed") {
+                        try {
+                          const doneResult = await transitionTask(
+                            projectRoot,
+                            board.id,
+                            input.taskId,
+                            {
+                              to: "done",
+                              actor,
+                              action: "Automated acceptance after verification",
+                              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.");
+          }
+          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 } : {},
+              // Ownership fence: when expectedLeaseId is supplied, the renewal
+              // is applied only if the current assignment still holds this lease.
+              // This prevents a recovered+reassigned stale worker's heartbeat
+              // from renewing the successor's lease. The check is atomic inside
+              // heartbeatTaskAssignment's mutateBoard lock.
+              ...input.expectedLeaseId !== void 0 ? { expectedLeaseId: input.expectedLeaseId } : {}
+            });
+            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 result2 = 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 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
+            };
+          }
+          default:
+            {
+              const detailResult = await handleKanbanDetailAction(projectRoot, input);
+              if (detailResult !== void 0) return detailResult;
+            }
+            return fail(`Unknown kanban action: ${input.action}`);
+        }
+      })();
+      return withPresence(result);
+    } catch (err) {
+      return fail(err instanceof Error ? err.message : String(err));
+    }
+  }
+};
 
 // src/todo.ts
+function normalizedTitle(value) {
+  return value.trim().toLocaleLowerCase().replace(/\s+/g, " ");
+}
+function activeBoardId(items, ctx) {
+  const metaKanban = ctx.meta?.["kanban"];
+  const metaBoardId = metaKanban && typeof metaKanban === "object" ? metaKanban["boardId"] : void 0;
+  return ctx.currentKanbanBoardId ?? (typeof metaBoardId === "string" ? metaBoardId : void 0) ?? items.find((item) => item.kanbanBoardId)?.kanbanBoardId ?? "";
+}
+function bindTodosToBoard(items, previous, board) {
+  const previousById = new Map(previous.map((item) => [item.id, item]));
+  const available = board.tasks.filter(
+    (task) => task.status !== "archived" && task.mergedIntoTaskId === void 0 && (!task.childTaskIds || task.childTaskIds.length === 0)
+  ).sort(
+    (left, right) => left.createdAt.localeCompare(right.createdAt) || left.order - right.order
+  );
+  const used = /* @__PURE__ */ new Set();
+  return items.map((item) => {
+    const previousItem = previousById.get(item.id);
+    const requestedTaskId = item.kanbanBoardId === board.id ? item.kanbanTaskId : previousItem?.kanbanBoardId === board.id ? previousItem.kanbanTaskId : void 0;
+    const title = normalizedTitle(item.content);
+    const candidates = [
+      requestedTaskId ? board.tasks.find((task2) => task2.id === requestedTaskId) : void 0,
+      board.tasks.find((task2) => task2.id === item.id),
+      board.tasks.find((task2) => task2.origin?.taskId === item.id),
+      available.find((task2) => !used.has(task2.id) && normalizedTitle(task2.title) === title)
+    ];
+    const task = candidates.find((candidate) => candidate && !used.has(candidate.id));
+    if (!task) return { ...item };
+    used.add(task.id);
+    return { ...item, kanbanBoardId: board.id, kanbanTaskId: task.id };
+  });
+}
+async function synchronizeManagedKanban(items, board, ctx, signal) {
+  let synced = 0;
+  const warnings = [];
+  const actor = ctx.agentId?.trim() || ctx.agentName?.trim() || "kanban-agent";
+  const execute = async (input) => {
+    const result = await kanbanTool.execute(input, ctx, { signal });
+    if (!result.ok) warnings.push(result.message);
+    else {
+      synced++;
+      if (result.message.includes("Warning:")) warnings.push(result.message);
+    }
+    return result;
+  };
+  for (const item of items) {
+    if (item.status !== "pending" || item.kanbanBoardId !== board.id || !item.kanbanTaskId) {
+      continue;
+    }
+    const task = board.tasks.find((candidate) => candidate.id === item.kanbanTaskId);
+    if (task?.lifecycle?.currentStage !== "running") continue;
+    const released = await execute({
+      action: "mark_assignment",
+      boardId: board.id,
+      taskId: task.id,
+      assignmentStatus: "assigned",
+      agentId: actor,
+      lastResult: `Todo returned to queue: ${item.content}`
+    });
+    if (!released.ok) continue;
+    await execute({
+      action: "transition_task",
+      boardId: board.id,
+      taskId: task.id,
+      lifecycleStage: "todo",
+      author: actor,
+      transitionComment: `Todo returned to queue: ${item.content}`
+    });
+  }
+  for (const item of items) {
+    if (item.status !== "completed" || item.kanbanBoardId !== board.id || !item.kanbanTaskId) {
+      continue;
+    }
+    const task = board.tasks.find((candidate) => candidate.id === item.kanbanTaskId);
+    if (!task || task.status === "completed") continue;
+    await execute({
+      action: "mark_assignment",
+      boardId: board.id,
+      taskId: task.id,
+      assignmentStatus: "completed",
+      agentId: actor,
+      lastResult: `Todo completed: ${item.content}`
+    });
+  }
+  const attemptedParents = /* @__PURE__ */ new Set();
+  let afterCompletions = await getBoard4(ctx.projectRoot, board.id);
+  while (afterCompletions) {
+    const parent = afterCompletions.tasks.find(
+      (task) => task.atomic === true && task.status !== "completed" && Boolean(task.childTaskIds?.length) && !attemptedParents.has(task.id) && task.childTaskIds?.every(
+        (childId) => afterCompletions?.tasks.find((candidate) => candidate.id === childId)?.status === "completed"
+      )
+    );
+    if (!parent) break;
+    attemptedParents.add(parent.id);
+    const started = await execute({
+      action: "start_task",
+      boardId: board.id,
+      taskId: parent.id,
+      author: actor,
+      agentId: actor,
+      transitionComment: "All child tasks completed; validating composite parent."
+    });
+    if (started.ok) {
+      await execute({
+        action: "mark_assignment",
+        boardId: board.id,
+        taskId: parent.id,
+        assignmentStatus: "completed",
+        agentId: actor,
+        lastResult: "All child tasks completed; composite result ready for verification."
+      });
+    }
+    afterCompletions = await getBoard4(ctx.projectRoot, board.id);
+  }
+  const completionPending = items.some(
+    (item) => item.status === "completed" && item.kanbanBoardId === board.id && Boolean(item.kanbanTaskId) && afterCompletions?.tasks.find((task) => task.id === item.kanbanTaskId)?.status !== "completed"
+  );
+  const active = items.find(
+    (item) => item.status === "in_progress" && item.kanbanBoardId === board.id && Boolean(item.kanbanTaskId)
+  );
+  if (active?.kanbanTaskId) {
+    await execute({
+      action: "start_task",
+      boardId: board.id,
+      taskId: active.kanbanTaskId,
+      author: actor,
+      agentId: actor,
+      transitionComment: `Todo activated: ${active.content}`
+    });
+  }
+  if (active?.kanbanTaskId && completionPending) {
+    warnings.push(
+      "A completed todo is still awaiting acceptance; the next independent Kanban task was started."
+    );
+  } else if (!active && ctx.currentKanbanBoardId === board.id) {
+    ctx.setCurrentKanbanTask(void 0, board.id);
+  }
+  return { synced, warnings };
+}
 var todoTool = {
   name: "todo",
   category: "Session",
-  description: "Manage the session-level todo list. This is the primary mechanism for tracking multi-step work. The list is fully replaced on every call (not appended).",
-  usageHint: "BEST PRACTICE for complex tasks:\n- At the beginning of a non-trivial task, create a clear todo list with specific, actionable items.\n- Only **one** item should be `in_progress` at any time.\n- Update the list frequently as work progresses (mark items done, add new ones, change status).\n- **Re-order items** to reflect current priorities \u2014 the full list is replaced each call, so item order is entirely under your control.\n- When all items are completed the board auto-clears \u2014 you do NOT need to send an empty list.\n- The system and user can see this list, so keep it honest and up-to-date.\nThis tool is extremely valuable for maintaining focus and giving the user visibility into your plan.",
-  permission: "auto",
-  mutating: false,
-  // mutates only conversation state (ctx.todos), not external state — no confirmation needed
-  timeoutMs: 5e3,
-  capabilities: ["session.todo"],
+  description: "Manage the compact active-work list. With a managed Kanban binding, every row resolves to a real card and status changes advance that card; without Kanban it remains session-only state. Each call replaces ordering and supplied fields, but unfinished omitted rows are retained until completed.",
+  usageHint: "BEST PRACTICE for complex tasks:\n- At the beginning of a non-trivial task, create a clear todo list with specific, actionable items.\n- Only **one** item should be `in_progress` at any time.\n- Update the list frequently as work progresses (mark items done, add new ones, change status).\n- **Re-order items** to reflect current priorities. Omission is not cancellation: unfinished rows are retained until completed.\n- When all items are completed the board auto-clears \u2014 you do NOT need to send an empty list.\n- The system and user can see this list, so keep it honest and up-to-date.\nThis tool is extremely valuable for maintaining focus and giving the user visibility into your plan.",
+  permission: "confirm",
+  mutating: true,
+  timeoutMs: 3e4,
+  capabilities: ["session.todo", "fs.write"],
+  subjectKey: "todos",
   icon: "todo",
   inputSchema: {
     type: "object",
@@ -227,20 +2299,38 @@ var todoTool = {
             activeForm: {
               type: "string",
               description: 'Optional present-tense form shown while the task is active (e.g. "Fixing auth bug").'
+            },
+            kanbanBoardId: {
+              type: "string",
+              description: "Kanban board that owns this UI row when Kanban is active."
+            },
+            kanbanTaskId: {
+              type: "string",
+              description: "Real Kanban task represented by this UI row."
             }
           },
           required: ["id", "content", "status"]
         },
-        description: "The complete new list of todos. This replaces the previous list entirely."
+        description: "The desired todo list. Supplied rows are replaced/reordered; unfinished omitted rows are retained."
       }
     },
     required: ["todos"]
   },
-  async execute(input, ctx) {
+  async execute(input, ctx, call) {
     if (!Array.isArray(input?.todos)) {
       throw new Error("todo: todos must be an array");
     }
     const items = input.todos.filter((t) => Boolean(t?.id && t.content));
+    const todoIdentity = (item) => item.kanbanBoardId && item.kanbanTaskId ? `kanban:${item.kanbanBoardId}:${item.kanbanTaskId}` : item.promotedFromTask ? `task:${item.promotedFromTask}` : item.promotedFromPlan ? `plan:${item.promotedFromPlan}` : `todo:${item.id}`;
+    const requestedIdentities = new Set(items.map(todoIdentity));
+    for (const previous of ctx.todos ?? []) {
+      const identity = todoIdentity(previous);
+      if (previous.status === "completed" || requestedIdentities.has(identity)) {
+        continue;
+      }
+      items.push({ ...previous });
+      requestedIdentities.add(identity);
+    }
     const inProgress = items.filter((t) => t.status === "in_progress");
     if (inProgress.length > 1) {
       let seenInProgress = false;
@@ -251,8 +2341,32 @@ var todoTool = {
         }
       }
     }
-    ctx.state.replaceTodos(items);
-    mirrorSessionTodosToKanban(ctx.projectRoot, items, ctx.session?.id ?? "session");
+    const boardId = activeBoardId(items, ctx);
+    const board = boardId ? await getBoard4(ctx.projectRoot, boardId) : null;
+    const boundItems = board?.lifecycle?.mode === "managed" ? bindTodosToBoard(items, ctx.todos ?? [], board) : items;
+    ctx.state.replaceTodos(boundItems);
+    const kanbanSync = board?.lifecycle?.mode === "managed" ? await synchronizeManagedKanban(boundItems, board, ctx, call.signal) : { synced: 0, warnings: [] };
+    if (board?.lifecycle?.mode === "managed") {
+      const unresolved = boundItems.filter(
+        (item) => item.kanbanBoardId !== board.id || !item.kanbanTaskId
+      );
+      if (unresolved.length > 0) {
+        kanbanSync.warnings.push(
+          `${unresolved.length} Todo row(s) did not match a real Kanban task and were not applied. Preserve kanbanBoardId/kanbanTaskId when updating the projection.`
+        );
+      }
+    }
+    let projectedBoard = board;
+    if (board?.lifecycle?.mode === "managed") {
+      const refreshed = await getBoard4(ctx.projectRoot, board.id);
+      if (refreshed) {
+        projectedBoard = refreshed;
+        applyManagedKanbanBoardToTodos(ctx, refreshed);
+      }
+    }
+    if (board?.lifecycle?.mode !== "managed") {
+      mirrorSessionTodosToKanban(ctx.projectRoot, items, ctx.session?.id ?? "session");
+    }
     const completedPlanIds = /* @__PURE__ */ new Set();
     const completedTaskIds = /* @__PURE__ */ new Set();
     const pendingPlanIds = /* @__PURE__ */ new Set();
@@ -287,7 +2401,7 @@ var todoTool = {
       const taskPath = ctx.meta["task.path"];
       if (typeof taskPath !== "string" || !taskPath) continue;
       try {
-        const file = await loadTasks2(taskPath);
+        const file = await loadTasks3(taskPath);
         if (file) {
           const task = file.tasks.find((t) => t.id === taskId);
           if (task && task.status !== "completed") {
@@ -301,7 +2415,25 @@ var todoTool = {
     }
     return {
       count: items.length,
-      in_progress: items.filter((t) => t.status === "in_progress").length
+      in_progress: (ctx.todos ?? boundItems).filter((t) => t.status === "in_progress").length,
+      ...kanbanSync.synced > 0 ? { kanban_synced: kanbanSync.synced } : {},
+      ...kanbanSync.warnings.length > 0 ? { kanban_warnings: kanbanSync.warnings } : {},
+      ...projectedBoard?.lifecycle?.mode === "managed" ? {
+        kanban_bindings: boundItems.flatMap((item) => {
+          if (item.kanbanBoardId !== projectedBoard.id || !item.kanbanTaskId) return [];
+          const task = projectedBoard.tasks.find(
+            (candidate) => candidate.id === item.kanbanTaskId
+          );
+          return task ? [
+            {
+              todoId: item.id,
+              boardId: projectedBoard.id,
+              taskId: task.id,
+              taskStatus: task.status
+            }
+          ] : [];
+        })
+      } : {}
     };
   }
 };