@wrongstack/tools 0.302.2 → 0.305.0

package/dist/kanban.js

@@ -1,8 +1,8 @@
 // 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,
   adoptManagedLifecycle,
   assignTask,
@@ -10,12 +10,14 @@ import {
   copyTaskToBoard,
   createBoard as createBoard2,
   createBoardFromTaskGraph,
+  createBoardFromText,
   duplicateBoard,
+  evaluateContractGraphReadiness,
   exportBoardAsMarkdown,
   exportBoardToTaskGraph,
-  createBoardFromText,
+  finalizeTaskCompletion,
   getBoard as getBoard3,
-  getKanbanOrchestrationSnapshot,
+  getKanbanOrchestrationSnapshot as getKanbanOrchestrationSnapshot2,
   getKanbanQueueHealth,
   getTask,
   getTaskChain,
@@ -27,53 +29,76 @@ import {
   moveTask,
   parseLinesIntoTasks,
   recoverStaleTaskAssignments,
-  repairManagedTaskProjection,
   releaseTaskClaim,
   removeBoard as removeBoard2,
-  removeColumn,
   removeTask,
+  repairManagedTaskProjection,
+  resolveAutoAccept,
   searchKanban,
   setTaskChain,
+  stripLifecycleIssues,
   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-evidence-bridge.ts
-import { recordCompletedWorkEvidence } from "@wrongstack/core/utils";
-function kanbanEvidenceKey(boardId, taskId) {
-  return `kanban:${boardId}:${taskId}`;
+// src/kanban-board-inputs.ts
+function agentSettableGate(enforcement) {
+  if (enforcement === void 0 || enforcement === "off") return {};
+  return { completionGate: { enforcement } };
 }
-function kanbanEvidencePointer(boardId, taskId) {
-  return `kanban://${boardId}/${taskId}#verificationReport`;
+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 recordKanbanVerificationEvidence(ctx, report) {
-  try {
-    const passed = report.checks.filter((check) => check.status === "passed").length;
-    const completedAt = Date.parse(report.completedAt);
-    recordCompletedWorkEvidence(ctx, {
-      key: kanbanEvidenceKey(report.boardId, report.taskId),
-      source: "verification",
-      summary: `${report.taskTitle} \u2014 verification ${report.verdict} (${passed}/${report.checks.length} checks)`,
-      ...Number.isFinite(completedAt) ? { completedAt } : {},
-      evidence: kanbanEvidencePointer(report.boardId, report.taskId)
-    });
-  } catch {
-  }
+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
+// src/kanban-contract-actions.ts
 import {
-  assessTaskAtomicity,
-  proposeTaskDecomposition,
-  updateTask,
-  verifyTaskCompletion
+  addContractEdge,
+  configureContractGraph,
+  evaluateTaskContractGraph,
+  getContractGraph,
+  removeContractEdge,
+  removeContractNode,
+  upsertContractNode
 } from "@wrongstack/kanban";
 
 // src/kanban-tool-results.ts
@@ -96,6 +121,137 @@ 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,
+  proposeTaskDecomposition,
+  updateTask,
+  verifyTaskCompletion
+} from "@wrongstack/kanban";
+
+// src/kanban-evidence-bridge.ts
+import { recordCompletedWorkEvidence } from "@wrongstack/core/utils";
+function kanbanEvidenceKey(boardId, taskId) {
+  return `kanban:${boardId}:${taskId}`;
+}
+function kanbanEvidencePointer(boardId, taskId) {
+  return `kanban://${boardId}/${taskId}#verificationReport`;
+}
+function recordKanbanVerificationEvidence(ctx, report) {
+  try {
+    const passed = report.checks.filter((check) => check.status === "passed").length;
+    const completedAt = Date.parse(report.completedAt);
+    recordCompletedWorkEvidence(ctx, {
+      key: kanbanEvidenceKey(report.boardId, report.taskId),
+      source: "verification",
+      summary: `${report.taskTitle} \u2014 verification ${report.verdict} (${passed}/${report.checks.length} checks)`,
+      ...Number.isFinite(completedAt) ? { completedAt } : {},
+      evidence: kanbanEvidencePointer(report.boardId, report.taskId)
+    });
+  } catch {
+  }
+}
+
 // src/kanban-decomposition-actions.ts
 async function handleKanbanDecompositionAction(projectRoot, input, ctx) {
   switch (input.action) {
@@ -184,6 +340,8 @@ import {
   addGoalMetricToTask,
   addLinkToTask,
   addNoteToTask,
+  getKanbanWorkbench,
+  removeCheckFromTask,
   updateCheckOnTask,
   updateGoalMetricOnTask
 } from "@wrongstack/kanban";
@@ -241,6 +399,16 @@ 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 "add_dependency": {
       if (!input.boardId || !input.taskId || !input.dependencyTaskId) {
         return fail("add_dependency requires boardId, taskId, and dependencyTaskId.");
@@ -293,8 +461,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.");
     }
@@ -309,11 +478,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.");
@@ -344,47 +529,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;
+    }
   };
 }
 
@@ -411,14 +573,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 } : {}
         }
       ]
     } : {},
@@ -454,22 +627,23 @@ 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 } : {}
       }
     } : {}
   };
 }
 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 {
@@ -483,7 +657,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 } : {}
   };
@@ -543,8 +725,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 = "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: {
@@ -557,6 +739,7 @@ var KANBAN_INPUT_SCHEMA = {
         "duplicate_board",
         "update_board",
         "adopt_managed_lifecycle",
+        "release_managed_lifecycle",
         "delete_board",
         "generate_board",
         "export_markdown",
@@ -567,15 +750,14 @@ var KANBAN_INPUT_SCHEMA = {
         "search_tasks",
         "ready_tasks",
         "snapshot",
-        "add_column",
-        "update_column",
-        "delete_column",
+        "workbench",
         "add_task",
         "split_task",
         "merge_tasks",
         "copy_task",
         "transfer_task",
         "get_task",
+        "start_task",
         "update_task",
         "transition_task",
         "repair_managed_projection",
@@ -596,18 +778,29 @@ 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" },
+    fromNodeId: { type: "string" },
+    toNodeId: { type: "string" },
+    baseline: { oneOf: [{ type: "string" }, { type: "number" }] },
+    threshold: { oneOf: [{ type: "string" }, { type: "number" }] },
     columnId: { type: "string" },
     targetBoardId: { type: "string" },
     targetColumnId: { type: "string" },
@@ -689,12 +882,26 @@ 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" },
     graphId: { type: "string" },
     specId: { type: "string" },
+    specRequirementId: { type: "string" },
     sourceSystem: { type: "string" },
     phaseId: { type: "string" },
     preserveOriginTaskIds: { type: "boolean" },
@@ -722,6 +929,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" },
@@ -765,27 +1040,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 {
@@ -795,18 +1049,27 @@ 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 as getBoard2,
+  getDependencyReadinessIssues,
+  getKanbanOrchestrationSnapshot,
   listBoards,
+  pruneSessionBoards,
   removeBoard,
   syncBoardFromTaskGraph,
   touchKanbanPresence as touchKanbanPresence2,
   updateBoard
 } from "@wrongstack/kanban";
+var SESSION_KANBAN_COLUMNS = DEFAULT_COLUMNS.map((column) => ({
+  ...column
+}));
 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 +1078,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 +1096,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,
@@ -874,8 +1139,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.");
@@ -904,9 +1175,27 @@ 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(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": {
@@ -919,8 +1208,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(
@@ -1058,7 +1346,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,
@@ -1073,41 +1361,11 @@ 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));
             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 +1424,98 @@ 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(" | ")}`
+              );
+            }
+            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, {
+                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 +1537,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 +1576,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) {
@@ -1248,6 +1608,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": {
@@ -1366,53 +1729,45 @@ 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)}`
+                    `Lifecycle transition to Running deferred: ${stripLifecycleIssues(err instanceof Error ? err.message : String(err))}`
                   );
                 }
               }
               if (assignmentStatus === "completed" && stage === "running") {
                 const comment = typeof input.lastResult === "string" && input.lastResult.trim().length > 0 ? input.lastResult.trim().slice(0, 1e3) : "Work completed.";
                 try {
-                  transitionResult = await transitionTask(
-                    projectRoot,
-                    board.id,
-                    input.taskId,
-                    {
-                      to: "review",
-                      actor,
-                      comment,
-                      attachment: {
-                        url: `kanban://task/${input.taskId}/result`,
-                        title: "Worker completion result",
-                        type: "file"
-                      },
-                      patch: {
-                        // Only patch non-description fields so the
-                        // original card description is preserved.
-                        ...input.agentId !== void 0 ? { assignedAgent: input.agentId } : {}
-                      }
+                  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)}`
+                    `Lifecycle transition to Review failed: ${stripLifecycleIssues(err instanceof Error ? err.message : String(err))}`
                   );
                 }
                 if (transitionResult) {
@@ -1427,8 +1782,16 @@ 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") {
+                      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,
@@ -1437,6 +1800,7 @@ var kanbanTool = {
                             {
                               to: "done",
                               actor,
+                              action: "Automated acceptance after verification",
                               comment: "Auto-accepted: verification passed.",
                               attachment: {
                                 url: `kanban://task/${input.taskId}/verification`,
@@ -1545,11 +1909,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;
@@ -1559,7 +1946,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)));
     }
   }
 };