@wrongstack/tools 0.302.0 → 0.303.0

package/dist/kanban.js

@@ -1,6 +1,7 @@
 // src/kanban.ts
-import { deserializeTaskGraph as deserializeTaskGraph2, serializeTaskGraph } from "@wrongstack/core/tasking";
+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,
@@ -10,10 +11,12 @@ import {
   copyTaskToBoard,
   createBoard as createBoard2,
   createBoardFromTaskGraph,
+  createBoardFromText,
   duplicateBoard,
+  evaluateContractGraphReadiness,
   exportBoardAsMarkdown,
   exportBoardToTaskGraph,
-  createBoardFromText,
+  finalizeTaskCompletion,
   getBoard as getBoard3,
   getKanbanOrchestrationSnapshot,
   getKanbanQueueHealth,
@@ -27,22 +30,73 @@ import {
   moveTask,
   parseLinesIntoTasks,
   recoverStaleTaskAssignments,
-  repairManagedTaskProjection,
   releaseTaskClaim,
   removeBoard as removeBoard2,
   removeColumn,
   removeTask,
+  repairManagedTaskProjection,
   searchKanban,
   setTaskChain,
   syncBoardFromTaskGraph as syncBoardFromTaskGraph2,
-  transitionTask,
   transferTaskToBoard,
+  transitionTask,
   updateBoard as updateBoard2,
   updateColumn,
   updateTask as updateTask2,
   updateTaskAssignment,
-  verifyTaskCompletion as verifyTaskCompletion2,
-  finalizeTaskCompletion
+  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
@@ -68,14 +122,6 @@ function recordKanbanVerificationEvidence(ctx, report) {
   }
 }
 
-// src/kanban-decomposition-actions.ts
-import {
-  assessTaskAtomicity,
-  proposeTaskDecomposition,
-  updateTask,
-  verifyTaskCompletion
-} from "@wrongstack/kanban";
-
 // src/kanban-tool-results.ts
 function atomicityNudge(task) {
   if (task.atomicityAssessment?.verdict !== "needs_decomposition") return "";
@@ -180,12 +226,20 @@ async function handleKanbanDecompositionAction(projectRoot, input, ctx) {
 // src/kanban-detail-actions.ts
 import {
   addCheckToTask,
+  addContractEdge,
   addDependency,
   addGoalMetricToTask,
   addLinkToTask,
   addNoteToTask,
+  configureContractGraph,
+  evaluateTaskContractGraph,
+  getContractGraph,
+  getKanbanWorkbench,
+  removeContractEdge,
+  removeContractNode,
   updateCheckOnTask,
-  updateGoalMetricOnTask
+  updateGoalMetricOnTask,
+  upsertContractNode
 } from "@wrongstack/kanban";
 
 // src/kanban-split-task-handler.ts
@@ -241,6 +295,141 @@ async function requireBoard(projectRoot, boardId) {
 // 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.");
@@ -344,47 +533,24 @@ async function handleKanbanDetailAction(projectRoot, input) {
   }
 }
 
-// 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-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;
+    }
   };
 }
 
@@ -454,11 +620,12 @@ function taskInput(input) {
         }
       ]
     } : {},
-    ...input.graphId !== void 0 ? {
+    ...[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 } : {}
       }
     } : {}
@@ -543,8 +710,8 @@ function assignmentForTaskCreate(input) {
 }
 
 // src/kanban-tool-schema.ts
-var KANBAN_TOOL_DESCRIPTION = "Manage and audit project-scoped multi-kanban boards through the shared IPC Kanban server and its SQLite store. Managed cards enforce fully specified details and adjacent Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions with persistent comments and evidence. Successful board access records live agent/session presence. Use verify_completion to validate a task against its success criteria and persist the verification report. Use split_atomic to split a task into child tasks with parent.atomic=true in a single atomic board mutation, enforcing subtree verification before the parent can complete.";
-var KANBAN_TOOL_USAGE_HINT = "Use this for durable project kanban state. Reassess with get_board whenever evidence changes; agents may add, update, split, merge, reprioritize, or remove tasks so the board remains a live plan. Presence includes active/last-seen session and agent metadata. For managed boards, fully fill card details, use transition_task after every material step, attach truthful evidence, and never use update_task/move_task to bypass lifecycle guards. Worker completion enters Review; only passed acceptance criteria plus review evidence allow Done. Use verify_completion to generate a verification report (persisted automatically) and split_atomic to atomically create child subtasks with the atomic flag pre-set.";
+var KANBAN_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: {
@@ -567,6 +734,7 @@ var KANBAN_INPUT_SCHEMA = {
         "search_tasks",
         "ready_tasks",
         "snapshot",
+        "workbench",
         "add_column",
         "update_column",
         "delete_column",
@@ -576,6 +744,7 @@ var KANBAN_INPUT_SCHEMA = {
         "copy_task",
         "transfer_task",
         "get_task",
+        "start_task",
         "update_task",
         "transition_task",
         "repair_managed_projection",
@@ -583,6 +752,13 @@ var KANBAN_INPUT_SCHEMA = {
         "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",
@@ -608,6 +784,39 @@ var KANBAN_INPUT_SCHEMA = {
     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" },
@@ -695,6 +904,7 @@ var KANBAN_INPUT_SCHEMA = {
     taskGraph: { type: "object" },
     graphId: { type: "string" },
     specId: { type: "string" },
+    specRequirementId: { type: "string" },
     sourceSystem: { type: "string" },
     phaseId: { type: "string" },
     preserveOriginTaskIds: { type: "boolean" },
@@ -765,27 +975,6 @@ var KANBAN_INPUT_SCHEMA = {
   required: ["action"]
 };
 
-// src/kanban-presence.ts
-import { touchKanbanPresence } from "@wrongstack/kanban";
-function createKanbanPresenceWrapper(projectRoot, input, ctx) {
-  return async (result) => {
-    const boardId = result.board?.id ?? input.boardId;
-    if (!result.ok || !boardId || !ctx.session?.id || !ctx.agentId) return result;
-    try {
-      const board = await touchKanbanPresence(projectRoot, boardId, {
-        sessionId: ctx.session.id,
-        agentId: ctx.agentId,
-        agentName: ctx.agentName,
-        taskId: input.taskId ?? result.task?.id,
-        runTaskId: input.runTaskId
-      });
-      return board ? { ...result, board } : result;
-    } catch {
-      return result;
-    }
-  };
-}
-
 // src/session-kanban.ts
 import { getSharedProjectMailbox } from "@wrongstack/core/coordination";
 import {
@@ -807,6 +996,7 @@ import {
   updateBoard
 } from "@wrongstack/kanban";
 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,
@@ -815,6 +1005,7 @@ function taskFileToSerializedGraph(tasks, sessionId) {
     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,
@@ -832,8 +1023,9 @@ function taskFileToSerializedGraph(tasks, sessionId) {
   const rootNodes = nodes.filter((node) => !hasIncoming.has(node.id)).map((node) => node.id);
   return {
     // Keep the historical graph id so existing mirrored task cards are reused.
-    id: `session:${sessionId}`,
-    specId: `session:${sessionId}`,
+    id: graphId,
+    specId: graphId,
+    requiredRequirementIds: nodes.map((node) => node.specRequirementId),
     title: "Session tasks",
     nodes,
     edges,
@@ -906,7 +1098,11 @@ var kanbanTool = {
           }
           case "duplicate_board": {
             if (!input.boardId) return fail("duplicate_board requires boardId.");
-            const board = await duplicateBoard(projectRoot, input.boardId, duplicateBoardOptions(input));
+            const board = await duplicateBoard(
+              projectRoot,
+              input.boardId,
+              duplicateBoardOptions(input)
+            );
             return board ? okBoard(board, "Board duplicated.") : fail("Board not found.");
           }
           case "delete_board": {
@@ -1074,7 +1270,8 @@ var kanbanTool = {
             };
           }
           case "add_column": {
-            if (!input.boardId || !input.title) return fail("add_column requires boardId and title.");
+            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 } : {}
@@ -1103,11 +1300,7 @@ var kanbanTool = {
             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)}`
-            );
+            return okTask(result2.board, result2.task, `Task added.${atomicityNudge(result2.task)}`);
           }
           case "split_task": {
             if (!input.boardId || !input.taskId || !input.childTitles?.length) {
@@ -1166,10 +1359,72 @@ var kanbanTool = {
             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.");
+            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.");
@@ -1191,9 +1446,14 @@ var kanbanTool = {
               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
-                });
+                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
@@ -1225,11 +1485,20 @@ var kanbanTool = {
                 "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.");
+            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) {
@@ -1366,21 +1635,18 @@ var kanbanTool = {
                 };
               }
             } else if (board.lifecycle?.mode === "managed") {
-              const managedTask = board.tasks.find(
-                (candidate) => candidate.id === input.taskId
-              );
+              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." }
-                  );
+                  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)}`
@@ -1390,26 +1656,21 @@ var kanbanTool = {
               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 } : {}
-                      }
+                  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)}`
@@ -1427,6 +1688,10 @@ var kanbanTool = {
                       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 {
@@ -1437,6 +1702,7 @@ var kanbanTool = {
                             {
                               to: "done",
                               actor,
+                              action: "Automated acceptance after verification",
                               comment: "Auto-accepted: verification passed.",
                               attachment: {
                                 url: `kanban://task/${input.taskId}/verification`,