@wrongstack/tools 0.306.3 → 0.307.0

package/dist/plan.js

@@ -14,22 +14,14 @@ import {
 import { formatTaskList } from "@wrongstack/core/utils";
 
 // src/session-kanban.ts
-import { getSharedProjectMailbox } from "@wrongstack/core/coordination";
-import {
-  loadPlan,
-  loadTasks,
-  mutatePlan,
-  mutateTasks
-} from "@wrongstack/core/storage";
+import { loadPlan, loadTasks } from "@wrongstack/core/storage";
 import { deserializeTaskGraph } from "@wrongstack/core/tasking";
-import { formatTodosForModel, resolveWstackPaths } from "@wrongstack/core/utils";
 import {
   bridgeKanbanSupervisor,
   compactSessionMirrorBoard,
   createBoard,
   DEFAULT_COLUMNS,
   getBoard,
-  getDependencyReadinessIssues,
   getKanbanOrchestrationSnapshot,
   listBoards,
   pruneSessionBoards,
@@ -38,6 +30,254 @@ import {
   touchKanbanPresence,
   updateBoard
 } from "@wrongstack/kanban";
+
+// src/session-kanban-graph.ts
+var PLAN_STATUS_TO_TASK = {
+  open: "pending",
+  in_progress: "in_progress",
+  done: "completed"
+};
+function todoListToSerializedGraph(todos, sessionId) {
+  const graphId = `todo:${sessionId}`;
+  const nodes = todos.map((todo, index) => ({
+    id: todo.id,
+    title: todo.content,
+    description: todo.activeForm ?? "",
+    type: "chore",
+    priority: "medium",
+    status: todo.status,
+    specRequirementId: `${graphId}:${todo.id}`,
+    createdAt: index,
+    updatedAt: index
+  }));
+  return {
+    id: graphId,
+    specId: graphId,
+    requiredRequirementIds: nodes.map((node) => node.specRequirementId),
+    title: "Session todos",
+    nodes,
+    edges: [],
+    rootNodes: nodes.map((node) => node.id),
+    createdAt: 0,
+    updatedAt: 0
+  };
+}
+function taskFileToSerializedGraph(tasks, sessionId) {
+  const graphId = `session:${sessionId}`;
+  const ids = new Set(tasks.map((task) => task.id));
+  const nodes = tasks.map((task, index) => ({
+    id: task.id,
+    title: task.title,
+    description: task.description ?? "",
+    type: task.type,
+    priority: task.priority,
+    status: task.status,
+    specRequirementId: `${graphId}:${task.id}`,
+    ...task.assignee ? { assignee: task.assignee } : {},
+    ...task.estimateHours !== void 0 ? { estimateHours: task.estimateHours } : {},
+    createdAt: index,
+    updatedAt: index
+  }));
+  const edges = tasks.flatMap(
+    (task) => (task.dependsOn ?? []).filter((dependency) => ids.has(dependency)).map((dependency) => ({
+      id: `${dependency}->${task.id}`,
+      from: dependency,
+      to: task.id,
+      type: "depends_on"
+    }))
+  );
+  const hasIncoming = new Set(edges.map((edge) => edge.to));
+  const rootNodes = nodes.filter((node) => !hasIncoming.has(node.id)).map((node) => node.id);
+  return {
+    // Keep the historical graph id so existing mirrored task cards are reused.
+    id: graphId,
+    specId: graphId,
+    requiredRequirementIds: nodes.map((node) => node.specRequirementId),
+    title: "Session tasks",
+    nodes,
+    edges,
+    rootNodes: rootNodes.length ? rootNodes : nodes[0] ? [nodes[0].id] : [],
+    createdAt: 0,
+    updatedAt: 0
+  };
+}
+function planFileToSerializedGraph(items, sessionId) {
+  const graphId = `plan:${sessionId}`;
+  const nodes = items.map((item, index) => ({
+    id: item.id,
+    title: item.title,
+    description: item.details ?? "",
+    type: "chore",
+    priority: "medium",
+    status: PLAN_STATUS_TO_TASK[item.status],
+    specRequirementId: `${graphId}:${item.id}`,
+    createdAt: index,
+    updatedAt: index
+  }));
+  return {
+    id: graphId,
+    specId: graphId,
+    requiredRequirementIds: nodes.map((node) => node.specRequirementId),
+    title: "Session plan",
+    nodes,
+    edges: [],
+    rootNodes: nodes.map((node) => node.id),
+    createdAt: 0,
+    updatedAt: 0
+  };
+}
+
+// src/session-kanban-sync.ts
+import { getSharedProjectMailbox } from "@wrongstack/core/coordination";
+import { mutatePlan, mutateTasks } from "@wrongstack/core/storage";
+import { formatTodosForModel, resolveWstackPaths } from "@wrongstack/core/utils";
+import {
+  getDependencyReadinessIssues
+} from "@wrongstack/kanban";
+function sourceStatus(task) {
+  if (task.status === "completed") return "completed";
+  if (task.status === "in_progress") return "in_progress";
+  if (task.status === "review") return "review";
+  if (task.status === "blocked") return "blocked";
+  if (task.status === "failed") return "failed";
+  return "pending";
+}
+function todoStatus(task) {
+  const status = sourceStatus(task);
+  if (status === "completed") return "completed";
+  if (status === "review" && task.assignment?.status === "completed") return "completed";
+  if (status === "in_progress" || status === "review") return "in_progress";
+  return "pending";
+}
+function sessionTodoFromTask(task, board) {
+  const blockedBy = board ? blockingTitles(board, task) : [];
+  return {
+    id: task.origin?.taskId ?? task.id,
+    content: task.title,
+    status: todoStatus(task),
+    ...task.description ? { activeForm: task.description } : {},
+    ...blockedBy.length ? { blockedBy } : {}
+  };
+}
+function managedTodoFromTask(task, board) {
+  return {
+    ...sessionTodoFromTask(task, board),
+    kanbanBoardId: board.id,
+    kanbanTaskId: task.id
+  };
+}
+function blockingTitles(board, task) {
+  return getDependencyReadinessIssues(board, task).map((issue) => {
+    const dependency = board.tasks.find((candidate) => candidate.id === issue.dependencyId);
+    if (!dependency) return `${issue.dependencyId} (missing)`;
+    return dependency.title;
+  });
+}
+var PRIORITY_ORDER = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3
+};
+function orderTasksForTodos(board, tasks) {
+  const columnOrder = new Map(board.columns.map((column) => [column.id, column.order]));
+  const baseline = [...tasks].sort(
+    (left, right) => (columnOrder.get(left.columnId) ?? 0) - (columnOrder.get(right.columnId) ?? 0) || (PRIORITY_ORDER[left.priority] ?? 2) - (PRIORITY_ORDER[right.priority] ?? 2) || left.order - right.order || left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id)
+  );
+  const included = new Set(baseline.map((task) => task.id));
+  const remaining = new Map(baseline.map((task) => [task.id, task]));
+  const emitted = [];
+  const done = /* @__PURE__ */ new Set();
+  while (remaining.size > 0) {
+    const ready = baseline.filter(
+      (task) => remaining.has(task.id) && (task.dependsOn ?? []).every(
+        (dependencyId) => !included.has(dependencyId) || done.has(dependencyId)
+      )
+    );
+    if (ready.length === 0) break;
+    for (const task of ready) {
+      remaining.delete(task.id);
+      done.add(task.id);
+      emitted.push(task);
+    }
+  }
+  for (const task of baseline) if (remaining.has(task.id)) emitted.push(task);
+  return emitted;
+}
+function sameTodos(left, right) {
+  return left.length === right.length && left.every((todo, index) => {
+    const candidate = right[index];
+    return candidate?.id === todo.id && candidate.content === todo.content && candidate.status === todo.status && candidate.activeForm === todo.activeForm && candidate.promotedFromPlan === todo.promotedFromPlan && candidate.promotedFromTask === todo.promotedFromTask && candidate.kanbanBoardId === todo.kanbanBoardId && candidate.kanbanTaskId === todo.kanbanTaskId && (candidate.blockedBy ?? []).join("\0") === (todo.blockedBy ?? []).join("\0");
+  });
+}
+function broadcastTodoUpdate(context, todos) {
+  const sessionId = context.session?.id ?? "";
+  if (!context.agentId || !sessionId) return;
+  const statusCounts = { pending: 0, inProgress: 0, completed: 0 };
+  for (const todo of todos) {
+    if (todo.status === "completed") statusCounts.completed++;
+    else if (todo.status === "in_progress") statusCounts.inProgress++;
+    else statusCounts.pending++;
+  }
+  const projectDir = resolveWstackPaths({ projectRoot: context.projectRoot }).projectDir;
+  const mailbox = getSharedProjectMailbox(projectDir);
+  void mailbox.send({
+    from: context.agentId,
+    to: "*",
+    type: "status",
+    subject: `Kanban todo list updated (${todos.length} item${todos.length === 1 ? "" : "s"})`,
+    body: JSON.stringify({
+      kind: "kanban.todos.updated",
+      sessionId,
+      revision: context.state.revision,
+      todoCount: todos.length,
+      statusCounts
+    }),
+    priority: "normal",
+    senderSessionId: sessionId
+  }).catch(() => {
+  });
+}
+function notifyTodoUpdate(context, todos) {
+  const summary = formatTodosForModel(todos);
+  const text = `[KANBAN TODO UPDATE]
+Another Kanban agent reassessed the shared board. The canonical todo list is now:
+${summary}
+Reassess your current plan before continuing; do not rely on the initial todo snapshot. Preserve each row's <kanban board/task> binding verbatim on your next \`todo\` call \u2014 a row that loses it stops advancing its card.`;
+  const state = context.state;
+  if (typeof state.appendBlockToLastUserMessage === "function") {
+    if (state.appendBlockToLastUserMessage({ type: "text", text })) return;
+  }
+  if (typeof state.appendMessage === "function") {
+    state.appendMessage({ role: "user", content: [{ type: "text", text }] });
+  }
+}
+function applyManagedKanbanBoardToTodos(context, board, suppressedTodoMirrors2) {
+  const metaKanban = context.meta["kanban"];
+  const metaBoardId = metaKanban && typeof metaKanban === "object" ? metaKanban["boardId"] : void 0;
+  const activeBoardId2 = context.currentKanbanBoardId ?? (typeof metaBoardId === "string" ? metaBoardId : void 0);
+  if (!activeBoardId2 || board.id !== activeBoardId2 || board.lifecycle?.mode !== "managed") {
+    return [...context.todos];
+  }
+  const projectedTodos = orderTasksForTodos(
+    board,
+    board.tasks.filter(
+      (task) => task.status !== "archived" && task.mergedIntoTaskId === void 0 && (!task.childTaskIds || task.childTaskIds.length === 0)
+    )
+  ).map((task) => managedTodoFromTask(task, board));
+  if (sameTodos(context.todos, projectedTodos)) return [...context.todos];
+  suppressedTodoMirrors2.add(context);
+  try {
+    context.state.replaceTodos(projectedTodos);
+  } finally {
+    suppressedTodoMirrors2.delete(context);
+  }
+  notifyTodoUpdate(context, context.todos);
+  broadcastTodoUpdate(context, context.todos);
+  return [...context.todos];
+}
+
+// src/session-kanban.ts
 var SESSION_BOARD_TAG = "session-work";
 var MIRROR_DISABLED_ENV = "WRONGSTACK_KANBAN_TASK_MIRROR";
 var SESSION_KANBAN_COLUMNS = DEFAULT_COLUMNS.map((column) => ({
@@ -161,15 +401,6 @@ async function projectGraph(projectRoot, sessionId, graph, sourceSystem) {
         tags: [.../* @__PURE__ */ new Set([...board.tags ?? [], ...sessionBoardTags(sessionId)])],
         archiveMissingTasks: true,
         includeCompletedTasks: true,
-        // The scope ledger stays declared and accurate, but it may not veto a
-        // projection. A session mirror reflects a tactical list that shrinks by
-        // design, and refusing the sync never protected the removed row — it
-        // froze the entire board, permanently, because the stored scope then
-        // outlived every later snapshot (`session-kanban.mirror-failed`).
-        // Nothing is lost by shrinking here: `archiveMissingTasks` keeps the
-        // removed card on the board as `archived`, the reconciliation pass
-        // first walks vanished completed rows to Done, and the session journal
-        // remains the durable record.
         allowRequirementScopeShrink: true
       }
     );
@@ -263,260 +494,24 @@ function takeSessionMirrorFailure(projectRoot, sessionId) {
   mirrorFailures.delete(key);
   return `Kanban mirror (${failure.sourceSystem}) failed and the board may be stale: ${failure.message}`;
 }
-function todoListToSerializedGraph(todos, sessionId) {
-  const graphId = `todo:${sessionId}`;
-  const nodes = todos.map((todo, index) => ({
-    id: todo.id,
-    title: todo.content,
-    description: todo.activeForm ?? "",
-    type: "chore",
-    priority: "medium",
-    status: todo.status,
-    specRequirementId: `${graphId}:${todo.id}`,
-    createdAt: index,
-    updatedAt: index
-  }));
-  return {
-    id: graphId,
-    specId: graphId,
-    requiredRequirementIds: nodes.map((node) => node.specRequirementId),
-    title: "Session todos",
-    nodes,
-    edges: [],
-    rootNodes: nodes.map((node) => node.id),
-    createdAt: 0,
-    updatedAt: 0
-  };
-}
-function taskFileToSerializedGraph(tasks, sessionId) {
-  const graphId = `session:${sessionId}`;
-  const ids = new Set(tasks.map((task) => task.id));
-  const nodes = tasks.map((task, index) => ({
-    id: task.id,
-    title: task.title,
-    description: task.description ?? "",
-    type: task.type,
-    priority: task.priority,
-    status: task.status,
-    specRequirementId: `${graphId}:${task.id}`,
-    ...task.assignee ? { assignee: task.assignee } : {},
-    ...task.estimateHours !== void 0 ? { estimateHours: task.estimateHours } : {},
-    createdAt: index,
-    updatedAt: index
-  }));
-  const edges = tasks.flatMap(
-    (task) => (task.dependsOn ?? []).filter((dependency) => ids.has(dependency)).map((dependency) => ({
-      id: `${dependency}->${task.id}`,
-      from: dependency,
-      to: task.id,
-      type: "depends_on"
-    }))
-  );
-  const hasIncoming = new Set(edges.map((edge) => edge.to));
-  const rootNodes = nodes.filter((node) => !hasIncoming.has(node.id)).map((node) => node.id);
-  return {
-    // Keep the historical graph id so existing mirrored task cards are reused.
-    id: graphId,
-    specId: graphId,
-    requiredRequirementIds: nodes.map((node) => node.specRequirementId),
-    title: "Session tasks",
-    nodes,
-    edges,
-    rootNodes: rootNodes.length ? rootNodes : nodes[0] ? [nodes[0].id] : [],
-    createdAt: 0,
-    updatedAt: 0
-  };
-}
-var PLAN_STATUS_TO_TASK = {
-  open: "pending",
-  in_progress: "in_progress",
-  done: "completed"
-};
-function planFileToSerializedGraph(items, sessionId) {
-  const graphId = `plan:${sessionId}`;
-  const nodes = items.map((item, index) => ({
-    id: item.id,
-    title: item.title,
-    description: item.details ?? "",
-    type: "chore",
-    priority: "medium",
-    status: PLAN_STATUS_TO_TASK[item.status],
-    specRequirementId: `${graphId}:${item.id}`,
-    createdAt: index,
-    updatedAt: index
-  }));
-  return {
-    id: graphId,
-    specId: graphId,
-    requiredRequirementIds: nodes.map((node) => node.specRequirementId),
-    title: "Session plan",
-    nodes,
-    edges: [],
-    rootNodes: nodes.map((node) => node.id),
-    createdAt: 0,
-    updatedAt: 0
-  };
-}
 function projectSessionPlanToKanban(projectRoot, items, sessionId) {
   return projectGraph(
     projectRoot,
     sessionId,
     planFileToSerializedGraph(items, sessionId),
-    "session-plan"
-  );
-}
-function broadcastTodoUpdate(context, todos) {
-  const sessionId = context.session?.id ?? "";
-  if (!context.agentId || !sessionId) return;
-  const statusCounts = { pending: 0, inProgress: 0, completed: 0 };
-  for (const todo of todos) {
-    if (todo.status === "completed") statusCounts.completed++;
-    else if (todo.status === "in_progress") statusCounts.inProgress++;
-    else statusCounts.pending++;
-  }
-  const projectDir = resolveWstackPaths({ projectRoot: context.projectRoot }).projectDir;
-  const mailbox = getSharedProjectMailbox(projectDir);
-  void mailbox.send({
-    from: context.agentId,
-    to: "*",
-    type: "status",
-    subject: `Kanban todo list updated (${todos.length} item${todos.length === 1 ? "" : "s"})`,
-    body: JSON.stringify({
-      kind: "kanban.todos.updated",
-      sessionId,
-      revision: context.state.revision,
-      todoCount: todos.length,
-      statusCounts
-    }),
-    priority: "normal",
-    senderSessionId: sessionId
-  }).catch(() => {
-  });
-}
-function notifyTodoUpdate(context, todos) {
-  const summary = formatTodosForModel(todos);
-  const text = `[KANBAN TODO UPDATE]
-Another Kanban agent reassessed the shared board. The canonical todo list is now:
-${summary}
-Reassess your current plan before continuing; do not rely on the initial todo snapshot. Preserve each row's <kanban board/task> binding verbatim on your next \`todo\` call \u2014 a row that loses it stops advancing its card.`;
-  const state = context.state;
-  if (typeof state.appendBlockToLastUserMessage === "function") {
-    if (state.appendBlockToLastUserMessage({ type: "text", text })) return;
-  }
-  if (typeof state.appendMessage === "function") {
-    state.appendMessage({ role: "user", content: [{ type: "text", text }] });
-  }
-}
-function mirrorSessionTodosToKanban(projectRoot, todos, sessionId) {
-  queueLatestMirror(
-    projectRoot,
-    sessionId,
-    todoListToSerializedGraph(todos, sessionId),
-    "session-todo"
-  );
-}
-function sourceStatus(task) {
-  if (task.status === "completed") return "completed";
-  if (task.status === "in_progress") return "in_progress";
-  if (task.status === "review") return "review";
-  if (task.status === "blocked") return "blocked";
-  if (task.status === "failed") return "failed";
-  return "pending";
-}
-function todoStatus(task) {
-  const status = sourceStatus(task);
-  if (status === "completed") return "completed";
-  if (status === "review" && task.assignment?.status === "completed") return "completed";
-  if (status === "in_progress" || status === "review") return "in_progress";
-  return "pending";
-}
-function sessionTodoFromTask(task, board) {
-  const blockedBy = board ? blockingTitles(board, task) : [];
-  return {
-    id: task.origin?.taskId ?? task.id,
-    content: task.title,
-    status: todoStatus(task),
-    ...task.description ? { activeForm: task.description } : {},
-    ...blockedBy.length ? { blockedBy } : {}
-  };
-}
-function managedTodoFromTask(task, board) {
-  return {
-    ...sessionTodoFromTask(task, board),
-    kanbanBoardId: board.id,
-    kanbanTaskId: task.id
-  };
-}
-function blockingTitles(board, task) {
-  return getDependencyReadinessIssues(board, task).map((issue) => {
-    const dependency = board.tasks.find((candidate) => candidate.id === issue.dependencyId);
-    if (!dependency) return `${issue.dependencyId} (missing)`;
-    return dependency.title;
-  });
-}
-var PRIORITY_ORDER = {
-  critical: 0,
-  high: 1,
-  medium: 2,
-  low: 3
-};
-function orderTasksForTodos(board, tasks) {
-  const columnOrder = new Map(board.columns.map((column) => [column.id, column.order]));
-  const baseline = [...tasks].sort(
-    (left, right) => (columnOrder.get(left.columnId) ?? 0) - (columnOrder.get(right.columnId) ?? 0) || (PRIORITY_ORDER[left.priority] ?? 2) - (PRIORITY_ORDER[right.priority] ?? 2) || left.order - right.order || left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id)
-  );
-  const included = new Set(baseline.map((task) => task.id));
-  const remaining = new Map(baseline.map((task) => [task.id, task]));
-  const emitted = [];
-  const done = /* @__PURE__ */ new Set();
-  while (remaining.size > 0) {
-    const ready = baseline.filter(
-      (task) => remaining.has(task.id) && (task.dependsOn ?? []).every(
-        (dependencyId) => !included.has(dependencyId) || done.has(dependencyId)
-      )
-    );
-    if (ready.length === 0) break;
-    for (const task of ready) {
-      remaining.delete(task.id);
-      done.add(task.id);
-      emitted.push(task);
-    }
-  }
-  for (const task of baseline) if (remaining.has(task.id)) emitted.push(task);
-  return emitted;
+    "session-plan"
+  );
 }
-function sameTodos(left, right) {
-  return left.length === right.length && left.every((todo, index) => {
-    const candidate = right[index];
-    return candidate?.id === todo.id && candidate.content === todo.content && candidate.status === todo.status && candidate.activeForm === todo.activeForm && candidate.promotedFromPlan === todo.promotedFromPlan && candidate.promotedFromTask === todo.promotedFromTask && candidate.kanbanBoardId === todo.kanbanBoardId && candidate.kanbanTaskId === todo.kanbanTaskId && // Readiness is part of the projection: when a dependency completes,
-    // the rows are otherwise identical and the unblocking would never
-    // reach the model.
-    (candidate.blockedBy ?? []).join("\0") === (todo.blockedBy ?? []).join("\0");
-  });
+function mirrorSessionTodosToKanban(projectRoot, todos, sessionId) {
+  queueLatestMirror(
+    projectRoot,
+    sessionId,
+    todoListToSerializedGraph(todos, sessionId),
+    "session-todo"
+  );
 }
-function applyManagedKanbanBoardToTodos(context, board) {
-  const metaKanban = context.meta["kanban"];
-  const metaBoardId = metaKanban && typeof metaKanban === "object" ? metaKanban["boardId"] : void 0;
-  const activeBoardId2 = context.currentKanbanBoardId ?? (typeof metaBoardId === "string" ? metaBoardId : void 0);
-  if (!activeBoardId2 || board.id !== activeBoardId2 || board.lifecycle?.mode !== "managed") {
-    return [...context.todos];
-  }
-  const projectedTodos = orderTasksForTodos(
-    board,
-    board.tasks.filter(
-      (task) => task.status !== "archived" && task.mergedIntoTaskId === void 0 && (!task.childTaskIds || task.childTaskIds.length === 0)
-    )
-  ).map((task) => managedTodoFromTask(task, board));
-  if (sameTodos(context.todos, projectedTodos)) return [...context.todos];
-  suppressedTodoMirrors.add(context);
-  try {
-    context.state.replaceTodos(projectedTodos);
-  } finally {
-    suppressedTodoMirrors.delete(context);
-  }
-  notifyTodoUpdate(context, context.todos);
-  broadcastTodoUpdate(context, context.todos);
-  return [...context.todos];
+function applyManagedKanbanBoardToTodos2(context, board) {
+  return applyManagedKanbanBoardToTodos(context, board, suppressedTodoMirrors);
 }
 
 // src/todo.ts
@@ -527,54 +522,34 @@ import {
   saveTasks,
   setPlanItemStatus
 } from "@wrongstack/core/storage";
-import { addTask as addTask2, getBoard as getBoard4 } from "@wrongstack/kanban";
+import { addTask as addTask3, getBoard as getBoard5 } from "@wrongstack/kanban";
 
 // src/kanban.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { stripLifecycleIssues as stripLifecycleIssues2 } from "@wrongstack/kanban";
+
+// src/kanban-board-actions.ts
 import { loadTasks as loadTasks2 } from "@wrongstack/core/storage";
 import { deserializeTaskGraph as deserializeTaskGraph2, serializeTaskGraph } from "@wrongstack/core/tasking";
 import {
   addTask,
   adoptManagedLifecycle,
-  assignTask,
-  claimReadyTask,
-  copyTaskToBoard,
   createBoard as createBoard2,
   createBoardFromTaskGraph,
   createBoardFromText,
   duplicateBoard,
-  evaluateContractGraphReadiness,
   exportBoardAsMarkdown,
   exportBoardToTaskGraph,
-  finalizeTaskCompletion,
   getBoard as getBoard3,
   getKanbanOrchestrationSnapshot as getKanbanOrchestrationSnapshot2,
   getKanbanQueueHealth,
-  getTask,
-  getTaskChain,
-  heartbeatTaskAssignment,
   listBoards as listBoards2,
   listKanbanEvents,
   listReadyTasks,
-  mergeTasks,
-  moveTask,
   parseLinesIntoTasks,
-  recoverStaleTaskAssignments,
-  releaseTaskClaim,
   removeBoard as removeBoard2,
-  removeTask,
-  repairManagedTaskProjection,
-  resolveAutoAccept,
   searchKanban,
-  setTaskChain,
-  stripLifecycleIssues,
   syncBoardFromTaskGraph as syncBoardFromTaskGraph2,
-  transferTaskToBoard,
-  transitionTask,
-  updateBoard as updateBoard2,
-  updateTask as updateTask2,
-  updateTaskAssignment,
-  verifyTaskCompletion as verifyTaskCompletion2
+  updateBoard as updateBoard2
 } from "@wrongstack/kanban";
 
 // src/kanban-board-inputs.ts
@@ -621,16 +596,8 @@ function duplicateBoardOptions(input) {
   };
 }
 
-// src/kanban-contract-actions.ts
-import {
-  addContractEdge,
-  configureContractGraph,
-  evaluateTaskContractGraph,
-  getContractGraph,
-  removeContractEdge,
-  removeContractNode,
-  upsertContractNode
-} from "@wrongstack/kanban";
+// src/kanban-split-task-handler.ts
+import { getBoard as getBoard2, splitTask } from "@wrongstack/kanban";
 
 // src/kanban-tool-results.ts
 function atomicityNudge(task) {
@@ -652,7 +619,314 @@ function okTask(board, task, message) {
   return { ok: true, message, board, task };
 }
 
+// src/kanban-split-task-handler.ts
+async function handleSplitTask(projectRoot, input, extraSplitOptions) {
+  const boardId = input.boardId;
+  const taskId = input.taskId;
+  const childTitles = input.childTitles;
+  if (!boardId || !taskId || !childTitles?.length) {
+    return fail("split requires boardId, taskId, and at least one childTitles.");
+  }
+  const {
+    targetColumnId,
+    inheritAssignment,
+    inheritLabels,
+    inheritSuccessCriteria,
+    inheritGoalMetrics,
+    inheritDependencies,
+    chainChildren,
+    rewireDependents
+  } = input;
+  const result = await splitTask(projectRoot, boardId, taskId, {
+    titles: childTitles,
+    ...extraSplitOptions,
+    ...targetColumnId !== void 0 ? { columnId: targetColumnId } : {},
+    ...inheritAssignment !== void 0 ? { inheritAssignment } : {},
+    ...inheritLabels !== void 0 ? { inheritLabels } : {},
+    ...inheritSuccessCriteria !== void 0 ? { inheritSuccessCriteria } : {},
+    ...inheritGoalMetrics !== void 0 ? { inheritGoalMetrics } : {},
+    ...inheritDependencies !== void 0 ? { inheritDependencies } : {},
+    ...chainChildren !== void 0 ? { chainChildren } : {},
+    ...rewireDependents !== void 0 ? { rewireDependents } : {}
+  });
+  if (!result) return fail("Task not found.");
+  const freshParent = result.board.tasks?.find((t) => t.id === taskId);
+  if (!freshParent) {
+    return fail(
+      `Split succeeded but parent ${taskId} not found in returned board. Children: [${result.children.map((c) => c.id).join(", ")}].`
+    );
+  }
+  return {
+    ok: true,
+    message: `${result.children.length} child task(s) created.`,
+    board: result.board,
+    task: freshParent,
+    children: result.children
+  };
+}
+async function requireBoard(projectRoot, boardId) {
+  return boardId ? getBoard2(projectRoot, boardId) : null;
+}
+
+// src/kanban-board-actions.ts
+async function handleKanbanBoardAction(projectRoot, input, ctx) {
+  switch (input.action) {
+    case "list_boards": {
+      const boards = await listBoards2(projectRoot);
+      return { ok: true, message: `${boards.length} board(s).`, boards };
+    }
+    case "get_board": {
+      const board = await requireBoard(projectRoot, input.boardId);
+      return board ? okBoard(board) : fail("Board not found.");
+    }
+    case "create_board": {
+      if (!input.title) return fail("create_board requires title.");
+      const existing = (await listBoards2(projectRoot)).filter(
+        (candidate) => (candidate.kind ?? "project") === "project"
+      );
+      const board = await createBoard2(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 updateBoard2(projectRoot, input.boardId, boardUpdatePatch(input));
+      return board ? okBoard(board, "Board updated.") : fail("Board not found.");
+    }
+    case "adopt_managed_lifecycle": {
+      if (!input.boardId || !input.author || !input.transitionComment) {
+        return fail(
+          "adopt_managed_lifecycle requires boardId, author, transitionComment, and five ordered columns."
+        );
+      }
+      if (input.columns?.length !== 5) {
+        return fail(
+          "adopt_managed_lifecycle columns must be ordered as backlog, todo, running, review, done."
+        );
+      }
+      const [backlog, todo, running, review, done] = input.columns;
+      if (!backlog || !todo || !running || !review || !done) {
+        return fail("adopt_managed_lifecycle columns must contain five nonblank ids.");
+      }
+      const board = await adoptManagedLifecycle(projectRoot, input.boardId, {
+        columns: { backlog, todo, running, review, done },
+        actor: input.author,
+        comment: input.transitionComment
+      });
+      return board ? okBoard(board, "Managed lifecycle adopted without moving existing cards.") : fail("Board not found.");
+    }
+    case "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));
+      return board ? okBoard(board, "Board duplicated.") : fail("Board not found.");
+    }
+    case "delete_board": {
+      if (!input.boardId) return fail("delete_board requires boardId.");
+      const removed = await removeBoard2(projectRoot, input.boardId);
+      return { ok: removed, message: removed ? "Board deleted." : "Board not found." };
+    }
+    case "generate_board": {
+      if (!input.description) return fail("generate_board requires description.");
+      const boardInput = createBoardFromText({
+        description: input.description,
+        ...input.title !== void 0 ? { title: input.title } : {},
+        ...input.context !== void 0 ? { context: input.context } : {}
+      });
+      const board = await createBoard2(projectRoot, boardInput);
+      for (const tInput of parseLinesIntoTasks(
+        input.description,
+        board.columns[0]?.id ?? "backlog"
+      )) {
+        await addTask(projectRoot, board.id, tInput);
+      }
+      return okBoard(await getBoard3(projectRoot, board.id) ?? board, "Board generated.");
+    }
+    case "export_markdown": {
+      const board = await requireBoard(projectRoot, input.boardId);
+      if (!board) return fail("Board not found.");
+      return {
+        ok: true,
+        message: "Board exported.",
+        board,
+        markdown: exportBoardAsMarkdown(board)
+      };
+    }
+    case "export_task_graph": {
+      if (!input.boardId) return fail("export_task_graph requires boardId.");
+      const exported = await exportBoardToTaskGraph(projectRoot, input.boardId, {
+        ...input.graphId !== void 0 ? { graphId: input.graphId } : {},
+        ...input.specId !== void 0 ? { specId: input.specId } : {},
+        ...input.title !== void 0 ? { title: input.title } : {},
+        ...input.preserveOriginTaskIds !== void 0 ? { preserveOriginTaskIds: input.preserveOriginTaskIds } : {},
+        ...input.includeArchived !== void 0 ? { includeArchived: input.includeArchived } : {}
+      });
+      if (!exported) return fail("Board not found.");
+      return {
+        ok: true,
+        message: `Task graph exported with ${exported.graph.nodes.size} node(s).`,
+        board: exported.board,
+        taskGraph: serializeTaskGraph(exported.graph)
+      };
+    }
+    case "sync_task_graph": {
+      if (!input.boardId || !input.taskGraph) {
+        return fail("sync_task_graph requires boardId and taskGraph.");
+      }
+      const graph = deserializeTaskGraph2(input.taskGraph);
+      const result = await syncBoardFromTaskGraph2(projectRoot, input.boardId, graph, {
+        ...input.title !== void 0 ? { title: input.title } : {},
+        ...input.description !== void 0 ? { description: input.description } : {},
+        ...input.tags !== void 0 ? { tags: input.tags } : {},
+        ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
+        ...input.sourceSystem !== void 0 ? { sourceSystem: input.sourceSystem } : {},
+        ...input.phaseId !== void 0 ? { phaseId: input.phaseId } : {},
+        ...input.includeCompletedTasks !== void 0 ? { includeCompletedTasks: input.includeCompletedTasks } : {},
+        ...input.archiveMissingTasks !== void 0 ? { archiveMissingTasks: input.archiveMissingTasks } : {},
+        ...input.preserveManualDependencies !== void 0 ? { preserveManualDependencies: input.preserveManualDependencies } : {}
+      });
+      return 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 = deserializeTaskGraph2(input.taskGraph);
+      const { board } = await createBoardFromTaskGraph(projectRoot, graph, {
+        ...input.title !== void 0 ? { title: input.title } : {},
+        ...input.description !== void 0 ? { description: input.description } : {},
+        ...input.tags !== void 0 ? { tags: input.tags } : {},
+        ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
+        ...input.sourceSystem !== void 0 ? { sourceSystem: input.sourceSystem } : {},
+        ...input.phaseId !== void 0 ? { phaseId: input.phaseId } : {},
+        ...input.includeCompletedTasks !== void 0 ? { includeCompletedTasks: input.includeCompletedTasks } : {}
+      });
+      return {
+        ok: true,
+        message: `Created board "${board.title}" from task graph with ${board.tasks.length} tasks.`,
+        board
+      };
+    }
+    case "import_session_tasks": {
+      const taskPath = ctx.meta?.["task.path"];
+      if (!taskPath) return fail("No session task file for this session.");
+      const file = await loadTasks2(taskPath);
+      if (!file || file.tasks.length === 0) return fail("No session tasks to import.");
+      const sessionId = ctx.session?.id ?? file.sessionId ?? "session";
+      const graph = deserializeTaskGraph2(taskFileToSerializedGraph(file.tasks, sessionId));
+      const tags = ["session", `session:${sessionId}`];
+      const existing = (await listBoards2(projectRoot)).find(
+        (b) => b.tags?.includes(`session:${sessionId}`)
+      );
+      if (existing) {
+        const result = await syncBoardFromTaskGraph2(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 getKanbanOrchestrationSnapshot2(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) {
   switch (input.action) {
     case "get_contract_graph": {
@@ -855,79 +1129,27 @@ async function handleKanbanDecompositionAction(projectRoot, input, ctx) {
         ),
         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";
-
-// src/kanban-split-task-handler.ts
-import { getBoard as getBoard2, splitTask } from "@wrongstack/kanban";
-async function handleSplitTask(projectRoot, input, extraSplitOptions) {
-  const boardId = input.boardId;
-  const taskId = input.taskId;
-  const childTitles = input.childTitles;
-  if (!boardId || !taskId || !childTitles?.length) {
-    return fail("split requires boardId, taskId, and at least one childTitles.");
-  }
-  const {
-    targetColumnId,
-    inheritAssignment,
-    inheritLabels,
-    inheritSuccessCriteria,
-    inheritGoalMetrics,
-    inheritDependencies,
-    chainChildren,
-    rewireDependents
-  } = input;
-  const result = await splitTask(projectRoot, boardId, taskId, {
-    titles: childTitles,
-    ...extraSplitOptions,
-    ...targetColumnId !== void 0 ? { columnId: targetColumnId } : {},
-    ...inheritAssignment !== void 0 ? { inheritAssignment } : {},
-    ...inheritLabels !== void 0 ? { inheritLabels } : {},
-    ...inheritSuccessCriteria !== void 0 ? { inheritSuccessCriteria } : {},
-    ...inheritGoalMetrics !== void 0 ? { inheritGoalMetrics } : {},
-    ...inheritDependencies !== void 0 ? { inheritDependencies } : {},
-    ...chainChildren !== void 0 ? { chainChildren } : {},
-    ...rewireDependents !== void 0 ? { rewireDependents } : {}
-  });
-  if (!result) return fail("Task not found.");
-  const freshParent = result.board.tasks?.find((t) => t.id === taskId);
-  if (!freshParent) {
-    return fail(
-      `Split succeeded but parent ${taskId} not found in returned board. Children: [${result.children.map((c) => c.id).join(", ")}].`
-    );
+        board: persistedBoard,
+        task: freshTask ?? verResult.task
+      };
+    }
+    default:
+      return void 0;
   }
-  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 ? getBoard2(projectRoot, boardId) : null;
 }
 
 // src/kanban-detail-actions.ts
+import {
+  addCheckToTask,
+  addDependency,
+  addGoalMetricToTask,
+  addLinkToTask,
+  addNoteToTask,
+  getKanbanWorkbench,
+  removeCheckFromTask,
+  updateCheckOnTask,
+  updateGoalMetricOnTask
+} from "@wrongstack/kanban";
 async function handleKanbanDetailAction(projectRoot, input) {
   switch (input.action) {
     case "workbench": {
@@ -1060,26 +1282,34 @@ async function handleKanbanDetailAction(projectRoot, input) {
   }
 }
 
-// src/kanban-presence.ts
-import { touchKanbanPresence as touchKanbanPresence2 } 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 touchKanbanPresence2(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-lifecycle-actions.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import {
+  addTask as addTask2,
+  assignTask,
+  claimReadyTask,
+  copyTaskToBoard,
+  evaluateContractGraphReadiness,
+  finalizeTaskCompletion,
+  getBoard as getBoard4,
+  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";
@@ -1228,31 +1458,597 @@ function assignmentInput(input) {
     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 } : {}
-  };
+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 handleKanbanLifecycleAction(projectRoot, input, ctx) {
+  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));
+      if (!result) return fail("Board not found.");
+      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, {});
+    }
+    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 } : {}
+      });
+      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 } : {}
+        }
+      );
+      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 } : {}
+        }
+      );
+      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 getBoard4(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.");
+      const board = await updateTask2(projectRoot, input.boardId, input.taskId, taskPatch(input));
+      return board ? okBoard(board, "Task updated.") : fail("Task not found.");
+    }
+    case "transition_task": {
+      if (!input.boardId || !input.taskId || !input.lifecycleStage || !input.author || !input.transitionComment) {
+        return fail(
+          "transition_task requires boardId, taskId, lifecycleStage, author, and transitionComment."
+        );
+      }
+      if (input.lifecycleStage === "done") {
+        const boardBefore = await getBoard4(projectRoot, input.boardId);
+        const taskBefore = boardBefore ? await getTask(projectRoot, input.boardId, input.taskId) : null;
+        if (boardBefore && taskBefore && !taskBefore.verificationReport && (taskBefore.atomic || Boolean(taskBefore.successCriteria?.length))) {
+          const preGate = await verifyTaskCompletion2(projectRoot, input.boardId, taskBefore.id, {
+            persist: false
+          });
+          await updateTask2(projectRoot, input.boardId, taskBefore.id, {
+            verificationReport: preGate.report,
+            successCriteria: preGate.task.successCriteria
+          });
+        }
+      }
+      const result = await transitionTask(projectRoot, input.boardId, input.taskId, {
+        to: input.lifecycleStage,
+        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);
+      }
+      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
+      });
+      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
+      );
+      return board ? okBoard(board, "Task moved.") : fail("Move failed.");
+    }
+    case "delete_task": {
+      if (!input.boardId || !input.taskId) return fail("delete_task requires boardId and taskId.");
+      const board = await removeTask(projectRoot, input.boardId, input.taskId);
+      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": {
+      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 } : {}
+      });
+      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"
+      });
+      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 } : {}
+      });
+      return board ? okBoard(board, "Task claim released.") : fail("Task not found.");
+    }
+    case "assign_task": {
+      if (!input.boardId || !input.taskId) return fail("assign_task requires boardId and taskId.");
+      const board = await assignTask(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        assignmentInput(input)
+      );
+      return board ? okBoard(board, "Task assigned.") : fail("Task not found.");
+    }
+    case "mark_assignment": {
+      if (!input.boardId || !input.taskId)
+        return fail("mark_assignment requires boardId and taskId.");
+      const assignmentStatus = input.assignmentStatus ?? (input.status === "completed" ? "completed" : input.error ? "failed" : void 0);
+      const board = await updateTaskAssignment(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        {
+          ...assignmentStatus !== void 0 ? { status: assignmentStatus } : {},
+          ...input.subagentId !== void 0 ? { subagentId: input.subagentId } : {},
+          ...input.runTaskId !== void 0 ? { runTaskId: input.runTaskId } : {},
+          ...input.lastResult !== void 0 ? { lastResult: input.lastResult } : {},
+          ...input.error !== void 0 ? { error: input.error } : {},
+          ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
+          ...input.leaseId !== void 0 ? { leaseId: input.leaseId } : {},
+          ...input.claimedAt !== void 0 ? { claimedAt: input.claimedAt } : {},
+          ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
+          ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
+          ...input.attempt !== void 0 ? { attempt: input.attempt } : {},
+          ...input.maxAttempts !== void 0 ? { maxAttempts: input.maxAttempts } : {}
+        },
+        input.expectedLeaseId !== void 0 ? { expectedLeaseId: input.expectedLeaseId } : {}
+      );
+      if (!board) return fail("Task not found.");
+      if (assignmentStatus === "completed" && board.lifecycle?.mode !== "managed") {
+        const envGate = readEnvGateEnforcement();
+        const finalized = await finalizeTaskCompletion(projectRoot, board.id, input.taskId, {
+          ...board.completionGate === void 0 && envGate !== void 0 ? { enforcement: envGate } : {},
+          ...ctx.agentId !== void 0 ? { eventContext: { actor: ctx.agentId } } : {}
+        });
+        if (finalized) {
+          if (finalized.gate.report) {
+            recordKanbanVerificationEvidence(ctx, finalized.gate.report);
+          }
+          const gateSummary = {
+            enforcement: finalized.gate.enforcement,
+            allowed: finalized.gate.allowed,
+            verdict: finalized.gate.verdict,
+            issues: finalized.gate.issues.map((issue) => issue.message)
+          };
+          const gateMessage = finalized.gate.allowed ? `Completion gate ${finalized.gate.verdict === "skipped" ? "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(" | ")}`;
+          return {
+            ...okTask(finalized.board, finalized.task, `Assignment updated. ${gateMessage}`),
+            gate: gateSummary
+          };
+        }
+      } else if (board.lifecycle?.mode === "managed") {
+        const managedTask = board.tasks.find((candidate) => candidate.id === input.taskId);
+        const stage = managedTask?.lifecycle?.currentStage;
+        const actor = ctx.agentId ?? "kanban-agent";
+        let transitionResult = null;
+        const lifecycleWarnings = [];
+        if (assignmentStatus === "running" && stage === "todo") {
+          try {
+            transitionResult = await transitionTask(projectRoot, board.id, input.taskId, {
+              to: "running",
+              actor,
+              comment: "Work started."
+            });
+          } catch (err) {
+            lifecycleWarnings.push(
+              `Lifecycle transition to Running deferred: ${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: {
+                ...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
+                });
+                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",
+                      actor,
+                      action: "Automated acceptance after verification",
+                      comment: "Auto-accepted: verification passed.",
+                      attachment: {
+                        url: `kanban://task/${input.taskId}/verification`,
+                        title: "Auto-verification result",
+                        type: "file"
+                      }
+                    });
+                    transitionResult = doneResult;
+                  } catch (acceptErr) {
+                    lifecycleWarnings.push(
+                      `Auto-accept to Done deferred: ${acceptErr instanceof Error ? acceptErr.message : String(acceptErr)}`
+                    );
+                  }
+                } else {
+                  lifecycleWarnings.push(
+                    `Verification verdict: ${verdict} \u2014 card left in Review for manual acceptance.`
+                  );
+                }
+              } catch (verifyErr) {
+                lifecycleWarnings.push(
+                  `Auto-verification error: ${verifyErr instanceof Error ? verifyErr.message : String(verifyErr)}`
+                );
+              }
+            } else {
+              lifecycleWarnings.push(
+                "No automatic success criteria \u2014 card left in Review for manual verification."
+              );
+            }
+          }
+        }
+        const responseBoard = transitionResult?.board ?? board;
+        const responseTask = transitionResult?.task ?? managedTask;
+        const msgParts = ["Assignment updated."];
+        if (transitionResult) {
+          msgParts.push(`Card advanced to ${transitionResult.transition.to}.`);
+        }
+        for (const w of lifecycleWarnings) msgParts.push(`Warning: ${w}`);
+        return okTask(responseBoard, responseTask, msgParts.join(" "));
+      }
+      return okBoard(board, "Assignment updated.");
+    }
+    case "heartbeat_assignment": {
+      if (!input.boardId || !input.taskId) {
+        return fail("heartbeat_assignment requires boardId and taskId.");
+      }
+      const board = await heartbeatTaskAssignment(projectRoot, input.boardId, input.taskId, {
+        ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
+        ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
+        ...input.expectedLeaseId !== void 0 ? { expectedLeaseId: input.expectedLeaseId } : {}
+      });
+      return board ? okBoard(board, "Assignment heartbeat updated.") : fail("Task assignment not found.");
+    }
+    case "recover_stale": {
+      if (!input.boardId) return fail("recover_stale requires boardId.");
+      const policyFields = [
+        input.recoveryPolicyFailOnCostCeiling !== void 0,
+        input.recoveryPolicyReleaseOnFailureKinds !== void 0,
+        input.recoveryPolicyReleaseOnHeartbeatDue !== void 0,
+        input.recoveryPolicyRetryPolicyOverride !== void 0
+      ].some(Boolean);
+      const 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
+            } : {}
+          }
+        } : {}
+      });
+      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 as touchKanbanPresence2 } 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 touchKanbanPresence2(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
@@ -1590,8 +2386,6 @@ var kanbanTool = {
   description: KANBAN_TOOL_DESCRIPTION,
   usageHint: KANBAN_TOOL_USAGE_HINT,
   permission: "confirm",
-  // WS-046: gives permission decisions something to key on.
-  // The action performed; kanban has no single file or path subject.
   subjectKey: "action",
   mutating: true,
   capabilities: ["fs.write"],
@@ -1606,873 +2400,29 @@ var kanbanTool = {
       const result = await (async () => {
         const decompositionResult = await handleKanbanDecompositionAction(projectRoot, input, ctx);
         if (decompositionResult !== void 0) return decompositionResult;
-        switch (input.action) {
-          case "list_boards": {
-            const boards = await listBoards2(projectRoot);
-            return { ok: true, message: `${boards.length} board(s).`, boards };
-          }
-          case "get_board": {
-            const board = await requireBoard(projectRoot, input.boardId);
-            return board ? okBoard(board) : fail("Board not found.");
-          }
-          case "create_board": {
-            if (!input.title) return fail("create_board requires title.");
-            const existing = (await listBoards2(projectRoot)).filter(
-              (candidate) => (candidate.kind ?? "project") === "project"
-            );
-            const board = await createBoard2(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 updateBoard2(projectRoot, input.boardId, boardUpdatePatch(input));
-            return board ? okBoard(board, "Board updated.") : fail("Board not found.");
-          }
-          case "adopt_managed_lifecycle": {
-            if (!input.boardId || !input.author || !input.transitionComment) {
-              return fail(
-                "adopt_managed_lifecycle requires boardId, author, transitionComment, and five ordered columns."
-              );
-            }
-            if (input.columns?.length !== 5) {
-              return fail(
-                "adopt_managed_lifecycle columns must be ordered as backlog, todo, running, review, done."
-              );
-            }
-            const [backlog, todo, running, review, done] = input.columns;
-            if (!backlog || !todo || !running || !review || !done) {
-              return fail("adopt_managed_lifecycle columns must contain five nonblank ids.");
-            }
-            const board = await adoptManagedLifecycle(projectRoot, input.boardId, {
-              columns: { backlog, todo, running, review, done },
-              actor: input.author,
-              comment: input.transitionComment
-            });
-            return board ? okBoard(board, "Managed lifecycle adopted without moving existing cards.") : fail("Board not found.");
-          }
-          // 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)
-            );
-            return board ? okBoard(board, "Board duplicated.") : fail("Board not found.");
-          }
-          case "delete_board": {
-            if (!input.boardId) return fail("delete_board requires boardId.");
-            const removed = await removeBoard2(projectRoot, input.boardId);
-            return { ok: removed, message: removed ? "Board deleted." : "Board not found." };
-          }
-          case "generate_board": {
-            if (!input.description) return fail("generate_board requires description.");
-            const boardInput = createBoardFromText({
-              description: input.description,
-              ...input.title !== void 0 ? { title: input.title } : {},
-              ...input.context !== void 0 ? { context: input.context } : {}
-            });
-            const board = await createBoard2(projectRoot, boardInput);
-            for (const taskInput2 of parseLinesIntoTasks(
-              input.description,
-              board.columns[0]?.id ?? "backlog"
-            )) {
-              await addTask(projectRoot, board.id, taskInput2);
-            }
-            return okBoard(await getBoard3(projectRoot, board.id) ?? board, "Board generated.");
-          }
-          case "export_markdown": {
-            const board = await requireBoard(projectRoot, input.boardId);
-            if (!board) return fail("Board not found.");
-            return {
-              ok: true,
-              message: "Board exported.",
-              board,
-              markdown: exportBoardAsMarkdown(board)
-            };
-          }
-          case "export_task_graph": {
-            if (!input.boardId) return fail("export_task_graph requires boardId.");
-            const exported = await exportBoardToTaskGraph(projectRoot, input.boardId, {
-              ...input.graphId !== void 0 ? { graphId: input.graphId } : {},
-              ...input.specId !== void 0 ? { specId: input.specId } : {},
-              ...input.title !== void 0 ? { title: input.title } : {},
-              ...input.preserveOriginTaskIds !== void 0 ? { preserveOriginTaskIds: input.preserveOriginTaskIds } : {},
-              ...input.includeArchived !== void 0 ? { includeArchived: input.includeArchived } : {}
-            });
-            if (!exported) return fail("Board not found.");
-            return {
-              ok: true,
-              message: `Task graph exported with ${exported.graph.nodes.size} node(s).`,
-              board: exported.board,
-              taskGraph: serializeTaskGraph(exported.graph)
-            };
-          }
-          case "sync_task_graph": {
-            if (!input.boardId || !input.taskGraph) {
-              return fail("sync_task_graph requires boardId and taskGraph.");
-            }
-            const graph = deserializeTaskGraph2(input.taskGraph);
-            const result2 = await syncBoardFromTaskGraph2(projectRoot, input.boardId, graph, {
-              ...input.title !== void 0 ? { title: input.title } : {},
-              ...input.description !== void 0 ? { description: input.description } : {},
-              ...input.tags !== void 0 ? { tags: input.tags } : {},
-              ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
-              ...input.sourceSystem !== void 0 ? { sourceSystem: input.sourceSystem } : {},
-              ...input.phaseId !== void 0 ? { phaseId: input.phaseId } : {},
-              ...input.includeCompletedTasks !== void 0 ? { includeCompletedTasks: input.includeCompletedTasks } : {},
-              ...input.archiveMissingTasks !== void 0 ? { archiveMissingTasks: input.archiveMissingTasks } : {},
-              ...input.preserveManualDependencies !== void 0 ? { preserveManualDependencies: input.preserveManualDependencies } : {}
-            });
-            return result2 ? {
-              ok: true,
-              message: `Task graph synced: ${result2.createdTaskIds.length} created, ${result2.updatedTaskIds.length} updated, ${result2.archivedTaskIds.length} archived.`,
-              board: result2.board
-            } : fail("Board not found.");
-          }
-          case "create_from_graph": {
-            if (!input.taskGraph) return fail("create_from_graph requires taskGraph.");
-            const graph = deserializeTaskGraph2(input.taskGraph);
-            const { board } = await createBoardFromTaskGraph(projectRoot, graph, {
-              ...input.title !== void 0 ? { title: input.title } : {},
-              ...input.description !== void 0 ? { description: input.description } : {},
-              ...input.tags !== void 0 ? { tags: input.tags } : {},
-              ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
-              ...input.sourceSystem !== void 0 ? { sourceSystem: input.sourceSystem } : {},
-              ...input.phaseId !== void 0 ? { phaseId: input.phaseId } : {},
-              ...input.includeCompletedTasks !== void 0 ? { includeCompletedTasks: input.includeCompletedTasks } : {}
-            });
-            return {
-              ok: true,
-              message: `Created board "${board.title}" from task graph with ${board.tasks.length} tasks.`,
-              board
-            };
-          }
-          case "import_session_tasks": {
-            const taskPath = ctx.meta?.["task.path"];
-            if (!taskPath) return fail("No session task file for this session.");
-            const file = await loadTasks2(taskPath);
-            if (!file || file.tasks.length === 0) return fail("No session tasks to import.");
-            const sessionId = ctx.session?.id ?? file.sessionId ?? "session";
-            const graph = deserializeTaskGraph2(taskFileToSerializedGraph(file.tasks, sessionId));
-            const tags = ["session", `session:${sessionId}`];
-            const existing = (await listBoards2(projectRoot)).find(
-              (b) => b.tags?.includes(`session:${sessionId}`)
-            );
-            if (existing) {
-              const result2 = await syncBoardFromTaskGraph2(projectRoot, existing.id, graph, {
-                sourceSystem: "session",
-                tags,
-                archiveMissingTasks: true,
-                includeCompletedTasks: true
-              });
-              return result2 ? {
-                ok: true,
-                message: `Synced ${file.tasks.length} session tasks into board "${result2.board.title}".`,
-                board: result2.board
-              } : fail("Session board vanished mid-sync.");
-            }
-            const { board } = await createBoardFromTaskGraph(projectRoot, graph, {
-              title: `Session tasks (${sessionId.slice(0, 8)})`,
-              sourceSystem: "session",
-              tags
-            });
-            return {
-              ok: true,
-              message: `Imported ${file.tasks.length} session tasks into new board "${board.title}".`,
-              board
-            };
-          }
-          case "search_tasks": {
-            const tasks = await searchKanban(projectRoot, {
-              query: input.query,
-              boardId: input.boardId,
-              assignedAgent: input.agentId,
-              status: input.status,
-              priority: input.priority,
-              label: input.labels?.[0],
-              chainId: input.chainId
-            });
-            return { ok: true, message: `${tasks.length} task(s) matched.`, tasks };
-          }
-          case "ready_tasks": {
-            const tasks = await listReadyTasks(projectRoot, {
-              query: input.query,
-              boardId: input.boardId,
-              assignedAgent: input.agentId,
-              priority: input.priority,
-              label: input.labels?.[0],
-              chainId: input.chainId,
-              limit: input.limit
-            });
-            return { ok: true, message: `${tasks.length} ready task(s).`, tasks };
-          }
-          case "snapshot": {
-            const snapshot = await getKanbanOrchestrationSnapshot2(projectRoot, {
-              query: input.query,
-              boardId: input.boardId,
-              assignedAgent: input.agentId,
-              status: input.status,
-              priority: input.priority,
-              label: input.labels?.[0],
-              chainId: input.chainId
-            });
-            return {
-              ok: true,
-              message: `${snapshot.ready.length} ready, ${snapshot.running.length} running, ${snapshot.blocked.length} blocked.`,
-              snapshot
-            };
-          }
-          case "add_task": {
-            if (!input.boardId || !input.title) return fail("add_task requires boardId and title.");
-            const result2 = await addTask(projectRoot, input.boardId, taskInput(input));
-            if (!result2) return fail("Board not found.");
-            return okTask(result2.board, result2.task, `Task added.${atomicityNudge(result2.task)}`);
-          }
-          case "split_task": {
-            if (!input.boardId || !input.taskId || !input.childTitles?.length) {
-              return fail("split_task requires boardId, taskId, and childTitles.");
-            }
-            return handleSplitTask(projectRoot, input, {});
-          }
-          case "merge_tasks": {
-            if (!input.boardId || !input.taskIds?.length || !input.title) {
-              return fail("merge_tasks requires boardId, taskIds, and title.");
-            }
-            const result2 = await mergeTasks(projectRoot, input.boardId, {
-              taskIds: input.taskIds,
-              title: input.title,
-              ...input.description !== void 0 ? { description: input.description } : {},
-              ...input.targetColumnId !== void 0 ? { targetColumnId: input.targetColumnId } : {},
-              ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {},
-              ...input.closeSourceTasks !== void 0 ? { closeSourceTasks: input.closeSourceTasks } : {}
-            });
-            return result2 ? okTask(result2.board, result2.task, "Tasks merged.") : fail("Board or task not found.");
-          }
-          case "copy_task": {
-            if (!input.boardId || !input.taskId || !input.targetBoardId) {
-              return fail("copy_task requires boardId, taskId, and targetBoardId.");
-            }
-            const result2 = await copyTaskToBoard(
-              projectRoot,
-              input.boardId,
-              input.taskId,
-              input.targetBoardId,
-              {
-                ...input.targetColumnId !== void 0 ? { targetColumnId: input.targetColumnId } : {},
-                ...input.order !== void 0 ? { targetOrder: input.order } : {},
-                ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {},
-                ...input.preserveDependencies !== void 0 ? { preserveDependencies: input.preserveDependencies } : {}
-              }
-            );
-            return result2 ? okTask(result2.targetBoard, result2.task, "Task copied to target board.") : fail("Board or task not found.");
-          }
-          case "transfer_task": {
-            if (!input.boardId || !input.taskId || !input.targetBoardId) {
-              return fail("transfer_task requires boardId, taskId, and targetBoardId.");
-            }
-            const result2 = await transferTaskToBoard(
-              projectRoot,
-              input.boardId,
-              input.taskId,
-              input.targetBoardId,
-              {
-                ...input.targetColumnId !== void 0 ? { targetColumnId: input.targetColumnId } : {},
-                ...input.order !== void 0 ? { targetOrder: input.order } : {},
-                ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {},
-                ...input.preserveDependencies !== void 0 ? { preserveDependencies: input.preserveDependencies } : {}
-              }
-            );
-            return result2 ? okTask(result2.targetBoard, result2.task, "Task transferred to target board.") : fail("Board or task not found.");
-          }
-          case "get_task": {
-            if (!input.boardId || !input.taskId)
-              return fail("get_task requires boardId and taskId.");
-            const task = await getTask(projectRoot, input.boardId, input.taskId);
-            return task ? { ok: true, message: "Task loaded.", task } : fail("Task not found.");
-          }
-          case "start_task": {
-            if (!input.boardId || !input.taskId || !input.author || !input.transitionComment) {
-              return fail("start_task requires boardId, taskId, author, and transitionComment.");
-            }
-            let board = await getBoard3(projectRoot, input.boardId);
-            let task = board?.tasks.find((candidate) => candidate.id === input.taskId);
-            if (!board || !task) return fail("Board or task not found.");
-            const readiness = evaluateContractGraphReadiness(board, task.id);
-            if (!readiness.ready) {
-              return fail(
-                `Task is not implementation-ready: ${readiness.issues.map((issue) => issue.message).join(" | ")}`
-              );
-            }
-            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.");
-            const board = await updateTask2(
-              projectRoot,
-              input.boardId,
-              input.taskId,
-              taskPatch(input)
-            );
-            return board ? okBoard(board, "Task updated.") : fail("Task not found.");
-          }
-          case "transition_task": {
-            if (!input.boardId || !input.taskId || !input.lifecycleStage || !input.author || !input.transitionComment) {
-              return fail(
-                "transition_task requires boardId, taskId, lifecycleStage, author, and transitionComment."
-              );
-            }
-            if (input.lifecycleStage === "done") {
-              const boardBefore = await getBoard3(projectRoot, input.boardId);
-              const taskBefore = boardBefore ? await getTask(projectRoot, input.boardId, input.taskId) : null;
-              if (boardBefore && taskBefore && !taskBefore.verificationReport && (taskBefore.atomic || Boolean(taskBefore.successCriteria?.length))) {
-                const preGate = await verifyTaskCompletion2(
-                  projectRoot,
-                  input.boardId,
-                  taskBefore.id,
-                  {
-                    persist: false
-                  }
-                );
-                await updateTask2(projectRoot, input.boardId, taskBefore.id, {
-                  verificationReport: preGate.report,
-                  successCriteria: preGate.task.successCriteria
-                });
-              }
-            }
-            const result2 = await transitionTask(projectRoot, input.boardId, input.taskId, {
-              to: input.lifecycleStage,
-              actor: input.author,
-              comment: input.transitionComment,
-              ...input.transitionAction !== void 0 ? { action: input.transitionAction } : {},
-              ...input.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 (result2 && input.lifecycleStage === "done" && result2.task.verificationReport) {
-              recordKanbanVerificationEvidence(ctx, result2.task.verificationReport);
-            }
-            return result2 ? okTask(result2.board, result2.task, `Task advanced to ${result2.transition.to}.`) : fail("Board or task not found.");
-          }
-          case "repair_managed_projection": {
-            if (!input.boardId || !input.taskId || !input.author || !input.transitionComment) {
-              return fail(
-                "repair_managed_projection requires boardId, taskId, author, and transitionComment."
-              );
-            }
-            const result2 = await repairManagedTaskProjection(
-              projectRoot,
-              input.boardId,
-              input.taskId,
-              {
-                actor: input.author,
-                comment: input.transitionComment
-              }
-            );
-            return result2 ? okTask(
-              result2.board,
-              result2.task,
-              "Managed card projection repaired from lifecycle history."
-            ) : fail("Board or task not found.");
-          }
-          case "move_task": {
-            if (!input.boardId || !input.taskId || !input.targetColumnId) {
-              return fail("move_task requires boardId, taskId, and targetColumnId.");
-            }
-            const board = await moveTask(
-              projectRoot,
-              input.boardId,
-              input.taskId,
-              input.targetColumnId,
-              input.order
-            );
-            return board ? okBoard(board, "Task moved.") : fail("Move failed.");
-          }
-          case "delete_task": {
-            if (!input.boardId || !input.taskId)
-              return fail("delete_task requires boardId and taskId.");
-            const board = await removeTask(projectRoot, input.boardId, input.taskId);
-            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": {
-            if (!input.boardId || !input.taskIds?.length) {
-              return fail("set_chain requires boardId and taskIds.");
-            }
-            const result2 = await setTaskChain(projectRoot, input.boardId, {
-              taskIds: input.taskIds,
-              ...input.chainId !== void 0 ? { chainId: input.chainId } : {},
-              ...input.enforceDependencies !== void 0 ? { enforceDependencies: input.enforceDependencies } : {}
-            });
-            return result2 ? {
-              ok: true,
-              message: `Chain set: ${result2.chainId}`,
-              board: result2.board,
-              chain: result2.tasks
-            } : fail("Board or task not found.");
-          }
-          case "get_chain": {
-            if (!input.boardId || !(input.taskId || input.chainId)) {
-              return fail("get_chain requires boardId and taskId or chainId.");
-            }
-            const result2 = await getTaskChain(
-              projectRoot,
-              input.boardId,
-              input.taskId ?? input.chainId ?? ""
-            );
-            return result2 ? {
-              ok: true,
-              message: `Chain loaded: ${result2.chainId}`,
-              board: result2.board,
-              chain: result2.tasks
-            } : fail("Chain not found.");
-          }
-          case "claim_task": {
-            const result2 = await claimReadyTask(projectRoot, {
-              ...input.boardId !== void 0 ? { boardId: input.boardId } : {},
-              ...input.taskId !== void 0 ? { taskId: input.taskId } : {},
-              ...assignmentInput(input),
-              status: input.assignmentStatus ?? "queued"
-            });
-            return result2 ? okTask(result2.board, result2.task, "Task claimed.") : fail("No ready kanban task matched the claim.");
-          }
-          case "release_task": {
-            if (!input.boardId || !input.taskId) {
-              return fail("release_task requires boardId and taskId.");
-            }
-            const board = await releaseTaskClaim(projectRoot, input.boardId, input.taskId, {
-              ...input.releaseStatus !== void 0 ? { status: input.releaseStatus } : {},
-              ...input.releaseReason !== void 0 ? { reason: input.releaseReason } : {},
-              ...input.clearAssignee !== void 0 ? { clearAssignee: input.clearAssignee } : {}
-            });
-            return board ? okBoard(board, "Task claim released.") : fail("Task not found.");
-          }
-          case "assign_task": {
-            if (!input.boardId || !input.taskId)
-              return fail("assign_task requires boardId and taskId.");
-            const board = await assignTask(
-              projectRoot,
-              input.boardId,
-              input.taskId,
-              assignmentInput(input)
-            );
-            return board ? okBoard(board, "Task assigned.") : fail("Task not found.");
-          }
-          case "mark_assignment": {
-            if (!input.boardId || !input.taskId)
-              return fail("mark_assignment requires boardId and taskId.");
-            const assignmentStatus = input.assignmentStatus ?? (input.status === "completed" ? "completed" : input.error ? "failed" : void 0);
-            const board = await updateTaskAssignment(
-              projectRoot,
-              input.boardId,
-              input.taskId,
-              {
-                ...assignmentStatus !== void 0 ? { status: assignmentStatus } : {},
-                ...input.subagentId !== void 0 ? { subagentId: input.subagentId } : {},
-                ...input.runTaskId !== void 0 ? { runTaskId: input.runTaskId } : {},
-                ...input.lastResult !== void 0 ? { lastResult: input.lastResult } : {},
-                ...input.error !== void 0 ? { error: input.error } : {},
-                ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
-                ...input.leaseId !== void 0 ? { leaseId: input.leaseId } : {},
-                ...input.claimedAt !== void 0 ? { claimedAt: input.claimedAt } : {},
-                ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
-                ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
-                ...input.attempt !== void 0 ? { attempt: input.attempt } : {},
-                ...input.maxAttempts !== void 0 ? { maxAttempts: input.maxAttempts } : {}
-              },
-              // Ownership fence: when expectedLeaseId is supplied, the write is
-              // applied only if the current assignment still holds this lease.
-              // This prevents a recovered+reassigned stale worker's terminal
-              // mark_assignment from overwriting the successor's state. The check
-              // is atomic inside updateTaskAssignment's mutateBoard lock.
-              input.expectedLeaseId !== void 0 ? { expectedLeaseId: input.expectedLeaseId } : {}
-            );
-            if (!board) return fail("Task not found.");
-            if (assignmentStatus === "completed" && board.lifecycle?.mode !== "managed") {
-              const envGate = readEnvGateEnforcement();
-              const finalized = await finalizeTaskCompletion(projectRoot, board.id, input.taskId, {
-                ...board.completionGate === void 0 && envGate !== void 0 ? { enforcement: envGate } : {},
-                ...ctx.agentId !== void 0 ? { eventContext: { actor: ctx.agentId } } : {}
-              });
-              if (finalized) {
-                if (finalized.gate.report) {
-                  recordKanbanVerificationEvidence(ctx, finalized.gate.report);
-                }
-                const gateSummary = {
-                  enforcement: finalized.gate.enforcement,
-                  allowed: finalized.gate.allowed,
-                  verdict: finalized.gate.verdict,
-                  issues: finalized.gate.issues.map((issue) => issue.message)
-                };
-                const gateMessage = finalized.gate.allowed ? `Completion gate ${finalized.gate.verdict === "skipped" ? "skipped" : "passed"}; task completed.` : finalized.gate.enforcement === "strict" ? `Completion gate BLOCKED (verdict: ${finalized.gate.verdict}); task parked in review. Issues: ${gateSummary.issues.join(" | ")}` : `Completion gate failed softly (verdict: ${finalized.gate.verdict}); task completed with warnings. Issues: ${gateSummary.issues.join(" | ")}`;
-                return {
-                  ...okTask(finalized.board, finalized.task, `Assignment updated. ${gateMessage}`),
-                  gate: gateSummary
-                };
-              }
-            } else if (board.lifecycle?.mode === "managed") {
-              const managedTask = board.tasks.find((candidate) => candidate.id === input.taskId);
-              const stage = managedTask?.lifecycle?.currentStage;
-              const actor = ctx.agentId ?? "kanban-agent";
-              let transitionResult = null;
-              const lifecycleWarnings = [];
-              if (assignmentStatus === "running" && stage === "todo") {
-                try {
-                  transitionResult = await transitionTask(projectRoot, board.id, input.taskId, {
-                    to: "running",
-                    actor,
-                    comment: "Work started."
-                  });
-                } catch (err) {
-                  lifecycleWarnings.push(
-                    `Lifecycle transition to Running deferred: ${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 } : {}
-                    }
-                  });
-                } 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
-                      });
-                      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",
-                              actor,
-                              action: "Automated acceptance after verification",
-                              comment: "Auto-accepted: verification passed.",
-                              attachment: {
-                                url: `kanban://task/${input.taskId}/verification`,
-                                title: "Auto-verification result",
-                                type: "file"
-                              }
-                            }
-                          );
-                          transitionResult = doneResult;
-                        } catch (acceptErr) {
-                          lifecycleWarnings.push(
-                            `Auto-accept to Done deferred: ${acceptErr instanceof Error ? acceptErr.message : String(acceptErr)}`
-                          );
-                        }
-                      } else {
-                        lifecycleWarnings.push(
-                          `Verification verdict: ${verdict} \u2014 card left in Review for manual acceptance.`
-                        );
-                      }
-                    } catch (verifyErr) {
-                      lifecycleWarnings.push(
-                        `Auto-verification error: ${verifyErr instanceof Error ? verifyErr.message : String(verifyErr)}`
-                      );
-                    }
-                  } else {
-                    lifecycleWarnings.push(
-                      "No automatic success criteria \u2014 card left in Review for manual verification."
-                    );
-                  }
-                }
-              }
-              const responseBoard = transitionResult?.board ?? board;
-              const responseTask = transitionResult?.task ?? managedTask;
-              const msgParts = ["Assignment updated."];
-              if (transitionResult) {
-                msgParts.push(`Card advanced to ${transitionResult.transition.to}.`);
-              }
-              for (const w of lifecycleWarnings) msgParts.push(`Warning: ${w}`);
-              return okTask(responseBoard, responseTask, msgParts.join(" "));
-            }
-            return okBoard(board, "Assignment updated.");
-          }
-          case "heartbeat_assignment": {
-            if (!input.boardId || !input.taskId) {
-              return fail("heartbeat_assignment requires boardId and taskId.");
-            }
-            const board = await heartbeatTaskAssignment(projectRoot, input.boardId, input.taskId, {
-              ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
-              ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
-              // Ownership fence: when expectedLeaseId is supplied, the renewal
-              // is applied only if the current assignment still holds this lease.
-              // This prevents a recovered+reassigned stale worker's heartbeat
-              // from renewing the successor's lease. The check is atomic inside
-              // heartbeatTaskAssignment's mutateBoard lock.
-              ...input.expectedLeaseId !== void 0 ? { expectedLeaseId: input.expectedLeaseId } : {}
-            });
-            return board ? okBoard(board, "Assignment heartbeat updated.") : fail("Task assignment not found.");
-          }
-          case "recover_stale": {
-            if (!input.boardId) return fail("recover_stale requires boardId.");
-            const policyFields = [
-              input.recoveryPolicyFailOnCostCeiling !== void 0,
-              input.recoveryPolicyReleaseOnFailureKinds !== void 0,
-              input.recoveryPolicyReleaseOnHeartbeatDue !== void 0,
-              input.recoveryPolicyRetryPolicyOverride !== void 0
-            ].some(Boolean);
-            const result2 = await recoverStaleTaskAssignments(projectRoot, input.boardId, {
-              ...input.recoveryMode !== void 0 ? { mode: input.recoveryMode } : {},
-              ...input.recoveryNow !== void 0 ? { now: input.recoveryNow } : {},
-              ...input.releaseReason !== void 0 ? { reason: input.releaseReason } : {},
-              ...input.clearAssignee !== void 0 ? { clearAssignee: input.clearAssignee } : {},
-              ...policyFields ? {
-                policy: {
-                  ...input.recoveryPolicyFailOnCostCeiling !== void 0 ? { failWhenCostCeilingSet: input.recoveryPolicyFailOnCostCeiling } : {},
-                  ...input.recoveryPolicyReleaseOnFailureKinds !== void 0 ? {
-                    releaseOnFailureKinds: input.recoveryPolicyReleaseOnFailureKinds
-                  } : {},
-                  ...input.recoveryPolicyReleaseOnHeartbeatDue !== void 0 ? {
-                    releaseOnHeartbeatDue: input.recoveryPolicyReleaseOnHeartbeatDue
-                  } : {},
-                  ...input.recoveryPolicyRetryPolicyOverride !== void 0 ? {
-                    retryPolicyOverride: input.recoveryPolicyRetryPolicyOverride
-                  } : {}
-                }
-              } : {}
-            });
-            return result2 ? {
-              ok: true,
-              message: `Recovered ${result2.tasks.length} stale assignment(s).`,
-              board: result2.board,
-              recoveredTasks: result2.tasks
-            } : { ok: true, message: "No stale assignment matched.", recoveredTasks: [] };
-          }
-          case "events": {
-            if (!input.boardId) return fail("events requires boardId.");
-            const eventList = await listKanbanEvents(projectRoot, input.boardId);
-            return {
-              ok: true,
-              message: `${eventList.length} event(s).`,
-              events: eventList
-            };
-          }
-          case "queue_health": {
-            const health = await getKanbanQueueHealth(projectRoot, {
-              ...input.boardId !== void 0 ? { boardId: input.boardId } : {}
-            });
-            return {
-              ok: true,
-              message: `Counts: 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;
-            }
-            return fail(`Unknown kanban action: ${input.action}`);
-        }
+        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
+        );
+        if (contractResult !== void 0) return contractResult;
+        const detailResult = await handleKanbanDetailAction(projectRoot, input);
+        if (detailResult !== void 0) return detailResult;
+        return fail(`Unknown kanban action: ${input.action}`);
       })();
       return withPresence(result);
     } catch (err) {
-      return fail(stripLifecycleIssues(err instanceof Error ? err.message : String(err)));
+      return fail(stripLifecycleIssues2(err instanceof Error ? err.message : String(err)));
     }
   },
   serialize(output, input) {
     return serializeKanbanOutput(output, input);
   }
 };
-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/todo.ts
 function normalizedTitle(value) {
@@ -2530,7 +2480,7 @@ async function createMissingManagedCards(items, board, ctx, warnings) {
   for (const item of items) {
     if (item.kanbanBoardId === board.id && item.kanbanTaskId) continue;
     try {
-      const result = await addTask2(ctx.projectRoot, board.id, {
+      const result = await addTask3(ctx.projectRoot, board.id, {
         title: item.content,
         description: item.activeForm?.trim() || `Added from the session todo list: ${item.content}`
       });
@@ -2624,7 +2574,7 @@ async function synchronizeManagedKanban(items, board, ctx, signal) {
     });
   }
   const attemptedParents = /* @__PURE__ */ new Set();
-  let afterCompletions = await getBoard4(ctx.projectRoot, board.id);
+  let afterCompletions = await getBoard5(ctx.projectRoot, board.id);
   while (afterCompletions) {
     const parent = afterCompletions.tasks.find(
       (task) => task.atomic === true && task.status !== "completed" && Boolean(task.childTaskIds?.length) && !attemptedParents.has(task.id) && task.childTaskIds?.every(
@@ -2651,7 +2601,7 @@ async function synchronizeManagedKanban(items, board, ctx, signal) {
         lastResult: "All child tasks completed; composite result ready for verification."
       });
     }
-    afterCompletions = await getBoard4(ctx.projectRoot, board.id);
+    afterCompletions = await getBoard5(ctx.projectRoot, board.id);
   }
   const completionPending = items.some(
     (item) => item.status === "completed" && item.kanbanBoardId === board.id && Boolean(item.kanbanTaskId) && afterCompletions?.tasks.find((task) => task.id === item.kanbanTaskId)?.status !== "completed"
@@ -2764,7 +2714,7 @@ var todoTool = {
       }
     }
     const boardId = activeBoardId(items, ctx);
-    let board = boardId ? await getBoard4(ctx.projectRoot, boardId) : null;
+    let board = boardId ? await getBoard5(ctx.projectRoot, boardId) : null;
     const managed = board?.lifecycle?.mode === "managed";
     let boundItems = managed && board ? bindTodosToBoard(items, ctx.todos ?? [], board) : items;
     const creationWarnings = [];
@@ -2776,7 +2726,7 @@ var todoTool = {
           const taskId = created.get(item.id);
           return taskId ? { ...item, kanbanBoardId: managedBoardId, kanbanTaskId: taskId } : item;
         });
-        board = await getBoard4(ctx.projectRoot, managedBoardId) ?? board;
+        board = await getBoard5(ctx.projectRoot, managedBoardId) ?? board;
         boundItems = bindTodosToBoard(boundItems, ctx.todos ?? [], board);
       }
       boundItems = demoteBlockedInProgress(boundItems, creationWarnings);
@@ -2798,10 +2748,10 @@ var todoTool = {
     if (mirrorFailure) kanbanSync.warnings.push(mirrorFailure);
     let projectedBoard = board;
     if (managed && board) {
-      const refreshed = await getBoard4(ctx.projectRoot, board.id);
+      const refreshed = await getBoard5(ctx.projectRoot, board.id);
       if (refreshed) {
         projectedBoard = refreshed;
-        applyManagedKanbanBoardToTodos(ctx, refreshed);
+        applyManagedKanbanBoardToTodos2(ctx, refreshed);
       }
     }
     if (!managed) {