@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-JNNVRHMV.js

@@ -0,0 +1,2111 @@
+import {
+  applySessionKanbanTaskToSource,
+  taskFileToSerializedGraph
+} from "./chunk-PY2IOS7C.js";
+
+// src/kanban.ts
+import { stripLifecycleIssues as stripLifecycleIssues2 } from "@wrongstack/kanban";
+
+// src/kanban-board-actions.ts
+import { loadTasks } from "@wrongstack/core/storage";
+import { deserializeTaskGraph, serializeTaskGraph } from "@wrongstack/core/tasking";
+import {
+  addTask,
+  adoptManagedLifecycle,
+  createBoard,
+  createBoardFromTaskGraph,
+  createBoardFromText,
+  duplicateBoard,
+  exportBoardAsMarkdown,
+  exportBoardToTaskGraph,
+  getBoard as getBoard2,
+  getKanbanOrchestrationSnapshot,
+  getKanbanQueueHealth,
+  listBoards,
+  listKanbanEvents,
+  listReadyTasks,
+  parseLinesIntoTasks,
+  removeBoard,
+  searchKanban,
+  syncBoardFromTaskGraph,
+  updateBoard
+} from "@wrongstack/kanban";
+
+// src/kanban-board-inputs.ts
+function agentSettableGate(enforcement) {
+  if (enforcement === void 0 || enforcement === "off") return {};
+  return { completionGate: { enforcement } };
+}
+function boardCreateInput(input, title) {
+  return {
+    title,
+    ...input.description !== void 0 ? { description: input.description } : {},
+    ...input.tags !== void 0 ? { tags: input.tags } : {},
+    ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
+    ...input.atomicityMode !== void 0 ? {
+      atomicity: {
+        mode: input.atomicityMode,
+        decomposition: input.atomicityDecomposition ?? "propose"
+      }
+    } : {},
+    ...agentSettableGate(input.gateEnforcement)
+  };
+}
+function boardUpdatePatch(input) {
+  return {
+    ...input.title !== void 0 ? { title: input.title } : {},
+    ...input.description !== void 0 ? { description: input.description } : {},
+    ...input.tags !== void 0 ? { tags: input.tags } : {},
+    ...input.atomicityMode !== void 0 ? {
+      atomicity: {
+        mode: input.atomicityMode,
+        decomposition: input.atomicityDecomposition ?? "propose"
+      }
+    } : {},
+    ...agentSettableGate(input.gateEnforcement)
+  };
+}
+function duplicateBoardOptions(input) {
+  return {
+    ...input.title !== void 0 ? { title: input.title } : {},
+    ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
+    ...input.includeTasks !== void 0 ? { includeTasks: input.includeTasks } : {},
+    ...input.includeCompletedTasks !== void 0 ? { includeCompletedTasks: input.includeCompletedTasks } : {},
+    ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {}
+  };
+}
+
+// src/kanban-split-task-handler.ts
+import { getBoard, splitTask } 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-split-task-handler.ts
+async function handleSplitTask(projectRoot, input, extraSplitOptions, eventContext) {
+  const boardId = input.boardId;
+  const taskId = input.taskId;
+  const childTitles = input.childTitles;
+  if (!boardId || !taskId || !childTitles?.length) {
+    return fail("split requires boardId, taskId, and at least one childTitles.");
+  }
+  const {
+    targetColumnId,
+    inheritAssignment,
+    inheritLabels,
+    inheritSuccessCriteria,
+    inheritGoalMetrics,
+    inheritDependencies,
+    chainChildren,
+    rewireDependents
+  } = input;
+  const result = await splitTask(
+    projectRoot,
+    boardId,
+    taskId,
+    {
+      titles: childTitles,
+      ...extraSplitOptions,
+      ...targetColumnId !== void 0 ? { columnId: targetColumnId } : {},
+      ...inheritAssignment !== void 0 ? { inheritAssignment } : {},
+      ...inheritLabels !== void 0 ? { inheritLabels } : {},
+      ...inheritSuccessCriteria !== void 0 ? { inheritSuccessCriteria } : {},
+      ...inheritGoalMetrics !== void 0 ? { inheritGoalMetrics } : {},
+      ...inheritDependencies !== void 0 ? { inheritDependencies } : {},
+      ...chainChildren !== void 0 ? { chainChildren } : {},
+      ...rewireDependents !== void 0 ? { rewireDependents } : {}
+    },
+    eventContext
+  );
+  if (!result) return fail("Task not found.");
+  const freshParent = result.board.tasks?.find((t) => t.id === taskId);
+  if (!freshParent) {
+    return fail(
+      `Split succeeded but parent ${taskId} not found in returned board. Children: [${result.children.map((c) => c.id).join(", ")}].`
+    );
+  }
+  return {
+    ok: true,
+    message: `${result.children.length} child task(s) created.`,
+    board: result.board,
+    task: freshParent,
+    children: result.children
+  };
+}
+async function requireBoard(projectRoot, boardId) {
+  return boardId ? getBoard(projectRoot, boardId) : null;
+}
+
+// src/kanban-board-actions.ts
+async function handleKanbanBoardAction(projectRoot, input, ctx) {
+  const eventContext = {
+    sessionId: ctx.eventSessionId(),
+    ...ctx.agentId !== void 0 ? { actor: ctx.agentId } : {}
+  };
+  switch (input.action) {
+    case "list_boards": {
+      const boards = await listBoards(projectRoot);
+      return { ok: true, message: `${boards.length} board(s).`, boards };
+    }
+    case "get_board": {
+      const board = await requireBoard(projectRoot, input.boardId);
+      return board ? okBoard(board) : fail("Board not found.");
+    }
+    case "create_board": {
+      if (!input.title) return fail("create_board requires title.");
+      const existing = (await listBoards(projectRoot)).filter(
+        (candidate) => (candidate.kind ?? "project") === "project"
+      );
+      const board = await createBoard(projectRoot, boardCreateInput(input, input.title));
+      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.");
+      const board = await updateBoard(projectRoot, input.boardId, boardUpdatePatch(input));
+      return board ? okBoard(board, "Board updated.") : fail("Board not found.");
+    }
+    case "adopt_managed_lifecycle": {
+      if (!input.boardId || !input.author || !input.transitionComment) {
+        return fail(
+          "adopt_managed_lifecycle requires boardId, author, transitionComment, and five ordered columns."
+        );
+      }
+      if (input.columns?.length !== 5) {
+        return fail(
+          "adopt_managed_lifecycle columns must be ordered as backlog, todo, running, review, done."
+        );
+      }
+      const [backlog, todo, running, review, done] = input.columns;
+      if (!backlog || !todo || !running || !review || !done) {
+        return fail("adopt_managed_lifecycle columns must contain five nonblank ids.");
+      }
+      const board = await adoptManagedLifecycle(projectRoot, input.boardId, {
+        columns: { backlog, todo, running, review, done },
+        actor: input.author,
+        comment: input.transitionComment
+      });
+      return board ? okBoard(board, "Managed lifecycle adopted without moving existing cards.") : fail("Board not found.");
+    }
+    case "release_managed_lifecycle": {
+      if (!input.boardId) return fail("release_managed_lifecycle requires boardId.");
+      const board = await updateBoard(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));
+      return board ? okBoard(board, "Board duplicated.") : fail("Board not found.");
+    }
+    case "delete_board": {
+      if (!input.boardId) return fail("delete_board requires boardId.");
+      const removed = await removeBoard(projectRoot, input.boardId);
+      return { ok: removed, message: removed ? "Board deleted." : "Board not found." };
+    }
+    case "generate_board": {
+      if (!input.description) return fail("generate_board requires description.");
+      const boardInput = createBoardFromText({
+        description: input.description,
+        ...input.title !== void 0 ? { title: input.title } : {},
+        ...input.context !== void 0 ? { context: input.context } : {}
+      });
+      const board = await createBoard(projectRoot, boardInput);
+      for (const tInput of parseLinesIntoTasks(
+        input.description,
+        board.columns[0]?.id ?? "backlog"
+      )) {
+        await addTask(projectRoot, board.id, tInput, eventContext);
+      }
+      return okBoard(await getBoard2(projectRoot, board.id) ?? board, "Board generated.");
+    }
+    case "export_markdown": {
+      const board = await requireBoard(projectRoot, input.boardId);
+      if (!board) return fail("Board not found.");
+      return {
+        ok: true,
+        message: "Board exported.",
+        board,
+        markdown: exportBoardAsMarkdown(board)
+      };
+    }
+    case "export_task_graph": {
+      if (!input.boardId) return fail("export_task_graph requires boardId.");
+      const exported = await exportBoardToTaskGraph(projectRoot, input.boardId, {
+        ...input.graphId !== void 0 ? { graphId: input.graphId } : {},
+        ...input.specId !== void 0 ? { specId: input.specId } : {},
+        ...input.title !== void 0 ? { title: input.title } : {},
+        ...input.preserveOriginTaskIds !== void 0 ? { preserveOriginTaskIds: input.preserveOriginTaskIds } : {},
+        ...input.includeArchived !== void 0 ? { includeArchived: input.includeArchived } : {}
+      });
+      if (!exported) return fail("Board not found.");
+      return {
+        ok: true,
+        message: `Task graph exported with ${exported.graph.nodes.size} node(s).`,
+        board: exported.board,
+        taskGraph: serializeTaskGraph(exported.graph)
+      };
+    }
+    case "sync_task_graph": {
+      if (!input.boardId || !input.taskGraph) {
+        return fail("sync_task_graph requires boardId and taskGraph.");
+      }
+      const graph = deserializeTaskGraph(input.taskGraph);
+      const result = await syncBoardFromTaskGraph(projectRoot, input.boardId, graph, {
+        ...input.title !== void 0 ? { title: input.title } : {},
+        ...input.description !== void 0 ? { description: input.description } : {},
+        ...input.tags !== void 0 ? { tags: input.tags } : {},
+        ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
+        ...input.sourceSystem !== void 0 ? { sourceSystem: input.sourceSystem } : {},
+        ...input.phaseId !== void 0 ? { phaseId: input.phaseId } : {},
+        ...input.includeCompletedTasks !== void 0 ? { includeCompletedTasks: input.includeCompletedTasks } : {},
+        ...input.archiveMissingTasks !== void 0 ? { archiveMissingTasks: input.archiveMissingTasks } : {},
+        ...input.preserveManualDependencies !== void 0 ? { preserveManualDependencies: input.preserveManualDependencies } : {}
+      });
+      return result ? {
+        ok: true,
+        message: `Task graph synced: ${result.createdTaskIds.length} created, ${result.updatedTaskIds.length} updated, ${result.archivedTaskIds.length} archived.`,
+        board: result.board
+      } : fail("Board not found.");
+    }
+    case "create_from_graph": {
+      if (!input.taskGraph) return fail("create_from_graph requires taskGraph.");
+      const graph = deserializeTaskGraph(input.taskGraph);
+      const { board } = await createBoardFromTaskGraph(projectRoot, graph, {
+        ...input.title !== void 0 ? { title: input.title } : {},
+        ...input.description !== void 0 ? { description: input.description } : {},
+        ...input.tags !== void 0 ? { tags: input.tags } : {},
+        ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
+        ...input.sourceSystem !== void 0 ? { sourceSystem: input.sourceSystem } : {},
+        ...input.phaseId !== void 0 ? { phaseId: input.phaseId } : {},
+        ...input.includeCompletedTasks !== void 0 ? { includeCompletedTasks: input.includeCompletedTasks } : {}
+      });
+      return {
+        ok: true,
+        message: `Created board "${board.title}" from task graph with ${board.tasks.length} tasks.`,
+        board
+      };
+    }
+    case "import_session_tasks": {
+      const taskPath = ctx.meta?.["task.path"];
+      if (!taskPath) return fail("No session task file for this session.");
+      const file = await loadTasks(taskPath);
+      if (!file || file.tasks.length === 0) return fail("No session tasks to import.");
+      const sessionId = ctx.session?.id ?? file.sessionId ?? "session";
+      const graph = deserializeTaskGraph(taskFileToSerializedGraph(file.tasks, sessionId));
+      const tags = ["session", `session:${sessionId}`];
+      const existing = (await listBoards(projectRoot)).find(
+        (b) => b.tags?.includes(`session:${sessionId}`)
+      );
+      if (existing) {
+        const result = await syncBoardFromTaskGraph(projectRoot, existing.id, graph, {
+          sourceSystem: "session",
+          tags,
+          archiveMissingTasks: true,
+          includeCompletedTasks: true
+        });
+        return result ? {
+          ok: true,
+          message: `Synced ${file.tasks.length} session tasks into board "${result.board.title}".`,
+          board: result.board
+        } : fail("Session board vanished mid-sync.");
+      }
+      const { board } = await createBoardFromTaskGraph(projectRoot, graph, {
+        title: `Session tasks (${sessionId.slice(0, 8)})`,
+        sourceSystem: "session",
+        tags
+      });
+      return {
+        ok: true,
+        message: `Imported ${file.tasks.length} session tasks into new board "${board.title}".`,
+        board
+      };
+    }
+    case "search_tasks": {
+      const tasks = await searchKanban(projectRoot, {
+        query: input.query,
+        boardId: input.boardId,
+        assignedAgent: input.agentId,
+        status: input.status,
+        priority: input.priority,
+        label: input.labels?.[0],
+        chainId: input.chainId
+      });
+      return { ok: true, message: `${tasks.length} task(s) matched.`, tasks };
+    }
+    case "ready_tasks": {
+      const tasks = await listReadyTasks(projectRoot, {
+        query: input.query,
+        boardId: input.boardId,
+        assignedAgent: input.agentId,
+        priority: input.priority,
+        label: input.labels?.[0],
+        chainId: input.chainId,
+        limit: input.limit
+      });
+      return { ok: true, message: `${tasks.length} ready task(s).`, tasks };
+    }
+    case "snapshot": {
+      const snapshot = await getKanbanOrchestrationSnapshot(projectRoot, {
+        query: input.query,
+        boardId: input.boardId,
+        assignedAgent: input.agentId,
+        status: input.status,
+        priority: input.priority,
+        label: input.labels?.[0],
+        chainId: input.chainId
+      });
+      return {
+        ok: true,
+        message: `${snapshot.ready.length} ready, ${snapshot.running.length} running, ${snapshot.blocked.length} blocked.`,
+        snapshot
+      };
+    }
+    case "events": {
+      if (!input.boardId) return fail("events requires boardId.");
+      const eventList = await listKanbanEvents(projectRoot, input.boardId);
+      return {
+        ok: true,
+        message: `${eventList.length} event(s).`,
+        events: eventList
+      };
+    }
+    case "queue_health": {
+      const health = await getKanbanQueueHealth(projectRoot, {
+        ...input.boardId !== void 0 ? { boardId: input.boardId } : {}
+      });
+      return {
+        ok: true,
+        message: `Counts: startable=${health.counts.startable}, running=${health.counts.running}, stale=${health.staleAssignments.count}.`,
+        queueHealth: health
+      };
+    }
+    default:
+      return void 0;
+  }
+}
+
+// src/kanban-contract-actions.ts
+import {
+  addContractEdge,
+  configureContractGraph,
+  evaluateTaskContractGraph,
+  getContractGraph,
+  removeContractEdge,
+  removeContractNode,
+  upsertContractNode
+} from "@wrongstack/kanban";
+async function handleKanbanContractAction(projectRoot, input, actor, sessionId) {
+  const eventContext = { sessionId, ...actor !== void 0 ? { 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,
+        eventContext
+      );
+      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 } : {}
+        },
+        eventContext
+      );
+      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,
+        eventContext
+      );
+      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 } : {}
+        },
+        eventContext
+      );
+      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,
+        eventContext
+      );
+      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) {
+  const eventContext = {
+    sessionId: ctx.eventSessionId(),
+    ...ctx.agentId !== void 0 ? { actor: ctx.agentId } : {}
+  };
+  switch (input.action) {
+    case "assess_atomicity": {
+      if (!input.boardId || !input.taskId) {
+        return fail("assess_atomicity requires boardId and taskId.");
+      }
+      const result = await assessTaskAtomicity(projectRoot, input.boardId, input.taskId, {
+        assessedBy: "agent",
+        eventContext
+      });
+      if (!result) return fail("Task not found.");
+      const failing = result.assessment.criteria.filter((entry) => entry.score < 1).map((entry) => entry.reason);
+      const guidance = result.assessment.verdict === "needs_decomposition" ? ` This task should be split before dispatch \u2014 call propose_decomposition with 2+ subtasks (each with one verifiable success criterion). Reasons: ${failing.join(" | ")}` : result.assessment.verdict === "composite" ? " Container task: work happens in its children; it is verified via subtask aggregation." : "";
+      return okTask(
+        result.board,
+        result.task,
+        `Atomicity verdict: ${result.assessment.verdict} (score ${result.assessment.score}).${guidance}`
+      );
+    }
+    case "propose_decomposition": {
+      if (!input.boardId || !input.taskId || !input.subtasks?.length) {
+        return fail("propose_decomposition requires boardId, taskId, and subtasks (2+).");
+      }
+      if (input.subtasks.length < 2) {
+        return fail("propose_decomposition requires at least two subtasks.");
+      }
+      const invalid = input.subtasks.find(
+        (subtask) => typeof subtask?.title !== "string" || !subtask.title.trim()
+      );
+      if (invalid) return fail("Every proposed subtask needs a non-blank title.");
+      const result = await proposeTaskDecomposition(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        {
+          subtasks: input.subtasks,
+          ...input.note !== void 0 ? { rationale: input.note } : {},
+          ...ctx.agentId !== void 0 ? { proposedBy: ctx.agentId } : {}
+        },
+        eventContext
+      );
+      if (!result) return fail("Task not found.");
+      const message = result.proposal.status === "applied" ? `Decomposition applied: ${result.proposal.appliedChildTaskIds?.length ?? 0} child tasks created (parent marked atomic).` : 'Decomposition proposal recorded \u2014 awaiting approval (board policy is "propose"). It can be approved from the WebUI or via update_task.';
+      return okTask(result.board, result.task, message);
+    }
+    case "verify_completion": {
+      if (!input.boardId || !input.taskId) {
+        return fail("verify_completion requires boardId and taskId.");
+      }
+      const verResult = await verifyTaskCompletion(projectRoot, input.boardId, input.taskId);
+      const persistedBoard = await updateTask(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        {
+          verificationReport: verResult.report,
+          successCriteria: verResult.task.successCriteria
+        },
+        eventContext
+      );
+      if (!persistedBoard) {
+        return {
+          ok: false,
+          verdict: verResult.report.verdict,
+          message: `Verification succeeded but persist failed: ${verResult.report.markdownSummary}. Board may be stale \u2014 re-run verify_completion.`,
+          board: verResult.board
+        };
+      }
+      recordKanbanVerificationEvidence(ctx, verResult.report);
+      const freshTask = persistedBoard.tasks?.find((t) => t.id === input.taskId);
+      const deterministicVerdicts = ["passed", "failed", "needs_human", "incomplete"];
+      return {
+        ok: deterministicVerdicts.includes(
+          verResult.report.verdict
+        ),
+        verdict: verResult.report.verdict,
+        message: verResult.report.markdownSummary,
+        board: persistedBoard,
+        task: freshTask ?? verResult.task
+      };
+    }
+    default:
+      return void 0;
+  }
+}
+
+// src/kanban-detail-actions.ts
+import {
+  addCheckToTask,
+  addDependency,
+  addGoalMetricToTask,
+  addLinkToTask,
+  addNoteToTask,
+  getKanbanWorkbench,
+  removeCheckFromTask,
+  updateCheckOnTask,
+  updateGoalMetricOnTask
+} from "@wrongstack/kanban";
+async function handleKanbanDetailAction(projectRoot, input, ctx) {
+  const eventContext = {
+    sessionId: ctx.eventSessionId(),
+    ...ctx.agentId !== void 0 ? { actor: ctx.agentId } : {}
+  };
+  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.");
+      }
+      const board = await addDependency(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        input.dependencyTaskId,
+        eventContext
+      );
+      return board ? okBoard(board, "Dependency added.") : fail("Task not found.");
+    }
+    case "add_goal_metric": {
+      if (!input.boardId || !input.taskId || !input.metricName) {
+        return fail("add_goal_metric requires boardId, taskId, and metricName.");
+      }
+      const board = await addGoalMetricToTask(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        {
+          name: input.metricName,
+          ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
+          ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
+          ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
+          ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
+          ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
+        },
+        eventContext
+      );
+      return board ? okBoard(board, "Goal metric added.") : fail("Task not found.");
+    }
+    case "update_goal_metric": {
+      if (!input.boardId || !input.taskId || !input.metricId) {
+        return fail("update_goal_metric requires boardId, taskId, and metricId.");
+      }
+      const board = await updateGoalMetricOnTask(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        input.metricId,
+        {
+          ...input.metricName !== void 0 ? { name: input.metricName } : {},
+          ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
+          ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
+          ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
+          ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
+          ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
+        },
+        eventContext
+      );
+      return board ? okBoard(board, "Goal metric updated.") : fail("Metric not found.");
+    }
+    case "add_check": {
+      if (!input.boardId || !input.taskId || !input.checkDescription) {
+        return fail("add_check requires boardId, taskId, and checkDescription.");
+      }
+      const board = await addCheckToTask(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        {
+          description: input.checkDescription,
+          type: input.checkType ?? "manual",
+          status: input.checkStatus,
+          ...input.checkNotes !== void 0 ? { notes: input.checkNotes } : {}
+        },
+        eventContext
+      );
+      return board ? okBoard(board, "Check added.") : fail("Task not found.");
+    }
+    case "update_check": {
+      if (!input.boardId || !input.taskId || !input.checkId) {
+        return fail("update_check requires boardId, taskId, and checkId.");
+      }
+      const board = await updateCheckOnTask(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        input.checkId,
+        {
+          ...input.checkDescription !== void 0 ? { description: input.checkDescription } : {},
+          ...input.checkStatus !== void 0 ? { status: input.checkStatus } : {},
+          // 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 } : {}
+        },
+        eventContext
+      );
+      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,
+        eventContext
+      );
+      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.");
+      const board = await addNoteToTask(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        {
+          author: input.author ?? "agent",
+          content: input.note
+        },
+        eventContext
+      );
+      return board ? okBoard(board, "Note added.") : fail("Task not found.");
+    }
+    case "add_link": {
+      if (!input.boardId || !input.taskId || !input.url)
+        return fail("add_link requires boardId, taskId, and url.");
+      const board = await addLinkToTask(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        {
+          url: input.url,
+          type: input.linkType ?? "url",
+          ...input.linkTitle !== void 0 ? { title: input.linkTitle } : {}
+        },
+        eventContext
+      );
+      return board ? okBoard(board, "Link added.") : fail("Task not found.");
+    }
+    case "split_atomic": {
+      if (!input.boardId || !input.taskId || !input.childTitles?.length) {
+        return fail("split_atomic requires boardId, taskId, and childTitles (at least one).");
+      }
+      return handleSplitTask(projectRoot, input, { atomic: true }, eventContext);
+    }
+    default:
+      return void 0;
+  }
+}
+
+// src/kanban-lifecycle-actions.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import {
+  addTask as addTask2,
+  assignTask,
+  claimReadyTask,
+  copyTaskToBoard,
+  evaluateContractGraphReadiness,
+  finalizeTaskCompletion,
+  getBoard as getBoard3,
+  getTask,
+  getTaskChain,
+  heartbeatTaskAssignment,
+  mergeTasks,
+  moveTask,
+  recoverStaleTaskAssignments,
+  releaseTaskClaim,
+  removeTask,
+  repairManagedTaskProjection,
+  resolveAutoAccept,
+  setTaskChain,
+  stripLifecycleIssues,
+  transferTaskToBoard,
+  transitionTask,
+  updateTask as updateTask2,
+  updateTaskAssignment,
+  verifyTaskCompletion as verifyTaskCompletion2
+} from "@wrongstack/kanban";
+
+// src/kanban-task-inputs.ts
+import { randomUUID } from "node:crypto";
+import { clampSubagentCapabilities } from "@wrongstack/core/security";
+function taskInput(input) {
+  const assignment = hasAssignmentInput(input) ? assignmentForTaskCreate(input) : void 0;
+  return {
+    title: input.title ?? "",
+    columnId: input.columnId,
+    description: input.description,
+    dueDate: input.dueDate,
+    priority: input.priority,
+    ...input.taskType !== void 0 ? { type: input.taskType } : {},
+    status: input.status,
+    labels: input.labels,
+    ...assignment?.agentId ?? assignment?.role ?? assignment?.name ? { assignedAgent: assignment.agentId ?? assignment.role ?? assignment.name } : {},
+    ...input.assignee ?? assignment?.name ?? assignment?.agentId ? { assignee: input.assignee ?? assignment?.name ?? assignment?.agentId } : {},
+    ...mergedDependsOn(input) ? { dependsOn: mergedDependsOn(input) } : {},
+    ...input.estimatedHours !== void 0 ? { estimatedHours: input.estimatedHours } : {},
+    ...input.actualHours !== void 0 ? { actualHours: input.actualHours } : {},
+    ...assignment ? { assignment } : {},
+    ...input.order !== void 0 ? { order: input.order } : {},
+    ...input.retryPolicy !== void 0 ? { retryPolicy: input.retryPolicy } : {},
+    ...input.costCeilingUsd !== void 0 ? { costCeilingUsd: input.costCeilingUsd } : {},
+    // 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,
+          // `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 } : {}
+        }
+      ]
+    } : {},
+    ...input.metricName !== void 0 ? {
+      goalMetrics: [
+        {
+          id: randomUUID(),
+          name: input.metricName,
+          status: input.metricStatus ?? "pending",
+          ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
+          ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
+          ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
+          ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
+        }
+      ]
+    } : {},
+    ...input.url !== void 0 ? {
+      links: [
+        {
+          url: input.url,
+          type: input.linkType ?? "url",
+          ...input.linkTitle !== void 0 ? { title: input.linkTitle } : {}
+        }
+      ]
+    } : {},
+    ...input.note !== void 0 ? {
+      notes: [
+        {
+          id: randomUUID(),
+          author: input.author ?? "agent",
+          content: input.note,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      ]
+    } : {},
+    ...[input.graphId, input.specId, input.specRequirementId].some((value) => value !== void 0) ? {
+      origin: {
+        system: input.sourceSystem ?? "kanban-tool",
+        ...input.graphId !== void 0 ? { graphId: input.graphId } : {},
+        ...input.specId !== void 0 ? { specId: input.specId } : {},
+        ...input.specRequirementId !== void 0 ? { specRequirementId: input.specRequirementId } : {},
+        ...input.phaseId !== void 0 ? { phaseId: input.phaseId } : {}
+      }
+    } : {}
+  };
+}
+function mergedDependsOn(input) {
+  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);
+}
+function taskPatch(input) {
+  return {
+    title: input.title,
+    description: input.description,
+    dueDate: input.dueDate,
+    columnId: input.columnId,
+    order: input.order,
+    priority: input.priority,
+    ...input.taskType !== void 0 ? { type: input.taskType } : {},
+    status: input.status,
+    labels: input.labels,
+    assignedAgent: input.agentId,
+    ...mergedDependsOn(input) !== 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 } : {}
+  };
+}
+function clampRequestedCapabilities(requested) {
+  if (requested === void 0) return void 0;
+  return clampSubagentCapabilities(requested).granted;
+}
+function assignmentInput(input) {
+  return {
+    agentId: input.agentId,
+    name: input.name,
+    role: input.role,
+    provider: input.provider,
+    model: input.model,
+    fallbackProfile: input.fallbackProfile,
+    fallbackModels: input.fallbackModels,
+    tools: input.tools,
+    allowedCapabilities: clampRequestedCapabilities(input.allowedCapabilities),
+    assignee: input.assignee,
+    leaseId: input.leaseId,
+    claimedAt: input.claimedAt,
+    heartbeatAt: input.heartbeatAt,
+    leaseExpiresAt: input.leaseExpiresAt,
+    attempt: input.attempt,
+    maxAttempts: input.maxAttempts,
+    costCeilingUsd: input.costCeilingUsd,
+    retryPolicy: input.retryPolicy,
+    lastFailureKind: input.lastFailureKind
+  };
+}
+function hasAssignmentInput(input) {
+  return input.agentId !== void 0 || input.name !== void 0 || input.role !== void 0 || input.provider !== void 0 || input.model !== void 0 || input.fallbackProfile !== void 0 || input.fallbackModels !== void 0 || input.tools !== void 0 || input.allowedCapabilities !== void 0 || input.assignee !== void 0 || input.leaseId !== void 0 || input.claimedAt !== void 0 || input.heartbeatAt !== void 0 || input.leaseExpiresAt !== void 0 || input.attempt !== void 0 || input.maxAttempts !== void 0 || input.costCeilingUsd !== void 0 || input.retryPolicy !== void 0 || input.lastFailureKind !== void 0 || input.assignmentStatus !== void 0;
+}
+function assignmentForTaskCreate(input) {
+  return {
+    status: input.assignmentStatus ?? "assigned",
+    ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
+    ...input.name !== void 0 ? { name: input.name } : {},
+    ...input.role !== void 0 ? { role: input.role } : {},
+    ...input.provider !== void 0 ? { provider: input.provider } : {},
+    ...input.model !== void 0 ? { model: input.model } : {},
+    ...input.fallbackProfile !== void 0 ? { fallbackProfile: input.fallbackProfile } : {},
+    ...input.fallbackModels !== void 0 ? { fallbackModels: input.fallbackModels } : {},
+    ...input.tools !== void 0 ? { tools: input.tools } : {},
+    ...input.allowedCapabilities !== void 0 ? { allowedCapabilities: clampRequestedCapabilities(input.allowedCapabilities) } : {},
+    ...input.leaseId !== void 0 ? { leaseId: input.leaseId } : {},
+    ...input.claimedAt !== void 0 ? { claimedAt: input.claimedAt } : {},
+    ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
+    ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
+    ...input.attempt !== void 0 ? { attempt: input.attempt } : {},
+    ...input.maxAttempts !== void 0 ? { maxAttempts: input.maxAttempts } : {},
+    ...input.costCeilingUsd !== void 0 ? { costCeilingUsd: input.costCeilingUsd } : {},
+    ...input.retryPolicy !== void 0 ? { retryPolicy: input.retryPolicy } : {},
+    ...input.lastFailureKind !== void 0 ? { lastFailureKind: input.lastFailureKind } : {}
+  };
+}
+
+// src/kanban-lifecycle-actions.ts
+async function syncContextTask(ctx, task, options = {}) {
+  if (!ctx?.state || !task) return;
+  try {
+    await applySessionKanbanTaskToSource(ctx, task, options);
+  } catch {
+  }
+}
+async function handleKanbanLifecycleAction(projectRoot, input, ctx) {
+  const eventContext = {
+    sessionId: ctx.eventSessionId(),
+    ...ctx.agentId !== void 0 ? { actor: ctx.agentId } : {}
+  };
+  switch (input.action) {
+    case "add_task": {
+      if (!input.boardId || !input.title) return fail("add_task requires boardId and title.");
+      const result = await addTask2(projectRoot, input.boardId, taskInput(input), eventContext);
+      if (!result) return fail("Board not found.");
+      await syncContextTask(ctx, result.task);
+      return okTask(result.board, result.task, `Task added.${atomicityNudge(result.task)}`);
+    }
+    case "split_task": {
+      if (!input.boardId || !input.taskId || !input.childTitles?.length) {
+        return fail("split_task requires boardId, taskId, and childTitles.");
+      }
+      return handleSplitTask(projectRoot, input, {}, eventContext);
+    }
+    case "merge_tasks": {
+      if (!input.boardId || !input.taskIds?.length || !input.title) {
+        return fail("merge_tasks requires boardId, taskIds, and title.");
+      }
+      const result = await mergeTasks(
+        projectRoot,
+        input.boardId,
+        {
+          taskIds: input.taskIds,
+          title: input.title,
+          ...input.description !== void 0 ? { description: input.description } : {},
+          ...input.targetColumnId !== void 0 ? { targetColumnId: input.targetColumnId } : {},
+          ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {},
+          ...input.closeSourceTasks !== void 0 ? { closeSourceTasks: input.closeSourceTasks } : {}
+        },
+        eventContext
+      );
+      return result ? okTask(result.board, result.task, "Tasks merged.") : fail("Board or task not found.");
+    }
+    case "copy_task": {
+      if (!input.boardId || !input.taskId || !input.targetBoardId) {
+        return fail("copy_task requires boardId, taskId, and targetBoardId.");
+      }
+      const result = await copyTaskToBoard(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        input.targetBoardId,
+        {
+          ...input.targetColumnId !== void 0 ? { targetColumnId: input.targetColumnId } : {},
+          ...input.order !== void 0 ? { targetOrder: input.order } : {},
+          ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {},
+          ...input.preserveDependencies !== void 0 ? { preserveDependencies: input.preserveDependencies } : {},
+          eventContext
+        }
+      );
+      return result ? okTask(result.targetBoard, result.task, "Task copied to target board.") : fail("Board or task not found.");
+    }
+    case "transfer_task": {
+      if (!input.boardId || !input.taskId || !input.targetBoardId) {
+        return fail("transfer_task requires boardId, taskId, and targetBoardId.");
+      }
+      const result = await transferTaskToBoard(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        input.targetBoardId,
+        {
+          ...input.targetColumnId !== void 0 ? { targetColumnId: input.targetColumnId } : {},
+          ...input.order !== void 0 ? { targetOrder: input.order } : {},
+          ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {},
+          ...input.preserveDependencies !== void 0 ? { preserveDependencies: input.preserveDependencies } : {},
+          eventContext
+        }
+      );
+      return result ? okTask(result.targetBoard, result.task, "Task transferred to target board.") : fail("Board or task not found.");
+    }
+    case "get_task": {
+      if (!input.boardId || !input.taskId) return fail("get_task requires boardId and taskId.");
+      const task = await getTask(projectRoot, input.boardId, input.taskId);
+      return task ? { ok: true, message: "Task loaded.", task } : fail("Task not found.");
+    }
+    case "start_task": {
+      if (!input.boardId || !input.taskId || !input.author || !input.transitionComment) {
+        return fail("start_task requires boardId, taskId, author, and transitionComment.");
+      }
+      let board = await getBoard3(projectRoot, input.boardId);
+      let task = board?.tasks.find((candidate) => candidate.id === input.taskId);
+      if (!board || !task) return fail("Board or task not found.");
+      const readiness = evaluateContractGraphReadiness(board, task.id);
+      if (!readiness.ready) {
+        return fail(
+          `Task is not implementation-ready: ${readiness.issues.map((issue) => issue.message).join(" | ")}`
+        );
+      }
+      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
+          },
+          eventContext
+        );
+        if (!assigned) return fail("Task assignment could not be started.");
+        const started = await updateTask2(
+          projectRoot,
+          board.id,
+          task.id,
+          { status: "in_progress" },
+          eventContext
+        );
+        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",
+          sessionId: eventContext.sessionId,
+          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
+          },
+          eventContext
+        );
+        if (!assigned) return fail("Task assignment could not be started.");
+        const moved = await transitionTask(projectRoot, board.id, task.id, {
+          to: "running",
+          sessionId: eventContext.sessionId,
+          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);
+      await syncContextTask(ctx, task);
+      return okTask(
+        board,
+        task,
+        "Task is active; runtime Kanban governance is now bound to this run."
+      );
+    }
+    case "update_task": {
+      if (!input.boardId || !input.taskId) return fail("update_task requires boardId and taskId.");
+      const board = await updateTask2(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        taskPatch(input),
+        eventContext
+      );
+      if (board) {
+        await syncContextTask(
+          ctx,
+          board.tasks.find((t) => t.id === input.taskId)
+        );
+      }
+      return board ? okBoard(board, "Task updated.") : fail("Task not found.");
+    }
+    case "transition_task": {
+      if (!input.boardId || !input.taskId || !input.lifecycleStage || !input.author || !input.transitionComment) {
+        return fail(
+          "transition_task requires boardId, taskId, lifecycleStage, author, and transitionComment."
+        );
+      }
+      if (input.lifecycleStage === "done") {
+        const boardBefore = await getBoard3(projectRoot, input.boardId);
+        const taskBefore = boardBefore ? await getTask(projectRoot, input.boardId, input.taskId) : null;
+        if (boardBefore && taskBefore && !taskBefore.verificationReport && (taskBefore.atomic || Boolean(taskBefore.successCriteria?.length))) {
+          const preGate = await verifyTaskCompletion2(projectRoot, input.boardId, taskBefore.id, {
+            persist: false
+          });
+          await updateTask2(
+            projectRoot,
+            input.boardId,
+            taskBefore.id,
+            {
+              verificationReport: preGate.report,
+              successCriteria: preGate.task.successCriteria
+            },
+            eventContext
+          );
+        }
+      }
+      const result = await transitionTask(projectRoot, input.boardId, input.taskId, {
+        to: input.lifecycleStage,
+        sessionId: eventContext.sessionId,
+        actor: input.author,
+        comment: input.transitionComment,
+        ...input.transitionAction !== void 0 ? { action: input.transitionAction } : {},
+        ...input.tickChecks !== void 0 ? { tickChecks: input.tickChecks } : {},
+        ...input.attachmentUrl !== void 0 ? {
+          attachment: {
+            url: input.attachmentUrl,
+            type: input.attachmentType ?? "url",
+            ...input.attachmentTitle !== void 0 ? { title: input.attachmentTitle } : {}
+          }
+        } : {},
+        patch: taskPatch(input)
+      });
+      if (result && input.lifecycleStage === "done" && result.task.verificationReport) {
+        recordKanbanVerificationEvidence(ctx, result.task.verificationReport);
+      }
+      if (result?.task) {
+        await syncContextTask(ctx, result.task);
+      }
+      return result ? okTask(result.board, result.task, `Task advanced to ${result.transition.to}.`) : fail("Board or task not found.");
+    }
+    case "repair_managed_projection": {
+      if (!input.boardId || !input.taskId || !input.author || !input.transitionComment) {
+        return fail(
+          "repair_managed_projection requires boardId, taskId, author, and transitionComment."
+        );
+      }
+      const result = await repairManagedTaskProjection(projectRoot, input.boardId, input.taskId, {
+        actor: input.author,
+        comment: input.transitionComment
+      });
+      if (result?.task) {
+        await syncContextTask(ctx, result.task);
+      }
+      return result ? okTask(
+        result.board,
+        result.task,
+        "Managed card projection repaired from lifecycle history."
+      ) : fail("Board or task not found.");
+    }
+    case "move_task": {
+      if (!input.boardId || !input.taskId || !input.targetColumnId) {
+        return fail("move_task requires boardId, taskId, and targetColumnId.");
+      }
+      const board = await moveTask(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        input.targetColumnId,
+        input.order,
+        eventContext
+      );
+      if (board) {
+        await syncContextTask(
+          ctx,
+          board.tasks.find((t) => t.id === input.taskId)
+        );
+      }
+      return board ? okBoard(board, "Task moved.") : fail("Move failed.");
+    }
+    case "delete_task": {
+      if (!input.boardId || !input.taskId) return fail("delete_task requires boardId and taskId.");
+      const boardBefore = await getBoard3(projectRoot, input.boardId);
+      const taskToDelete = boardBefore?.tasks.find((t) => t.id === input.taskId);
+      const board = await removeTask(projectRoot, input.boardId, input.taskId, eventContext);
+      if (board && ctx.currentKanbanTaskId === input.taskId) {
+        ctx.setCurrentKanbanTask?.(void 0, ctx.currentKanbanBoardId);
+      }
+      if (board && taskToDelete) {
+        await syncContextTask(ctx, taskToDelete, { remove: true });
+      }
+      return board ? okBoard(board, "Task deleted.") : fail("Task not found.");
+    }
+    case "set_chain": {
+      if (!input.boardId || !input.taskIds?.length) {
+        return fail("set_chain requires boardId and taskIds.");
+      }
+      const result = await setTaskChain(
+        projectRoot,
+        input.boardId,
+        {
+          taskIds: input.taskIds,
+          ...input.chainId !== void 0 ? { chainId: input.chainId } : {},
+          ...input.enforceDependencies !== void 0 ? { enforceDependencies: input.enforceDependencies } : {}
+        },
+        eventContext
+      );
+      return result ? {
+        ok: true,
+        message: `Chain set: ${result.chainId}`,
+        board: result.board,
+        chain: result.tasks
+      } : fail("Board or task not found.");
+    }
+    case "get_chain": {
+      if (!input.boardId || !(input.taskId || input.chainId)) {
+        return fail("get_chain requires boardId and taskId or chainId.");
+      }
+      const result = await getTaskChain(
+        projectRoot,
+        input.boardId,
+        input.taskId ?? input.chainId ?? ""
+      );
+      return result ? {
+        ok: true,
+        message: `Chain loaded: ${result.chainId}`,
+        board: result.board,
+        chain: result.tasks
+      } : fail("Chain not found.");
+    }
+    case "claim_task": {
+      const result = await claimReadyTask(
+        projectRoot,
+        {
+          ...input.boardId !== void 0 ? { boardId: input.boardId } : {},
+          ...input.taskId !== void 0 ? { taskId: input.taskId } : {},
+          ...assignmentInput(input),
+          status: input.assignmentStatus ?? "queued"
+        },
+        eventContext
+      );
+      return result ? okTask(result.board, result.task, "Task claimed.") : fail("No ready kanban task matched the claim.");
+    }
+    case "release_task": {
+      if (!input.boardId || !input.taskId) {
+        return fail("release_task requires boardId and taskId.");
+      }
+      const board = await releaseTaskClaim(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        {
+          ...input.releaseStatus !== void 0 ? { status: input.releaseStatus } : {},
+          ...input.releaseReason !== void 0 ? { reason: input.releaseReason } : {},
+          ...input.clearAssignee !== void 0 ? { clearAssignee: input.clearAssignee } : {}
+        },
+        eventContext
+      );
+      return board ? okBoard(board, "Task claim released.") : fail("Task not found.");
+    }
+    case "assign_task": {
+      if (!input.boardId || !input.taskId) return fail("assign_task requires boardId and taskId.");
+      const board = await assignTask(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        assignmentInput(input),
+        eventContext
+      );
+      return board ? okBoard(board, "Task assigned.") : fail("Task not found.");
+    }
+    case "mark_assignment": {
+      if (!input.boardId || !input.taskId)
+        return fail("mark_assignment requires boardId and taskId.");
+      const assignmentStatus = input.assignmentStatus ?? (input.status === "completed" ? "completed" : input.error ? "failed" : void 0);
+      const board = await updateTaskAssignment(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        {
+          ...assignmentStatus !== void 0 ? { status: assignmentStatus } : {},
+          ...input.subagentId !== void 0 ? { subagentId: input.subagentId } : {},
+          ...input.runTaskId !== void 0 ? { runTaskId: input.runTaskId } : {},
+          ...input.lastResult !== void 0 ? { lastResult: input.lastResult } : {},
+          ...input.error !== void 0 ? { error: input.error } : {},
+          ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
+          ...input.leaseId !== void 0 ? { leaseId: input.leaseId } : {},
+          ...input.claimedAt !== void 0 ? { claimedAt: input.claimedAt } : {},
+          ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
+          ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
+          ...input.attempt !== void 0 ? { attempt: input.attempt } : {},
+          ...input.maxAttempts !== void 0 ? { maxAttempts: input.maxAttempts } : {}
+        },
+        {
+          ...eventContext,
+          ...input.expectedLeaseId !== void 0 ? { expectedLeaseId: input.expectedLeaseId } : {}
+        }
+      );
+      if (!board) return fail("Task not found.");
+      if (assignmentStatus === "completed" && board.lifecycle?.mode !== "managed") {
+        const envGate = readEnvGateEnforcement();
+        const finalized = await finalizeTaskCompletion(projectRoot, board.id, input.taskId, {
+          ...board.completionGate === void 0 && envGate !== void 0 ? { enforcement: envGate } : {},
+          eventContext
+        });
+        if (finalized) {
+          if (finalized.gate.report) {
+            recordKanbanVerificationEvidence(ctx, finalized.gate.report);
+          }
+          const gateSummary = {
+            enforcement: finalized.gate.enforcement,
+            allowed: finalized.gate.allowed,
+            verdict: finalized.gate.verdict,
+            issues: finalized.gate.issues.map((issue) => issue.message)
+          };
+          const gateMessage = finalized.gate.allowed ? `Completion gate ${finalized.gate.verdict === "skipped" ? "passed" : "passed"}; task completed.` : finalized.gate.enforcement === "strict" ? `Completion gate BLOCKED (verdict: ${finalized.gate.verdict}); task parked in review. Issues: ${gateSummary.issues.join(" | ")}` : `Completion gate failed softly (verdict: ${finalized.gate.verdict}); task completed with warnings. Issues: ${gateSummary.issues.join(" | ")}`;
+          await syncContextTask(ctx, finalized.task);
+          return {
+            ...okTask(finalized.board, finalized.task, `Assignment updated. ${gateMessage}`),
+            gate: gateSummary
+          };
+        }
+      } else if (board.lifecycle?.mode === "managed") {
+        const managedTask = board.tasks.find((candidate) => candidate.id === input.taskId);
+        const stage = managedTask?.lifecycle?.currentStage;
+        const actor = ctx.agentId ?? "kanban-agent";
+        let transitionResult = null;
+        const lifecycleWarnings = [];
+        if (assignmentStatus === "running" && stage === "todo") {
+          try {
+            transitionResult = await transitionTask(projectRoot, board.id, input.taskId, {
+              to: "running",
+              sessionId: eventContext.sessionId,
+              actor,
+              comment: "Work started."
+            });
+          } catch (err) {
+            lifecycleWarnings.push(
+              `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",
+              sessionId: eventContext.sessionId,
+              actor,
+              comment,
+              attachment: {
+                url: `kanban://task/${input.taskId}/result`,
+                title: "Worker completion result",
+                type: "file"
+              },
+              patch: {
+                ...input.agentId !== void 0 ? { assignedAgent: input.agentId } : {}
+              }
+            });
+          } catch (err) {
+            lifecycleWarnings.push(
+              `Lifecycle transition to Review failed: ${stripLifecycleIssues(err instanceof Error ? err.message : String(err))}`
+            );
+          }
+          if (transitionResult) {
+            const hasCriteria = (transitionResult.task.successCriteria?.length ?? 0) > 0 || transitionResult.task.atomic === true;
+            if (hasCriteria) {
+              try {
+                const verResult = await verifyTaskCompletion2(projectRoot, board.id, input.taskId);
+                if (verResult.report) {
+                  recordKanbanVerificationEvidence(ctx, verResult.report);
+                }
+                await updateTask2(
+                  projectRoot,
+                  board.id,
+                  input.taskId,
+                  {
+                    verificationReport: verResult.report,
+                    successCriteria: verResult.task.successCriteria
+                  },
+                  eventContext
+                );
+                const verdict = verResult.report.verdict;
+                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, board.id, input.taskId, {
+                      to: "done",
+                      sessionId: eventContext.sessionId,
+                      actor,
+                      action: "Automated acceptance after verification",
+                      comment: "Auto-accepted: verification passed.",
+                      attachment: {
+                        url: `kanban://task/${input.taskId}/verification`,
+                        title: "Auto-verification result",
+                        type: "file"
+                      }
+                    });
+                    transitionResult = doneResult;
+                  } catch (acceptErr) {
+                    lifecycleWarnings.push(
+                      `Auto-accept to Done deferred: ${acceptErr instanceof Error ? acceptErr.message : String(acceptErr)}`
+                    );
+                  }
+                } else {
+                  lifecycleWarnings.push(
+                    `Verification verdict: ${verdict} \u2014 card left in Review for manual acceptance.`
+                  );
+                }
+              } catch (verifyErr) {
+                lifecycleWarnings.push(
+                  `Auto-verification error: ${verifyErr instanceof Error ? verifyErr.message : String(verifyErr)}`
+                );
+              }
+            } else {
+              lifecycleWarnings.push(
+                "No automatic success criteria \u2014 card left in Review for manual verification."
+              );
+            }
+          }
+        }
+        const responseBoard = transitionResult?.board ?? board;
+        const responseTask = transitionResult?.task ?? managedTask;
+        const msgParts = ["Assignment updated."];
+        if (transitionResult) {
+          msgParts.push(`Card advanced to ${transitionResult.transition.to}.`);
+        }
+        for (const w of lifecycleWarnings) msgParts.push(`Warning: ${w}`);
+        await syncContextTask(ctx, responseTask);
+        return okTask(responseBoard, responseTask, msgParts.join(" "));
+      }
+      return okBoard(board, "Assignment updated.");
+    }
+    case "heartbeat_assignment": {
+      if (!input.boardId || !input.taskId) {
+        return fail("heartbeat_assignment requires boardId and taskId.");
+      }
+      const board = await heartbeatTaskAssignment(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        {
+          ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
+          ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
+          ...input.expectedLeaseId !== void 0 ? { expectedLeaseId: input.expectedLeaseId } : {}
+        },
+        eventContext
+      );
+      return board ? okBoard(board, "Assignment heartbeat updated.") : fail("Task assignment not found.");
+    }
+    case "recover_stale": {
+      if (!input.boardId) return fail("recover_stale requires boardId.");
+      const policyFields = [
+        input.recoveryPolicyFailOnCostCeiling !== void 0,
+        input.recoveryPolicyReleaseOnFailureKinds !== void 0,
+        input.recoveryPolicyReleaseOnHeartbeatDue !== void 0,
+        input.recoveryPolicyRetryPolicyOverride !== void 0
+      ].some(Boolean);
+      const result = await recoverStaleTaskAssignments(
+        projectRoot,
+        input.boardId,
+        {
+          ...input.recoveryMode !== void 0 ? { mode: input.recoveryMode } : {},
+          ...input.recoveryNow !== void 0 ? { now: input.recoveryNow } : {},
+          ...input.releaseReason !== void 0 ? { reason: input.releaseReason } : {},
+          ...input.clearAssignee !== void 0 ? { clearAssignee: input.clearAssignee } : {},
+          ...policyFields ? {
+            policy: {
+              ...input.recoveryPolicyFailOnCostCeiling !== void 0 ? { failWhenCostCeilingSet: input.recoveryPolicyFailOnCostCeiling } : {},
+              ...input.recoveryPolicyReleaseOnFailureKinds !== void 0 ? {
+                releaseOnFailureKinds: input.recoveryPolicyReleaseOnFailureKinds
+              } : {},
+              ...input.recoveryPolicyReleaseOnHeartbeatDue !== void 0 ? {
+                releaseOnHeartbeatDue: input.recoveryPolicyReleaseOnHeartbeatDue
+              } : {},
+              ...input.recoveryPolicyRetryPolicyOverride !== void 0 ? {
+                retryPolicyOverride: input.recoveryPolicyRetryPolicyOverride
+              } : {}
+            }
+          } : {}
+        },
+        eventContext
+      );
+      return result ? {
+        ok: true,
+        message: `Recovered ${result.tasks.length} stale assignment(s).`,
+        board: result.board,
+        recoveredTasks: result.tasks
+      } : { ok: true, message: "No stale assignment matched.", recoveredTasks: [] };
+    }
+    default:
+      return void 0;
+  }
+}
+
+// src/kanban-presence.ts
+import { touchKanbanPresence } from "@wrongstack/kanban";
+function createKanbanPresenceWrapper(projectRoot, input, ctx) {
+  return async (result) => {
+    const boardId = result.board?.id ?? input.boardId;
+    if (!result.ok || !boardId || !ctx.session?.id || !ctx.agentId) return result;
+    try {
+      const board = await touchKanbanPresence(projectRoot, boardId, {
+        sessionId: ctx.session.id,
+        agentId: ctx.agentId,
+        agentName: ctx.agentName,
+        taskId: input.taskId ?? result.task?.id,
+        runTaskId: input.runTaskId
+      });
+      return board ? { ...result, board } : result;
+    } catch {
+      return result;
+    }
+  };
+}
+
+// src/kanban-serializer.ts
+var KANBAN_BOARD_TRANSCRIPT_BYTE_CAP = 16384;
+var KANBAN_FULL_BOARD_ACTIONS = /* @__PURE__ */ new Set([
+  "get_board",
+  "export_markdown",
+  "export_task_graph"
+]);
+function serializeKanbanOutput(output, input) {
+  const action = input && typeof input === "object" ? input.action : void 0;
+  const board = output.board;
+  if (board) {
+    const keepFull = typeof action === "string" && KANBAN_FULL_BOARD_ACTIONS.has(action);
+    let boardBytes = 0;
+    if (!keepFull) {
+      try {
+        boardBytes = Buffer.byteLength(JSON.stringify(board), "utf8");
+      } catch {
+        boardBytes = 0;
+      }
+    }
+    if (!keepFull && boardBytes > KANBAN_BOARD_TRANSCRIPT_BYTE_CAP) {
+      const columns = {};
+      for (const column of board.columns) {
+        columns[column.title || column.id] = board.tasks.filter(
+          (task) => task.columnId === column.id
+        ).length;
+      }
+      const compact = {
+        ...output,
+        board: {
+          id: board.id,
+          title: board.title,
+          columns,
+          totalTasks: board.tasks.length,
+          note: `Full board (${boardBytes} bytes) omitted from the transcript; use get_board to load it.`
+        }
+      };
+      return JSON.stringify(compact, null, 2);
+    }
+  }
+  return JSON.stringify(output, null, 2);
+}
+
+// src/kanban-tool-schema.ts
+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. Goal metrics pass when current >= target by default; when lower is better (error rate, cost ceiling, latency, open-bug count), pass metricDirection "at_most" with add_goal_metric / update_goal_metric so verification compares current <= target instead.';
+var KANBAN_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      enum: [
+        "list_boards",
+        "get_board",
+        "create_board",
+        "duplicate_board",
+        "update_board",
+        "adopt_managed_lifecycle",
+        "release_managed_lifecycle",
+        "delete_board",
+        "generate_board",
+        "export_markdown",
+        "export_task_graph",
+        "sync_task_graph",
+        "create_from_graph",
+        "import_session_tasks",
+        "search_tasks",
+        "ready_tasks",
+        "snapshot",
+        "workbench",
+        "add_task",
+        "split_task",
+        "merge_tasks",
+        "copy_task",
+        "transfer_task",
+        "get_task",
+        "start_task",
+        "update_task",
+        "transition_task",
+        "repair_managed_projection",
+        "move_task",
+        "delete_task",
+        "set_chain",
+        "get_chain",
+        "claim_task",
+        "release_task",
+        "assign_task",
+        "mark_assignment",
+        "heartbeat_assignment",
+        "recover_stale",
+        "events",
+        "queue_health",
+        "add_dependency",
+        "add_goal_metric",
+        "update_goal_metric",
+        "add_check",
+        "update_check",
+        "remove_check",
+        "add_note",
+        "add_link",
+        "verify_completion",
+        "split_atomic",
+        "assess_atomicity",
+        "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" },
+    title: { type: "string" },
+    description: { type: "string" },
+    dueDate: { type: "string" },
+    tags: { type: "array", items: { type: "string" } },
+    labels: { type: "array", items: { type: "string" } },
+    priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
+    taskType: {
+      type: "string",
+      enum: ["feature", "bugfix", "refactor", "docs", "test", "chore"]
+    },
+    status: {
+      type: "string",
+      enum: [
+        "pending",
+        "ready",
+        "in_progress",
+        "blocked",
+        "review",
+        "completed",
+        "failed",
+        "archived"
+      ]
+    },
+    order: { type: "number" },
+    query: { type: "string" },
+    limit: { type: "number" },
+    agentId: { type: "string" },
+    name: { type: "string" },
+    role: { type: "string" },
+    provider: { type: "string" },
+    model: { type: "string" },
+    fallbackProfile: { type: "string" },
+    fallbackModels: { type: "array", items: { type: "string" } },
+    tools: { type: "array", items: { type: "string" } },
+    allowedCapabilities: { type: "array", items: { type: "string" } },
+    leaseId: { type: "string" },
+    claimedAt: { type: "string" },
+    heartbeatAt: { type: "string" },
+    leaseExpiresAt: { type: "string" },
+    attempt: { type: "number" },
+    maxAttempts: { type: "number" },
+    subagentId: { type: "string" },
+    runTaskId: { type: "string" },
+    lastResult: { type: "string" },
+    error: { type: "string" },
+    expectedLeaseId: { type: "string" },
+    assignmentStatus: {
+      type: "string",
+      enum: ["assigned", "queued", "running", "completed", "failed", "cancelled"]
+    },
+    lifecycleStage: {
+      type: "string",
+      enum: ["backlog", "todo", "running", "review", "done"]
+    },
+    transitionAction: { type: "string" },
+    transitionComment: { type: "string" },
+    tickChecks: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          checkId: { type: "string" },
+          checkStatus: { type: "string", enum: ["passed", "failed", "skipped"] }
+        },
+        required: ["checkId", "checkStatus"]
+      },
+      description: "`transition_task` (to=done only): flip one or more manual criteria to `passed` before the gate fires. Read ids from kanban get_task. Non-manual criteria are refused."
+    },
+    attachmentUrl: { type: "string" },
+    attachmentTitle: { type: "string" },
+    attachmentType: {
+      type: "string",
+      enum: ["issue", "pr", "doc", "commit", "design", "file", "url", "other"]
+    },
+    releaseStatus: { type: "string", enum: ["pending", "ready", "blocked"] },
+    releaseReason: { type: "string" },
+    clearAssignee: { type: "boolean" },
+    recoveryMode: { type: "string", enum: ["auto", "release", "retry", "fail"] },
+    recoveryNow: { type: "string" },
+    recoveryPolicyFailOnCostCeiling: { type: "boolean" },
+    recoveryPolicyReleaseOnFailureKinds: { type: "array", items: { type: "string" } },
+    recoveryPolicyReleaseOnHeartbeatDue: { type: "boolean" },
+    recoveryPolicyRetryPolicyOverride: {
+      type: "string",
+      enum: ["off", "incremental", "exponential"]
+    },
+    assignee: { type: "string" },
+    costCeilingUsd: { type: "number" },
+    retryPolicy: { type: "string", enum: ["off", "incremental", "exponential"] },
+    lastFailureKind: { type: "string" },
+    dependsOn: {
+      type: "array",
+      items: { type: "string" },
+      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" },
+    includeArchived: { type: "boolean" },
+    archiveMissingTasks: { type: "boolean" },
+    preserveManualDependencies: { type: "boolean" },
+    dependencyTaskId: { type: "string" },
+    enforceDependencies: { type: "boolean" },
+    childTitles: { type: "array", items: { type: "string" } },
+    inheritAssignment: { type: "boolean" },
+    inheritLabels: { type: "boolean" },
+    inheritSuccessCriteria: { type: "boolean" },
+    inheritGoalMetrics: { type: "boolean" },
+    inheritDependencies: { type: "boolean" },
+    chainChildren: { type: "boolean" },
+    rewireDependents: { type: "boolean" },
+    closeSourceTasks: { type: "boolean" },
+    metricId: { type: "string" },
+    metricName: { type: "string" },
+    metricTarget: { oneOf: [{ type: "string" }, { type: "number" }] },
+    metricCurrent: { oneOf: [{ type: "string" }, { type: "number" }] },
+    metricDirection: { type: "string", enum: ["at_least", "at_most"] },
+    metricUnit: { type: "string" },
+    metricStatus: { type: "string", enum: ["pending", "met", "missed", "waived"] },
+    metricNotes: { type: "string" },
+    checkId: { type: "string" },
+    checkDescription: { type: "string" },
+    checkStatus: { type: "string", enum: ["pending", "passed", "failed", "skipped"] },
+    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" },
+    linkTitle: { type: "string" },
+    linkType: {
+      type: "string",
+      enum: ["issue", "pr", "doc", "commit", "design", "file", "url", "other"]
+    },
+    context: { type: "string" },
+    columns: { type: "array", items: { type: "string" } },
+    generatedBy: { type: "string" },
+    includeTasks: { type: "boolean" },
+    includeCompletedTasks: { type: "boolean" },
+    preserveAssignment: { type: "boolean" },
+    preserveDependencies: { type: "boolean" },
+    moveTasksToColumnId: { type: "string" },
+    atomicityMode: { type: "string", enum: ["off", "assess", "enforce"] },
+    atomicityDecomposition: { type: "string", enum: ["auto", "propose"] },
+    gateEnforcement: {
+      type: "string",
+      // WS-023: `'off'` is deliberately absent. The agent whose work this gate
+      // checks must not be able to switch it off; it may only tighten. Turning
+      // a gate off stays a human decision, made through board config.
+      enum: ["strict", "soft"]
+    },
+    subtasks: {
+      type: "array",
+      minItems: 2,
+      items: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+          description: { type: "string" },
+          successCriteria: { type: "array", items: { type: "string" } },
+          dependsOnIndex: { type: "array", items: { type: "number" } }
+        },
+        required: ["title"]
+      }
+    }
+  },
+  required: ["action"]
+};
+
+// src/kanban.ts
+var kanbanTool = {
+  name: "kanban",
+  category: "Project",
+  description: KANBAN_TOOL_DESCRIPTION,
+  usageHint: KANBAN_TOOL_USAGE_HINT,
+  permission: "confirm",
+  subjectKey: "action",
+  mutating: true,
+  capabilities: ["fs.write"],
+  icon: "task",
+  timeoutMs: 3e4,
+  inputSchema: KANBAN_INPUT_SCHEMA,
+  async execute(input, ctx) {
+    const projectRoot = ctx.projectRoot;
+    if (!projectRoot) return fail("No project root is available.");
+    const withPresence = createKanbanPresenceWrapper(projectRoot, input, ctx);
+    try {
+      const result = await (async () => {
+        const decompositionResult = await handleKanbanDecompositionAction(projectRoot, input, ctx);
+        if (decompositionResult !== void 0) return decompositionResult;
+        const boardResult = await handleKanbanBoardAction(projectRoot, input, ctx);
+        if (boardResult !== void 0) return boardResult;
+        const lifecycleResult = await handleKanbanLifecycleAction(projectRoot, input, ctx);
+        if (lifecycleResult !== void 0) return lifecycleResult;
+        const contractResult = await handleKanbanContractAction(
+          projectRoot,
+          input,
+          input.author ?? input.agentId,
+          ctx.eventSessionId()
+        );
+        if (contractResult !== void 0) return contractResult;
+        const detailResult = await handleKanbanDetailAction(projectRoot, input, ctx);
+        if (detailResult !== void 0) return detailResult;
+        return fail(`Unknown kanban action: ${input.action}`);
+      })();
+      return withPresence(result);
+    } catch (err) {
+      return fail(stripLifecycleIssues2(err instanceof Error ? err.message : String(err)));
+    }
+  },
+  serialize(output, input) {
+    return serializeKanbanOutput(output, input);
+  }
+};
+
+export {
+  kanbanEvidenceKey,
+  kanbanEvidencePointer,
+  recordKanbanVerificationEvidence,
+  kanbanTool
+};
+//# sourceMappingURL=chunk-JNNVRHMV.js.map