@wrongstack/tools 0.303.0 → 0.305.1

package/dist/task.js

@@ -12,12 +12,17 @@ import {
   mutateTasks
 } from "@wrongstack/core/storage";
 import { deserializeTaskGraph } from "@wrongstack/core/tasking";
-import { resolveWstackPaths } from "@wrongstack/core/utils";
+import { formatTodosForModel, resolveWstackPaths } from "@wrongstack/core/utils";
 import {
   bridgeKanbanSupervisor,
+  compactSessionMirrorBoard,
   createBoard,
+  DEFAULT_COLUMNS,
   getBoard,
+  getDependencyReadinessIssues,
+  getKanbanOrchestrationSnapshot,
   listBoards,
+  pruneSessionBoards,
   removeBoard,
   syncBoardFromTaskGraph,
   touchKanbanPresence,
@@ -25,16 +30,14 @@ import {
 } from "@wrongstack/kanban";
 var SESSION_BOARD_TAG = "session-work";
 var MIRROR_DISABLED_ENV = "WRONGSTACK_KANBAN_TASK_MIRROR";
-var SESSION_KANBAN_COLUMNS = [
-  { id: "todo", title: "Todo", order: 0, wipLimit: 0, color: "#2563eb" },
-  { id: "in-progress", title: "Running", order: 1, wipLimit: 1, color: "#d97706" },
-  { id: "review", title: "Preview", order: 2, wipLimit: 0, color: "#7c3aed" },
-  { id: "done", title: "Done", order: 3, wipLimit: 0, color: "#16a34a" }
-];
+var SESSION_KANBAN_COLUMNS = DEFAULT_COLUMNS.map((column) => ({
+  ...column
+}));
 var boardQueue = /* @__PURE__ */ new Map();
 var boardEnsures = /* @__PURE__ */ new Map();
 var pendingMirrors = /* @__PURE__ */ new Map();
 var activeMirrors = /* @__PURE__ */ new Set();
+var mirrorFailures = /* @__PURE__ */ new Map();
 var suppressedTodoMirrors = /* @__PURE__ */ new WeakSet();
 function boardKey(projectRoot, sessionId) {
   return `${projectRoot}\0${sessionId}`;
@@ -42,6 +45,33 @@ function boardKey(projectRoot, sessionId) {
 function mirrorKey(projectRoot, sessionId, sourceSystem) {
   return `${boardKey(projectRoot, sessionId)}\0${sourceSystem}`;
 }
+function completedReconciliationGraph(latest, candidates) {
+  const latestNodeIds = new Set(latest.nodes.map((node) => node.id));
+  const carriedNodeIds = /* @__PURE__ */ new Set();
+  const completedNodes = candidates.flatMap(
+    (candidate) => candidate.nodes.filter((node) => {
+      if (node.status !== "completed" || latestNodeIds.has(node.id) || carriedNodeIds.has(node.id)) {
+        return false;
+      }
+      carriedNodeIds.add(node.id);
+      return true;
+    })
+  );
+  if (completedNodes.length === 0) return void 0;
+  const carriedRequirements = completedNodes.flatMap(
+    (node) => node.specRequirementId ? [node.specRequirementId] : []
+  );
+  return {
+    ...latest,
+    nodes: [...latest.nodes, ...completedNodes],
+    rootNodes: [.../* @__PURE__ */ new Set([...latest.rootNodes, ...completedNodes.map((node) => node.id)])],
+    ...latest.requiredRequirementIds ? {
+      requiredRequirementIds: [
+        .../* @__PURE__ */ new Set([...latest.requiredRequirementIds, ...carriedRequirements])
+      ]
+    } : {}
+  };
+}
 function sessionTag(sessionId) {
   return `session:${sessionId}`;
 }
@@ -120,16 +150,44 @@ async function projectGraph(projectRoot, sessionId, graph, sourceSystem) {
         sourceSystem,
         tags: [.../* @__PURE__ */ new Set([...board.tags ?? [], ...sessionBoardTags(sessionId)])],
         archiveMissingTasks: true,
-        includeCompletedTasks: true
+        includeCompletedTasks: true,
+        // The scope ledger stays declared and accurate, but it may not veto a
+        // projection. A session mirror reflects a tactical list that shrinks by
+        // design, and refusing the sync never protected the removed row — it
+        // froze the entire board, permanently, because the stored scope then
+        // outlived every later snapshot (`session-kanban.mirror-failed`).
+        // Nothing is lost by shrinking here: `archiveMissingTasks` keeps the
+        // removed card on the board as `archived`, the reconciliation pass
+        // first walks vanished completed rows to Done, and the session journal
+        // remains the durable record.
+        allowRequirementScopeShrink: true
       }
     );
-    return result?.board ?? null;
+    if (!result) return null;
+    const compacted = await compactSessionMirrorBoard(projectRoot, board.id);
+    if (compacted?.removedTaskIds.length) {
+      return await getBoard(projectRoot, board.id) ?? result.board;
+    }
+    return result.board;
   });
 }
 function queueLatestMirror(projectRoot, sessionId, graph, sourceSystem) {
   if (!projectRoot || !sessionId || process.env[MIRROR_DISABLED_ENV] === "0") return;
   const key = mirrorKey(projectRoot, sessionId, sourceSystem);
-  pendingMirrors.set(key, { projectRoot, sessionId, graph, sourceSystem });
+  const previous = pendingMirrors.get(key);
+  const reconciliationGraph = previous ? completedReconciliationGraph(
+    graph,
+    [previous.reconciliationGraph, previous.graph].filter(
+      (candidate) => candidate !== void 0
+    )
+  ) : void 0;
+  pendingMirrors.set(key, {
+    projectRoot,
+    sessionId,
+    graph,
+    ...reconciliationGraph ? { reconciliationGraph } : {},
+    sourceSystem
+  });
   if (activeMirrors.has(key)) return;
   activeMirrors.add(key);
   void (async () => {
@@ -139,20 +197,34 @@ function queueLatestMirror(projectRoot, sessionId, graph, sourceSystem) {
         if (!pending) break;
         pendingMirrors.delete(key);
         try {
+          if (pending.reconciliationGraph) {
+            await projectGraph(
+              pending.projectRoot,
+              pending.sessionId,
+              pending.reconciliationGraph,
+              pending.sourceSystem
+            );
+          }
           await projectGraph(
             pending.projectRoot,
             pending.sessionId,
             pending.graph,
             pending.sourceSystem
           );
+          mirrorFailures.delete(boardKey(pending.projectRoot, pending.sessionId));
         } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          mirrorFailures.set(boardKey(pending.projectRoot, pending.sessionId), {
+            message,
+            sourceSystem: pending.sourceSystem
+          });
           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),
+              message,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             })
           );
@@ -173,6 +245,14 @@ function queueLatestMirror(projectRoot, sessionId, graph, sourceSystem) {
     }
   })();
 }
+function takeSessionMirrorFailure(projectRoot, sessionId) {
+  if (!projectRoot || !sessionId) return void 0;
+  const key = boardKey(projectRoot, sessionId);
+  const failure = mirrorFailures.get(key);
+  if (!failure) return void 0;
+  mirrorFailures.delete(key);
+  return `Kanban mirror (${failure.sourceSystem}) failed and the board may be stale: ${failure.message}`;
+}
 function todoListToSerializedGraph(todos, sessionId) {
   const graphId = `todo:${sessionId}`;
   const nodes = todos.map((todo, index) => ({
@@ -266,11 +346,11 @@ function broadcastTodoUpdate(context, todos) {
   });
 }
 function notifyTodoUpdate(context, todos) {
-  const summary = todos.length ? todos.map((todo) => `- [${todo.status}] ${todo.content} (${todo.id})`).join("\n") : "- No active todos remain.";
+  const summary = formatTodosForModel(todos);
   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.`;
+Reassess your current plan before continuing; do not rely on the initial todo snapshot. Preserve each row's <kanban board/task> binding verbatim on your next \`todo\` call \u2014 a row that loses it stops advancing its card.`;
   const state = context.state;
   if (typeof state.appendBlockToLastUserMessage === "function") {
     if (state.appendBlockToLastUserMessage({ type: "text", text })) return;
@@ -309,26 +389,68 @@ function todoStatus(task) {
   if (status === "in_progress" || status === "review") return "in_progress";
   return "pending";
 }
-function sessionTodoFromTask(task, boardId) {
+function sessionTodoFromTask(task, board) {
+  const blockedBy = board ? blockingTitles(board, task) : [];
   return {
     id: task.origin?.taskId ?? task.id,
     content: task.title,
     status: todoStatus(task),
-    kanbanBoardId: boardId,
-    kanbanTaskId: task.id,
-    ...task.description ? { activeForm: task.description } : {}
+    ...task.description ? { activeForm: task.description } : {},
+    ...blockedBy.length ? { blockedBy } : {}
   };
 }
-function managedTodoFromTask(task, boardId) {
+function managedTodoFromTask(task, board) {
   return {
-    ...sessionTodoFromTask(task, boardId),
-    status: task.status === "completed" ? "completed" : task.status === "in_progress" ? "in_progress" : "pending"
+    ...sessionTodoFromTask(task, board),
+    kanbanBoardId: board.id,
+    kanbanTaskId: task.id
   };
 }
+function blockingTitles(board, task) {
+  return getDependencyReadinessIssues(board, task).map((issue) => {
+    const dependency = board.tasks.find((candidate) => candidate.id === issue.dependencyId);
+    if (!dependency) return `${issue.dependencyId} (missing)`;
+    return dependency.title;
+  });
+}
+var PRIORITY_ORDER = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3
+};
+function orderTasksForTodos(board, tasks) {
+  const columnOrder = new Map(board.columns.map((column) => [column.id, column.order]));
+  const baseline = [...tasks].sort(
+    (left, right) => (columnOrder.get(left.columnId) ?? 0) - (columnOrder.get(right.columnId) ?? 0) || (PRIORITY_ORDER[left.priority] ?? 2) - (PRIORITY_ORDER[right.priority] ?? 2) || left.order - right.order || left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id)
+  );
+  const included = new Set(baseline.map((task) => task.id));
+  const remaining = new Map(baseline.map((task) => [task.id, task]));
+  const emitted = [];
+  const done = /* @__PURE__ */ new Set();
+  while (remaining.size > 0) {
+    const ready = baseline.filter(
+      (task) => remaining.has(task.id) && (task.dependsOn ?? []).every(
+        (dependencyId) => !included.has(dependencyId) || done.has(dependencyId)
+      )
+    );
+    if (ready.length === 0) break;
+    for (const task of ready) {
+      remaining.delete(task.id);
+      done.add(task.id);
+      emitted.push(task);
+    }
+  }
+  for (const task of baseline) if (remaining.has(task.id)) emitted.push(task);
+  return emitted;
+}
 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;
+    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 && // Readiness is part of the projection: when a dependency completes,
+    // the rows are otherwise identical and the unblocking would never
+    // reach the model.
+    (candidate.blockedBy ?? []).join("\0") === (todo.blockedBy ?? []).join("\0");
   });
 }
 function applyManagedKanbanBoardToTodos(context, board) {
@@ -338,11 +460,12 @@ function applyManagedKanbanBoardToTodos(context, board) {
   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));
+  const projectedTodos = orderTasksForTodos(
+    board,
+    board.tasks.filter(
+      (task) => task.status !== "archived" && task.mergedIntoTaskId === void 0 && (!task.childTaskIds || task.childTaskIds.length === 0)
+    )
+  ).map((task) => managedTodoFromTask(task, board));
   if (sameTodos(context.todos, projectedTodos)) return [...context.todos];
   suppressedTodoMirrors.add(context);
   try {
@@ -363,14 +486,13 @@ import {
   saveTasks,
   setPlanItemStatus
 } from "@wrongstack/core/storage";
-import { getBoard as getBoard4 } from "@wrongstack/kanban";
+import { addTask as addTask2, 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,
@@ -385,7 +507,7 @@ import {
   exportBoardToTaskGraph,
   finalizeTaskCompletion,
   getBoard as getBoard3,
-  getKanbanOrchestrationSnapshot,
+  getKanbanOrchestrationSnapshot as getKanbanOrchestrationSnapshot2,
   getKanbanQueueHealth,
   getTask,
   getTaskChain,
@@ -399,16 +521,16 @@ import {
   recoverStaleTaskAssignments,
   releaseTaskClaim,
   removeBoard as removeBoard2,
-  removeColumn,
   removeTask,
   repairManagedTaskProjection,
+  resolveAutoAccept,
   searchKanban,
   setTaskChain,
+  stripLifecycleIssues,
   syncBoardFromTaskGraph as syncBoardFromTaskGraph2,
   transferTaskToBoard,
   transitionTask,
   updateBoard as updateBoard2,
-  updateColumn,
   updateTask as updateTask2,
   updateTaskAssignment,
   verifyTaskCompletion as verifyTaskCompletion2
@@ -458,6 +580,137 @@ function duplicateBoardOptions(input) {
   };
 }
 
+// src/kanban-contract-actions.ts
+import {
+  addContractEdge,
+  configureContractGraph,
+  evaluateTaskContractGraph,
+  getContractGraph,
+  removeContractEdge,
+  removeContractNode,
+  upsertContractNode
+} from "@wrongstack/kanban";
+
+// src/kanban-tool-results.ts
+function atomicityNudge(task) {
+  if (task.atomicityAssessment?.verdict !== "needs_decomposition") return "";
+  const reasons = task.atomicityAssessment.criteria.filter((entry) => entry.score < 1).map((entry) => entry.reason).join(" | ");
+  return ` Atomicity: needs_decomposition (score ${task.atomicityAssessment.score}) \u2014 call propose_decomposition with 2+ subtasks before dispatch. Reasons: ${reasons}`;
+}
+function readEnvGateEnforcement() {
+  const raw = process.env["WRONGSTACK_KANBAN_GATE"]?.trim().toLowerCase();
+  return raw === "strict" || raw === "soft" || raw === "off" ? raw : void 0;
+}
+function fail(message) {
+  return { ok: false, message };
+}
+function okBoard(board, message = "Board loaded.") {
+  return { ok: true, message, board };
+}
+function okTask(board, task, message) {
+  return { ok: true, message, board, task };
+}
+
+// src/kanban-contract-actions.ts
+async function handleKanbanContractAction(projectRoot, input, actor) {
+  switch (input.action) {
+    case "get_contract_graph": {
+      if (!input.boardId) return fail("get_contract_graph requires boardId.");
+      const found = await getContractGraph(projectRoot, input.boardId);
+      if (!found) return fail("Board not found.");
+      const evaluated = input.taskId ? await evaluateTaskContractGraph(projectRoot, input.boardId, input.taskId) : null;
+      if (input.taskId && !evaluated) return fail("Task not found on this board.");
+      return {
+        ok: true,
+        message: found.graph ? `Contract map: ${found.graph.nodes.length} node(s), ${found.graph.edges.length} edge(s), enforcement ${found.graph.enforcement}.` : "No contract map on this board yet. Call configure_contract_graph to start one.",
+        board: found.board,
+        contractGraph: found.graph,
+        ...evaluated ? { contractEvaluation: evaluated.evaluation } : {}
+      };
+    }
+    case "configure_contract_graph": {
+      if (!input.boardId) return fail("configure_contract_graph requires boardId.");
+      const enforcement = input.contractEnforcement ?? "advisory";
+      const board = await configureContractGraph(projectRoot, input.boardId, enforcement);
+      return board ? okBoard(board, `Contract map enforcement set to ${enforcement}.`) : fail("Board not found.");
+    }
+    case "upsert_contract_node": {
+      if (!input.boardId || !input.taskId) {
+        return fail("upsert_contract_node requires boardId and taskId.");
+      }
+      if (!input.contractNodeKind || !input.contractNodeTitle) {
+        return fail("upsert_contract_node requires contractNodeKind and contractNodeTitle.");
+      }
+      const waiver = input.contractNodeState === "waived" ? {
+        actor: actor ?? "agent",
+        reason: input.contractWaiverReason ?? "",
+        at: (/* @__PURE__ */ new Date()).toISOString()
+      } : void 0;
+      if (waiver && !waiver.reason.trim()) {
+        return fail("A waived contract node requires contractWaiverReason.");
+      }
+      const result = await upsertContractNode(projectRoot, input.boardId, {
+        taskId: input.taskId,
+        kind: input.contractNodeKind,
+        title: input.contractNodeTitle,
+        ...input.contractNodeId !== void 0 ? { id: input.contractNodeId } : {},
+        ...input.contractNodeDescription !== void 0 ? { description: input.contractNodeDescription } : {},
+        ...input.contractNodeState !== void 0 ? { state: input.contractNodeState } : {},
+        ...input.contractNodeEnforcement !== void 0 ? { enforcement: input.contractNodeEnforcement } : {},
+        ...input.contractCheckId !== void 0 ? { checkId: input.contractCheckId } : {},
+        ...input.contractMetricId !== void 0 ? { metricId: input.contractMetricId } : {},
+        ...waiver ? { waiver } : {},
+        ...actor !== void 0 ? { createdBy: actor } : {}
+      });
+      if (!result) return fail("Board or task not found.");
+      return {
+        ok: true,
+        message: `Contract node ${result.node.kind} "${result.node.title}" saved (${result.node.id}).`,
+        board: result.board,
+        contractGraph: result.board.contractGraph ?? null
+      };
+    }
+    case "remove_contract_node": {
+      if (!input.boardId || !input.contractNodeId) {
+        return fail("remove_contract_node requires boardId and contractNodeId.");
+      }
+      const board = await removeContractNode(projectRoot, input.boardId, input.contractNodeId);
+      return board ? okBoard(board, "Contract node removed, along with every edge that touched it.") : fail("Contract node not found.");
+    }
+    case "add_contract_edge": {
+      if (!input.boardId || !input.contractEdgeFrom || !input.contractEdgeTo) {
+        return fail("add_contract_edge requires boardId, contractEdgeFrom, and contractEdgeTo.");
+      }
+      if (!input.contractEdgeType) return fail("add_contract_edge requires contractEdgeType.");
+      const result = await addContractEdge(projectRoot, input.boardId, {
+        from: input.contractEdgeFrom,
+        to: input.contractEdgeTo,
+        type: input.contractEdgeType,
+        ...input.contractEdgeId !== void 0 ? { id: input.contractEdgeId } : {},
+        ...input.contractNodeEnforcement !== void 0 ? { enforcement: input.contractNodeEnforcement } : {},
+        ...input.contractEdgeRationale !== void 0 ? { rationale: input.contractEdgeRationale } : {},
+        ...actor !== void 0 ? { createdBy: actor } : {}
+      });
+      if (!result) return fail("Board not found.");
+      return {
+        ok: true,
+        message: `Contract edge ${result.edge.type}: ${result.edge.from} \u2192 ${result.edge.to}.`,
+        board: result.board,
+        contractGraph: result.board.contractGraph ?? null
+      };
+    }
+    case "remove_contract_edge": {
+      if (!input.boardId || !input.contractEdgeId) {
+        return fail("remove_contract_edge requires boardId and contractEdgeId.");
+      }
+      const board = await removeContractEdge(projectRoot, input.boardId, input.contractEdgeId);
+      return board ? okBoard(board, "Contract edge removed.") : fail("Contract edge not found.");
+    }
+    default:
+      return void 0;
+  }
+}
+
 // src/kanban-decomposition-actions.ts
 import {
   assessTaskAtomicity,
@@ -489,26 +742,6 @@ function recordKanbanVerificationEvidence(ctx, report) {
   }
 }
 
-// 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) {
@@ -593,20 +826,14 @@ async function handleKanbanDecompositionAction(projectRoot, input, ctx) {
 // src/kanban-detail-actions.ts
 import {
   addCheckToTask,
-  addContractEdge,
   addDependency,
   addGoalMetricToTask,
   addLinkToTask,
   addNoteToTask,
-  configureContractGraph,
-  evaluateTaskContractGraph,
-  getContractGraph,
   getKanbanWorkbench,
-  removeContractEdge,
-  removeContractNode,
+  removeCheckFromTask,
   updateCheckOnTask,
-  updateGoalMetricOnTask,
-  upsertContractNode
+  updateGoalMetricOnTask
 } from "@wrongstack/kanban";
 
 // src/kanban-split-task-handler.ts
@@ -672,131 +899,6 @@ async function handleKanbanDetailAction(projectRoot, input) {
         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.");
@@ -849,8 +951,9 @@ async function handleKanbanDetailAction(projectRoot, input) {
       }
       const board = await addCheckToTask(projectRoot, input.boardId, input.taskId, {
         description: input.checkDescription,
-        type: "manual",
-        status: input.checkStatus
+        type: input.checkType ?? "manual",
+        status: input.checkStatus,
+        ...input.checkNotes !== void 0 ? { notes: input.checkNotes } : {}
       });
       return board ? okBoard(board, "Check added.") : fail("Task not found.");
     }
@@ -865,11 +968,27 @@ async function handleKanbanDetailAction(projectRoot, input) {
         input.checkId,
         {
           ...input.checkDescription !== void 0 ? { description: input.checkDescription } : {},
-          ...input.checkStatus !== void 0 ? { status: input.checkStatus } : {}
+          ...input.checkStatus !== void 0 ? { status: input.checkStatus } : {},
+          // Promoting an existing manual criterion to an executable one is the
+          // common repair: the card was written before anyone knew the command.
+          ...input.checkType !== void 0 ? { type: input.checkType } : {},
+          ...input.checkNotes !== void 0 ? { notes: input.checkNotes } : {}
         }
       );
       return board ? okBoard(board, "Check updated.") : fail("Check not found.");
     }
+    case "remove_check": {
+      if (!input.boardId || !input.taskId || !input.checkId) {
+        return fail("remove_check requires boardId, taskId, and checkId.");
+      }
+      const board = await removeCheckFromTask(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        input.checkId
+      );
+      return board ? okBoard(board, "Acceptance criterion removed.") : fail("Check not found on this task.");
+    }
     case "add_note": {
       if (!input.boardId || !input.taskId || !input.note)
         return fail("add_note requires boardId, taskId, and note.");
@@ -944,14 +1063,25 @@ function taskInput(input) {
     ...input.order !== void 0 ? { order: input.order } : {},
     ...input.retryPolicy !== void 0 ? { retryPolicy: input.retryPolicy } : {},
     ...input.costCeilingUsd !== void 0 ? { costCeilingUsd: input.costCeilingUsd } : {},
+    // The system prompt has always told the model it may "set atomic: true"
+    // when creating a composite parent. It could not: the field reached
+    // neither the create input nor the patch, so the instruction described a
+    // capability that did not exist and the attempt was silently dropped.
+    ...input.atomic !== void 0 ? { atomic: input.atomic } : {},
     ...input.childTitles !== void 0 ? { childTaskIds: input.childTitles } : {},
     ...input.checkDescription !== void 0 ? {
       successCriteria: [
         {
           id: randomUUID(),
           description: input.checkDescription,
-          type: "manual",
-          status: input.checkStatus ?? "pending"
+          // `manual` only as the fallback. Hard-coding it here meant every
+          // agent-authored criterion was unverifiable by construction: the
+          // deterministic plugins never matched, the registry passed the
+          // hand-set status straight through, and "verified" collapsed into
+          // "the author ticked its own box".
+          type: input.checkType ?? "manual",
+          status: input.checkStatus ?? "pending",
+          ...input.checkNotes !== void 0 ? { notes: input.checkNotes } : {}
         }
       ]
     } : {},
@@ -999,11 +1129,11 @@ function taskInput(input) {
   };
 }
 function mergedDependsOn(input) {
-  const ids = [
+  if (input.dependsOn === void 0 && input.dependencyTaskId === void 0) return void 0;
+  return [
     ...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 {
@@ -1017,7 +1147,15 @@ function taskPatch(input) {
     status: input.status,
     labels: input.labels,
     assignedAgent: input.agentId,
-    ...mergedDependsOn(input) ? { dependsOn: mergedDependsOn(input) } : {},
+    ...mergedDependsOn(input) !== void 0 ? { dependsOn: mergedDependsOn(input) } : {},
+    // `atomic` and `childTaskIds` are the composite-parent contract, and the
+    // managed gate reads both: an `atomic` parent may not move forward without
+    // children, and may not reach Done until every child is completed. The
+    // manager has always accepted both on a patch; only this surface withheld
+    // them, so `split_atomic` was a one-way door — delete the children and the
+    // parent was stranded with no way to declare itself a leaf again.
+    ...input.atomic !== void 0 ? { atomic: input.atomic } : {},
+    ...input.childTaskIds !== void 0 ? { childTaskIds: input.childTaskIds } : {},
     ...input.estimatedHours !== void 0 ? { estimatedHours: input.estimatedHours } : {},
     ...input.actualHours !== void 0 ? { actualHours: input.actualHours } : {}
   };
@@ -1077,8 +1215,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. 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_TOOL_DESCRIPTION = "Durable project task boards: create and move cards, record checks, notes, links and assignments. The board is a record of the work, not a permit for it \u2014 nothing here gates other tools. Managed boards additionally enforce ordered Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions; release_managed_lifecycle turns that off.";
+var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything.';
 var KANBAN_INPUT_SCHEMA = {
   type: "object",
   properties: {
@@ -1091,6 +1229,7 @@ var KANBAN_INPUT_SCHEMA = {
         "duplicate_board",
         "update_board",
         "adopt_managed_lifecycle",
+        "release_managed_lifecycle",
         "delete_board",
         "generate_board",
         "export_markdown",
@@ -1102,9 +1241,6 @@ var KANBAN_INPUT_SCHEMA = {
         "ready_tasks",
         "snapshot",
         "workbench",
-        "add_column",
-        "update_column",
-        "delete_column",
         "add_task",
         "split_task",
         "merge_tasks",
@@ -1119,13 +1255,6 @@ 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",
@@ -1139,49 +1268,27 @@ var KANBAN_INPUT_SCHEMA = {
         "update_goal_metric",
         "add_check",
         "update_check",
+        "remove_check",
         "add_note",
         "add_link",
         "verify_completion",
         "split_atomic",
         "assess_atomicity",
-        "propose_decomposition"
+        "propose_decomposition",
+        "get_contract_graph",
+        "configure_contract_graph",
+        "upsert_contract_node",
+        "remove_contract_node",
+        "add_contract_edge",
+        "remove_contract_edge"
       ]
     },
     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" },
@@ -1265,7 +1372,20 @@ var KANBAN_INPUT_SCHEMA = {
     costCeilingUsd: { type: "number" },
     retryPolicy: { type: "string", enum: ["off", "incremental", "exponential"] },
     lastFailureKind: { type: "string" },
-    dependsOn: { type: "array", items: { type: "string" } },
+    dependsOn: {
+      type: "array",
+      items: { type: "string" },
+      description: "Task ids this card waits on. On update_task an explicit empty array clears them \u2014 use it when a dependency was recorded in error rather than completing work nobody wants."
+    },
+    atomic: {
+      type: "boolean",
+      description: "Composite parent (true) or executable leaf (false). Set false to make a stranded parent a leaf again after its children were dropped."
+    },
+    childTaskIds: {
+      type: "array",
+      items: { type: "string" },
+      description: "Children of a composite parent. On update_task an explicit empty array detaches them all."
+    },
     estimatedHours: { type: "number" },
     actualHours: { type: "number" },
     taskGraph: { type: "object" },
@@ -1299,6 +1419,74 @@ var KANBAN_INPUT_SCHEMA = {
     checkId: { type: "string" },
     checkDescription: { type: "string" },
     checkStatus: { type: "string", enum: ["pending", "passed", "failed", "skipped"] },
+    checkType: {
+      type: "string",
+      // Only types a verifier can actually execute. `manual` is the default and
+      // means a human or agent asserts the status by hand. The rest are run by
+      // `verify_completion` against the default deterministic registry. Types
+      // with no plugin in that registry (`auto`, `review`, `agent`, `council`)
+      // are deliberately omitted: offering them would produce criteria that
+      // silently report `skipped — no verifier plugin registered`.
+      enum: ["manual", "command", "test", "file_exists", "file_matches", "git_diff", "metric"],
+      description: 'How this acceptance criterion is verified. Default "manual" (status set by hand). Any other value makes verify_completion execute it, so the criterion becomes real evidence rather than a self-assertion. Pair with checkNotes.'
+    },
+    checkNotes: {
+      type: "string",
+      description: 'The executable body for a non-manual checkType, read in preference to checkDescription. command/test: the shell command or test pattern. file_exists: the path. file_matches: JSON {"file","pattern","flags"}. git_diff: JSON {"expectedFiles","minChanges","maxChanges"}.'
+    },
+    // ── Contract map ───────────────────────────────────────────────────
+    // The card contract: what this work targets, what it must not break, what
+    // it risks, and what verifies it. Advisory by default — the readiness gate
+    // deliberately does not require map structure, so a map is an operator
+    // review aid, not work the model must complete before implementing.
+    contractEnforcement: {
+      type: "string",
+      enum: ["off", "advisory", "strict"],
+      description: "Board-level contract map enforcement. Default when first configured: advisory."
+    },
+    contractNodeId: { type: "string" },
+    contractNodeKind: {
+      type: "string",
+      enum: ["objective", "guardrail", "risk", "component", "artifact", "verification"],
+      description: "objective = what this card is for; guardrail = what must keep working; risk = what could go wrong; component/artifact = what it touches; verification = what settles it."
+    },
+    contractNodeTitle: { type: "string" },
+    contractNodeDescription: { type: "string" },
+    contractNodeState: {
+      type: "string",
+      enum: ["unknown", "active", "satisfied", "violated", "waived", "resolved"]
+    },
+    contractNodeEnforcement: {
+      type: "string",
+      enum: ["blocking", "advisory", "informational"]
+    },
+    /** Bind a node to an acceptance criterion or goal metric already on the task. */
+    contractCheckId: { type: "string" },
+    contractMetricId: { type: "string" },
+    contractWaiverReason: {
+      type: "string",
+      description: 'Required, with an actor, when contractNodeState is "waived".'
+    },
+    contractEdgeId: { type: "string" },
+    contractEdgeFrom: {
+      type: "string",
+      description: 'A contract node id, or a task id (bare or "task:<id>") for the card endpoint.'
+    },
+    contractEdgeTo: { type: "string" },
+    contractEdgeType: {
+      type: "string",
+      enum: [
+        "targets",
+        "affects",
+        "must_preserve",
+        "exposes",
+        "verified_by",
+        "conflicts_with",
+        "derived_from",
+        "relates_to"
+      ]
+    },
+    contractEdgeRationale: { type: "string" },
     note: { type: "string" },
     author: { type: "string" },
     url: { type: "string" },
@@ -1373,8 +1561,14 @@ var kanbanTool = {
           }
           case "create_board": {
             if (!input.title) return fail("create_board requires title.");
+            const existing = (await listBoards2(projectRoot)).filter(
+              (candidate) => (candidate.kind ?? "project") === "project"
+            );
             const board = await createBoard2(projectRoot, boardCreateInput(input, input.title));
-            return { ok: true, message: `Board created: ${board.title}`, board };
+            const note = existing.length ? ` ${existing.length} other project board(s) already exist: ${existing.slice(0, 3).map((candidate) => `"${candidate.title}" (${candidate.taskCount} task(s))`).join(
+              ", "
+            )}${existing.length > 3 ? ", \u2026" : ""}. If this work belongs to one of them, add_task there instead and delete this board.` : "";
+            return { ok: true, message: `Board created: ${board.title}.${note}`, board };
           }
           case "update_board": {
             if (!input.boardId) return fail("update_board requires boardId.");
@@ -1403,6 +1597,20 @@ var kanbanTool = {
             });
             return board ? okBoard(board, "Managed lifecycle adopted without moving existing cards.") : fail("Board not found.");
           }
+          // Adoption used to be a one-way door: the strict lifecycle carries
+          // acceptance-criteria, verification-report, review-evidence and
+          // one-stage-at-a-time gates, and nothing on the tool surface could
+          // undo it, so a board adopted once kept its ceremony forever. The
+          // gates are worth having where a fleet is supervised; they are not
+          // worth being unable to leave. Cards and columns are untouched.
+          case "release_managed_lifecycle": {
+            if (!input.boardId) return fail("release_managed_lifecycle requires boardId.");
+            const board = await updateBoard2(projectRoot, input.boardId, { lifecycle: null });
+            return board ? okBoard(
+              board,
+              "Managed lifecycle released; the board now tracks work without strict gates."
+            ) : fail("Board not found.");
+          }
           case "duplicate_board": {
             if (!input.boardId) return fail("duplicate_board requires boardId.");
             const board = await duplicateBoard(
@@ -1422,8 +1630,7 @@ var kanbanTool = {
             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 } : {}
+              ...input.context !== void 0 ? { context: input.context } : {}
             });
             const board = await createBoard2(projectRoot, boardInput);
             for (const taskInput2 of parseLinesIntoTasks(
@@ -1561,7 +1768,7 @@ var kanbanTool = {
             return { ok: true, message: `${tasks.length} ready task(s).`, tasks };
           }
           case "snapshot": {
-            const snapshot = await getKanbanOrchestrationSnapshot(projectRoot, {
+            const snapshot = await getKanbanOrchestrationSnapshot2(projectRoot, {
               query: input.query,
               boardId: input.boardId,
               assignedAgent: input.agentId,
@@ -1576,33 +1783,6 @@ var kanbanTool = {
               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));
@@ -1684,6 +1864,32 @@ var kanbanTool = {
                 `Task is not implementation-ready: ${readiness.issues.map((issue) => issue.message).join(" | ")}`
               );
             }
+            if (board.lifecycle?.mode !== "managed") {
+              const now = /* @__PURE__ */ new Date();
+              const assigned = await updateTaskAssignment(projectRoot, board.id, task.id, {
+                status: "running",
+                agentId: input.agentId ?? input.author,
+                leaseId: input.leaseId ?? randomUUID2(),
+                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 started = await updateTask2(projectRoot, board.id, task.id, {
+                status: "in_progress"
+              });
+              const current = started ?? assigned;
+              const claimed = task;
+              const currentTask = current.tasks.find((candidate) => candidate.id === claimed.id) ?? claimed;
+              ctx.setCurrentKanbanTask?.(currentTask.id, current.id);
+              return okTask(
+                current,
+                currentTask,
+                "Task is active and bound to this run for attribution. This board is not in managed lifecycle mode, so runtime Kanban governance was not bound to it."
+              );
+            }
             let stage = task.lifecycle?.currentStage;
             if (stage === "backlog") {
               const moved = await transitionTask(projectRoot, board.id, task.id, {
@@ -1824,6 +2030,9 @@ var kanbanTool = {
             if (!input.boardId || !input.taskId)
               return fail("delete_task requires boardId and taskId.");
             const board = await removeTask(projectRoot, input.boardId, input.taskId);
+            if (board && ctx.currentKanbanTaskId === input.taskId) {
+              ctx.setCurrentKanbanTask?.(void 0, ctx.currentKanbanBoardId);
+            }
             return board ? okBoard(board, "Task deleted.") : fail("Task not found.");
           }
           case "set_chain": {
@@ -1956,7 +2165,7 @@ var kanbanTool = {
                   });
                 } catch (err) {
                   lifecycleWarnings.push(
-                    `Lifecycle transition to Running deferred: ${err instanceof Error ? err.message : String(err)}`
+                    `Lifecycle transition to Running deferred: ${stripLifecycleIssues(err instanceof Error ? err.message : String(err))}`
                   );
                 }
               }
@@ -1980,7 +2189,7 @@ var kanbanTool = {
                   });
                 } catch (err) {
                   lifecycleWarnings.push(
-                    `Lifecycle transition to Review failed: ${err instanceof Error ? err.message : String(err)}`
+                    `Lifecycle transition to Review failed: ${stripLifecycleIssues(err instanceof Error ? err.message : String(err))}`
                   );
                 }
                 if (transitionResult) {
@@ -2000,7 +2209,11 @@ var kanbanTool = {
                         successCriteria: verResult.task.successCriteria
                       });
                       const verdict = verResult.report.verdict;
-                      if (verdict === "passed") {
+                      if (verdict === "passed" && !resolveAutoAccept(board)) {
+                        lifecycleWarnings.push(
+                          "Verification passed, but this board does not auto-accept. The card is in Review awaiting an explicit transition_task to done."
+                        );
+                      } else if (verdict === "passed") {
                         try {
                           const doneResult = await transitionTask(
                             projectRoot,
@@ -2118,11 +2331,34 @@ var kanbanTool = {
             });
             return {
               ok: true,
-              message: `Counts: ready=${health.counts.ready}, running=${health.counts.running}, stale=${health.staleAssignments.count}.`,
+              message: `Counts: startable=${health.counts.startable}, running=${health.counts.running}, stale=${health.staleAssignments.count}.`,
               queueHealth: health
             };
           }
+          // Not every action is handled above. These are dispatched from here,
+          // and the split has already cost real time: an agent that read this
+          // file concluded `add_check` / `update_check` did not exist, wrote
+          // that on a card, and spent a session trying to satisfy a gate it
+          // already had the tool to clear. Keep this index in step with the
+          // handlers.
+          //
+          //   kanban-detail-actions.ts  workbench · add_dependency ·
+          //     add_goal_metric · update_goal_metric · add_check ·
+          //     update_check · add_note · add_link · split_atomic
+          //   kanban-decomposition-actions.ts  verify_completion ·
+          //     assess_atomicity · propose_decomposition
+          //   kanban-contract-actions.ts  get_contract_graph ·
+          //     configure_contract_graph · upsert_contract_node ·
+          //     remove_contract_node · add_contract_edge · remove_contract_edge
           default:
+            {
+              const contractResult = await handleKanbanContractAction(
+                projectRoot,
+                input,
+                input.author ?? input.agentId
+              );
+              if (contractResult !== void 0) return contractResult;
+            }
             {
               const detailResult = await handleKanbanDetailAction(projectRoot, input);
               if (detailResult !== void 0) return detailResult;
@@ -2132,7 +2368,7 @@ var kanbanTool = {
       })();
       return withPresence(result);
     } catch (err) {
-      return fail(err instanceof Error ? err.message : String(err));
+      return fail(stripLifecycleIssues(err instanceof Error ? err.message : String(err)));
     }
   }
 };
@@ -2165,11 +2401,51 @@ function bindTodosToBoard(items, previous, board) {
       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 };
+    if (!task) {
+      const { blockedBy: _discarded, ...rest } = item;
+      return { ...rest };
+    }
     used.add(task.id);
-    return { ...item, kanbanBoardId: board.id, kanbanTaskId: task.id };
+    const blockedBy = blockingTitles(board, task);
+    return {
+      ...item,
+      kanbanBoardId: board.id,
+      kanbanTaskId: task.id,
+      ...blockedBy.length ? { blockedBy } : { blockedBy: void 0 }
+    };
+  });
+}
+function demoteBlockedInProgress(items, warnings) {
+  return items.map((item) => {
+    if (item.status !== "in_progress" || !item.blockedBy?.length) return item;
+    warnings.push(
+      `"${item.content}" cannot start yet \u2014 it waits on: ${item.blockedBy.join("; ")}. Kept as pending; complete the blocking work first.`
+    );
+    return { ...item, status: "pending" };
   });
 }
+async function createMissingManagedCards(items, board, ctx, warnings) {
+  const created = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (item.kanbanBoardId === board.id && item.kanbanTaskId) continue;
+    try {
+      const result = await addTask2(ctx.projectRoot, board.id, {
+        title: item.content,
+        description: item.activeForm?.trim() || `Added from the session todo list: ${item.content}`
+      });
+      if (!result) {
+        warnings.push(`Could not open a Kanban card for "${item.content}": board not found.`);
+        continue;
+      }
+      created.set(item.id, result.task.id);
+    } catch (error) {
+      warnings.push(
+        `Could not open a Kanban card for "${item.content}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return created;
+}
 async function synchronizeManagedKanban(items, board, ctx, signal) {
   let synced = 0;
   const warnings = [];
@@ -2207,6 +2483,16 @@ async function synchronizeManagedKanban(items, board, ctx, signal) {
       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?.status !== "completed") continue;
+    warnings.push(
+      `"${item.content}" is already Done on the Kanban board and a completed card cannot be reopened; the row stays completed. Create a follow-up card for any remaining work.`
+    );
+  }
   for (const item of items) {
     if (item.status !== "completed" || item.kanbanBoardId !== board.id || !item.kanbanTaskId) {
       continue;
@@ -2258,17 +2544,25 @@ async function synchronizeManagedKanban(items, board, ctx, signal) {
   const active = items.find(
     (item) => item.status === "in_progress" && item.kanbanBoardId === board.id && Boolean(item.kanbanTaskId)
   );
+  const activeStage = active?.kanbanTaskId ? afterCompletions?.tasks.find((task) => task.id === active.kanbanTaskId)?.lifecycle?.currentStage : void 0;
   if (active?.kanbanTaskId) {
-    await execute({
-      action: "start_task",
-      boardId: board.id,
-      taskId: active.kanbanTaskId,
-      author: actor,
-      agentId: actor,
-      transitionComment: `Todo activated: ${active.content}`
-    });
+    if (activeStage === "review" || activeStage === "done") {
+      warnings.push(
+        `"${active.content}" is in ${activeStage === "review" ? "Review" : "Done"} awaiting acceptance; not re-activating it from the todo list. ` + (activeStage === "review" ? "Call kanban start_task explicitly to reopen it as a repair." : "Done is terminal; reopen only by creating a follow-up card.")
+      );
+    } else {
+      await execute({
+        action: "start_task",
+        boardId: board.id,
+        taskId: active.kanbanTaskId,
+        author: actor,
+        agentId: actor,
+        transitionComment: `Todo activated: ${active.content}`
+      });
+    }
   }
-  if (active?.kanbanTaskId && completionPending) {
+  if (active?.kanbanTaskId && activeStage === "review") {
+  } else if (active?.kanbanTaskId && completionPending) {
     warnings.push(
       "A completed todo is still awaiting acceptance; the next independent Kanban task was started."
     );
@@ -2355,29 +2649,47 @@ var todoTool = {
       }
     }
     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;
+    let board = boardId ? await getBoard4(ctx.projectRoot, boardId) : null;
+    const managed = board?.lifecycle?.mode === "managed";
+    let boundItems = managed && board ? bindTodosToBoard(items, ctx.todos ?? [], board) : items;
+    const creationWarnings = [];
+    if (managed && board) {
+      const managedBoardId = board.id;
+      const created = await createMissingManagedCards(boundItems, board, ctx, creationWarnings);
+      if (created.size > 0) {
+        boundItems = boundItems.map((item) => {
+          const taskId = created.get(item.id);
+          return taskId ? { ...item, kanbanBoardId: managedBoardId, kanbanTaskId: taskId } : item;
+        });
+        board = await getBoard4(ctx.projectRoot, managedBoardId) ?? board;
+        boundItems = bindTodosToBoard(boundItems, ctx.todos ?? [], board);
+      }
+      boundItems = demoteBlockedInProgress(boundItems, creationWarnings);
+    }
     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 kanbanSync = managed && board ? await synchronizeManagedKanban(boundItems, board, ctx, call.signal) : { synced: 0, warnings: [] };
+    kanbanSync.warnings.unshift(...creationWarnings);
+    if (managed && board) {
       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.`
+          `${unresolved.length} Todo row(s) could not be bound to a Kanban task and were not applied. Preserve kanbanBoardId/kanbanTaskId when updating the projection.`
         );
       }
     }
+    const mirrorFailure = takeSessionMirrorFailure(ctx.projectRoot, ctx.session?.id ?? "");
+    if (mirrorFailure) kanbanSync.warnings.push(mirrorFailure);
     let projectedBoard = board;
-    if (board?.lifecycle?.mode === "managed") {
+    if (managed && board) {
       const refreshed = await getBoard4(ctx.projectRoot, board.id);
       if (refreshed) {
         projectedBoard = refreshed;
         applyManagedKanbanBoardToTodos(ctx, refreshed);
       }
     }
-    if (board?.lifecycle?.mode !== "managed") {
+    if (!managed) {
       mirrorSessionTodosToKanban(ctx.projectRoot, items, ctx.session?.id ?? "session");
     }
     const completedPlanIds = /* @__PURE__ */ new Set();