@wrongstack/tools 0.310.1 → 0.313.1

package/dist/plan.js

@@ -1,3290 +1,9 @@
-// src/plan.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
 import {
-  addPlanItem,
-  clearPlan,
-  deriveTodosFromPlanItem,
-  formatPlan,
-  getPlanTemplate,
-  mutatePlan as mutatePlan2,
-  mutateTasks as mutateTasks2,
-  removePlanItem,
-  setPlanItemStatus as setPlanItemStatus2
-} from "@wrongstack/core/storage";
-import { formatTaskList } from "@wrongstack/core/utils";
-
-// src/session-kanban.ts
-import { loadPlan, loadTasks } from "@wrongstack/core/storage";
-import { deserializeTaskGraph } from "@wrongstack/core/tasking";
-import {
-  bridgeKanbanSupervisor,
-  compactSessionMirrorBoard,
-  createBoard,
-  DEFAULT_COLUMNS,
-  getBoard,
-  getKanbanOrchestrationSnapshot,
-  listBoards,
-  pruneSessionBoards,
-  removeBoard,
-  syncBoardFromTaskGraph,
-  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: `@session:${sessionId}`,
-    type: "status",
-    subject: `Kanban todo list updated (${todos.length} item${todos.length === 1 ? "" : "s"})`,
-    body: `Shared Kanban board synced this session's todo list: ${todos.length} item${todos.length === 1 ? "" : "s"} \u2014 ${statusCounts.completed} completed, ${statusCounts.inProgress} in progress, ${statusCounts.pending} pending.`,
-    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, options = {}) {
-  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 ownerSessionId = options.sessionOwnerFromTags?.(board.tags);
-  if (ownerSessionId && ownerSessionId !== (context.session?.id ?? "")) {
-    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];
-}
-async function applySessionKanbanTaskToSource(context, task, suppressedTodoMirrors2, options = {}) {
-  const originId = task.origin?.taskId;
-  const graphId = task.origin?.graphId ?? "";
-  const isTodoOrigin = task.origin?.system === "session-todo" || graphId.startsWith("todo:");
-  const targetTodo = context.todos?.find(
-    (todo) => originId !== void 0 && todo.id === originId || todo.kanbanTaskId === task.id || todo.id === task.id && !todo.promotedFromPlan && !todo.promotedFromTask
-  );
-  if (isTodoOrigin || targetTodo) {
-    const matchedId = targetTodo?.id ?? originId;
-    if (matchedId) {
-      const mappedStatus = todoStatus(task);
-      const next = options.remove ? context.todos.filter((todo) => todo.id !== matchedId) : context.todos.map(
-        (todo) => todo.id === matchedId ? {
-          ...todo,
-          content: task.title,
-          status: mappedStatus,
-          kanbanTaskId: task.id
-        } : todo
-      );
-      suppressedTodoMirrors2.add(context);
-      try {
-        context.state.replaceTodos(next);
-      } finally {
-        suppressedTodoMirrors2.delete(context);
-      }
-      return { source: "todo", todos: [...context.todos] };
-    }
-  }
-  if (!originId) return { source: null };
-  const id = context.session?.id ?? "";
-  if (task.origin?.system === "session-plan" || graphId.startsWith("plan:")) {
-    const planPath = context.meta["plan.path"];
-    if (typeof planPath !== "string" || !planPath) {
-      throw new Error(
-        "Cannot reflect this Kanban edit back to its plan source: the session has no plan.path configured. The board mutation already succeeded; the plan file is now out of sync."
-      );
-    }
-    const plan = await mutatePlan(planPath, id, (file) => ({
-      ...file,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      items: options.remove ? file.items.filter((item) => item.id !== originId) : file.items.map(
-        (item) => item.id === originId ? {
-          ...item,
-          title: task.title,
-          details: task.description,
-          status: task.status === "completed" ? "done" : task.status === "in_progress" || task.status === "review" ? "in_progress" : "open",
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        } : item
-      )
-    }));
-    return { source: "plan", plan };
-  }
-  if (task.origin?.system === "session-task" || task.origin?.system === "session" || graphId.startsWith("session:")) {
-    const taskPath = context.meta["task.path"];
-    if (typeof taskPath !== "string" || !taskPath) {
-      throw new Error(
-        "Cannot reflect this Kanban edit back to its task source: the session has no task.path configured. The board mutation already succeeded; the task file is now out of sync."
-      );
-    }
-    const tasks = await mutateTasks(taskPath, id, (file) => ({
-      ...file,
-      tasks: options.remove ? file.tasks.filter((item) => item.id !== originId) : file.tasks.map(
-        (item) => item.id === originId ? {
-          ...item,
-          title: task.title,
-          description: task.description,
-          status: sourceStatus(task),
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        } : item
-      )
-    }));
-    return { source: "task", tasks };
-  }
-  return { source: null };
-}
-
-// 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) => ({
-  ...column
-}));
-var boardQueue = /* @__PURE__ */ new Map();
-var boardEnsures = /* @__PURE__ */ new Map();
-var pendingMirrors = /* @__PURE__ */ new Map();
-var activeMirrors = /* @__PURE__ */ new Set();
-var mirrorFailures = /* @__PURE__ */ new Map();
-var suppressedTodoMirrors = /* @__PURE__ */ new WeakSet();
-function boardKey(projectRoot, sessionId) {
-  return `${projectRoot}\0${sessionId}`;
-}
-function mirrorKey(projectRoot, sessionId, sourceSystem) {
-  return `${boardKey(projectRoot, sessionId)}\0${sourceSystem}`;
-}
-function completedReconciliationGraph(latest, candidates) {
-  const latestNodeIds = new Set(latest.nodes.map((node) => node.id));
-  const carriedNodeIds = /* @__PURE__ */ new Set();
-  const completedNodes = candidates.flatMap(
-    (candidate) => candidate.nodes.filter((node) => {
-      if (node.status !== "completed" || latestNodeIds.has(node.id) || carriedNodeIds.has(node.id)) {
-        return false;
-      }
-      carriedNodeIds.add(node.id);
-      return true;
-    })
-  );
-  if (completedNodes.length === 0) return void 0;
-  const carriedRequirements = completedNodes.flatMap(
-    (node) => node.specRequirementId ? [node.specRequirementId] : []
-  );
-  return {
-    ...latest,
-    nodes: [...latest.nodes, ...completedNodes],
-    rootNodes: [.../* @__PURE__ */ new Set([...latest.rootNodes, ...completedNodes.map((node) => node.id)])],
-    ...latest.requiredRequirementIds ? {
-      requiredRequirementIds: [
-        .../* @__PURE__ */ new Set([...latest.requiredRequirementIds, ...carriedRequirements])
-      ]
-    } : {}
-  };
-}
-function sessionTag(sessionId) {
-  return `session:${sessionId}`;
-}
-function sessionBoardTitle(sessionId) {
-  const leaf = sessionId.split(/[\\/]/).filter(Boolean).pop() ?? sessionId;
-  return `Session ${leaf.slice(0, 12)}`;
-}
-function sessionBoardTags(sessionId) {
-  return ["session", SESSION_BOARD_TAG, sessionTag(sessionId)];
-}
-function sessionIdFromTags(tags) {
-  const tag = tags?.find((candidate) => candidate.startsWith("session:"));
-  return tag?.slice("session:".length) || null;
-}
-function sameColumns(columns) {
-  return columns.length === SESSION_KANBAN_COLUMNS.length && columns.every((column, index) => column.id === SESSION_KANBAN_COLUMNS[index]?.id);
-}
-async function ensureSessionKanbanBoard(projectRoot, sessionId) {
-  if (!projectRoot || !sessionId || process.env[MIRROR_DISABLED_ENV] === "0") return null;
-  const key = boardKey(projectRoot, sessionId);
-  const inFlight = boardEnsures.get(key);
-  if (inFlight) return inFlight;
-  const promise = (async () => {
-    const summary = (await listBoards(projectRoot)).find(
-      (board2) => board2.tags?.includes(sessionTag(sessionId))
-    );
-    let board = summary ? await getBoard(projectRoot, summary.id) : null;
-    if (!board) {
-      return createBoard(projectRoot, {
-        title: sessionBoardTitle(sessionId),
-        description: "Live session work: todos, tasks, and plan items.",
-        tags: sessionBoardTags(sessionId),
-        columns: SESSION_KANBAN_COLUMNS,
-        generatedBy: `session-kanban:${sessionId}`,
-        kind: "session_mirror",
-        retention: { mode: "archive_after_ttl", ttlMs: 7 * 24 * 60 * 60 * 1e3 }
-      });
-    }
-    if (!sameColumns(board.columns) || !board.tags?.includes(SESSION_BOARD_TAG)) {
-      board = await updateBoard(projectRoot, board.id, {
-        title: sessionBoardTitle(sessionId),
-        description: "Live session work: todos, tasks, and plan items.",
-        tags: [.../* @__PURE__ */ new Set([...board.tags ?? [], ...sessionBoardTags(sessionId)])],
-        columns: SESSION_KANBAN_COLUMNS
-      }) ?? board;
-    }
-    return board;
-  })();
-  boardEnsures.set(key, promise);
-  try {
-    return await promise;
-  } finally {
-    boardEnsures.delete(key);
-  }
-}
-function enqueueBoardWork(projectRoot, sessionId, work) {
-  const key = boardKey(projectRoot, sessionId);
-  const previous = boardQueue.get(key) ?? Promise.resolve();
-  const result = previous.catch(() => void 0).then(work);
-  const tail = result.then(
-    () => void 0,
-    () => void 0
-  );
-  boardQueue.set(key, tail);
-  void tail.then(() => {
-    if (boardQueue.get(key) === tail) boardQueue.delete(key);
-  });
-  return result;
-}
-async function projectGraph(projectRoot, sessionId, graph, sourceSystem) {
-  if (!projectRoot || !sessionId || process.env[MIRROR_DISABLED_ENV] === "0") return null;
-  return enqueueBoardWork(projectRoot, sessionId, async () => {
-    const board = await ensureSessionKanbanBoard(projectRoot, sessionId);
-    if (!board) return null;
-    const result = await syncBoardFromTaskGraph(
-      projectRoot,
-      board.id,
-      deserializeTaskGraph(graph),
-      {
-        sourceSystem,
-        tags: [.../* @__PURE__ */ new Set([...board.tags ?? [], ...sessionBoardTags(sessionId)])],
-        archiveMissingTasks: true,
-        includeCompletedTasks: true,
-        allowRequirementScopeShrink: true
-      }
-    );
-    if (!result) return null;
-    const compacted = await compactSessionMirrorBoard(projectRoot, board.id);
-    if (compacted?.removedTaskIds.length) {
-      return await getBoard(projectRoot, board.id) ?? result.board;
-    }
-    return result.board;
-  });
-}
-function queueLatestMirror(projectRoot, sessionId, graph, sourceSystem) {
-  if (!projectRoot || !sessionId || process.env[MIRROR_DISABLED_ENV] === "0") return;
-  const key = mirrorKey(projectRoot, sessionId, sourceSystem);
-  const previous = pendingMirrors.get(key);
-  const reconciliationGraph = previous ? completedReconciliationGraph(
-    graph,
-    [previous.reconciliationGraph, previous.graph].filter(
-      (candidate) => candidate !== void 0
-    )
-  ) : void 0;
-  pendingMirrors.set(key, {
-    projectRoot,
-    sessionId,
-    graph,
-    ...reconciliationGraph ? { reconciliationGraph } : {},
-    sourceSystem
-  });
-  if (activeMirrors.has(key)) return;
-  activeMirrors.add(key);
-  void (async () => {
-    try {
-      for (; ; ) {
-        const pending = pendingMirrors.get(key);
-        if (!pending) break;
-        pendingMirrors.delete(key);
-        try {
-          if (pending.reconciliationGraph) {
-            await projectGraph(
-              pending.projectRoot,
-              pending.sessionId,
-              pending.reconciliationGraph,
-              pending.sourceSystem
-            );
-          }
-          await projectGraph(
-            pending.projectRoot,
-            pending.sessionId,
-            pending.graph,
-            pending.sourceSystem
-          );
-          mirrorFailures.delete(boardKey(pending.projectRoot, pending.sessionId));
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          mirrorFailures.set(boardKey(pending.projectRoot, pending.sessionId), {
-            message,
-            sourceSystem: pending.sourceSystem
-          });
-          console.warn(
-            JSON.stringify({
-              level: "warn",
-              event: "session-kanban.mirror-failed",
-              sessionId: pending.sessionId,
-              sourceSystem: pending.sourceSystem,
-              message,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            })
-          );
-        }
-      }
-    } finally {
-      activeMirrors.delete(key);
-      const pending = pendingMirrors.get(key);
-      if (pending) {
-        pendingMirrors.delete(key);
-        queueLatestMirror(
-          pending.projectRoot,
-          pending.sessionId,
-          pending.graph,
-          pending.sourceSystem
-        );
-      }
-    }
-  })();
-}
-function takeSessionMirrorFailure(projectRoot, sessionId) {
-  if (!projectRoot || !sessionId) return void 0;
-  const key = boardKey(projectRoot, sessionId);
-  const failure = mirrorFailures.get(key);
-  if (!failure) return void 0;
-  mirrorFailures.delete(key);
-  return `Kanban mirror (${failure.sourceSystem}) failed and the board may be stale: ${failure.message}`;
-}
-function projectSessionPlanToKanban(projectRoot, items, sessionId) {
-  return projectGraph(
-    projectRoot,
-    sessionId,
-    planFileToSerializedGraph(items, sessionId),
-    "session-plan"
-  );
-}
-function mirrorSessionTodosToKanban(projectRoot, todos, sessionId) {
-  queueLatestMirror(
-    projectRoot,
-    sessionId,
-    todoListToSerializedGraph(todos, sessionId),
-    "session-todo"
-  );
-}
-function applyManagedKanbanBoardToTodos2(context, board) {
-  return applyManagedKanbanBoardToTodos(context, board, suppressedTodoMirrors, {
-    sessionOwnerFromTags: sessionIdFromTags
-  });
-}
-function applySessionKanbanTaskToSource2(context, task, options = {}) {
-  return applySessionKanbanTaskToSource(context, task, suppressedTodoMirrors, options);
-}
-
-// src/todo.ts
-import {
-  loadPlan as loadPlan2,
-  loadTasks as loadTasks3,
-  savePlan,
-  saveTasks,
-  setPlanItemStatus
-} from "@wrongstack/core/storage";
-import { addTask as addTask3, getBoard as getBoard5 } from "@wrongstack/kanban";
-
-// src/kanban.ts
-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,
-  createBoard as createBoard2,
-  createBoardFromTaskGraph,
-  createBoardFromText,
-  duplicateBoard,
-  exportBoardAsMarkdown,
-  exportBoardToTaskGraph,
-  getBoard as getBoard3,
-  getKanbanOrchestrationSnapshot as getKanbanOrchestrationSnapshot2,
-  getKanbanQueueHealth,
-  listBoards as listBoards2,
-  listKanbanEvents,
-  listReadyTasks,
-  parseLinesIntoTasks,
-  removeBoard as removeBoard2,
-  searchKanban,
-  syncBoardFromTaskGraph as syncBoardFromTaskGraph2,
-  updateBoard as updateBoard2
-} from "@wrongstack/kanban";
-
-// src/kanban-board-inputs.ts
-function agentSettableGate(enforcement) {
-  if (enforcement === void 0 || enforcement === "off") return {};
-  return { completionGate: { enforcement } };
-}
-function boardCreateInput(input, title) {
-  return {
-    title,
-    ...input.description !== void 0 ? { description: input.description } : {},
-    ...input.tags !== void 0 ? { tags: input.tags } : {},
-    ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
-    ...input.atomicityMode !== void 0 ? {
-      atomicity: {
-        mode: input.atomicityMode,
-        decomposition: input.atomicityDecomposition ?? "propose"
-      }
-    } : {},
-    ...agentSettableGate(input.gateEnforcement)
-  };
-}
-function boardUpdatePatch(input) {
-  return {
-    ...input.title !== void 0 ? { title: input.title } : {},
-    ...input.description !== void 0 ? { description: input.description } : {},
-    ...input.tags !== void 0 ? { tags: input.tags } : {},
-    ...input.atomicityMode !== void 0 ? {
-      atomicity: {
-        mode: input.atomicityMode,
-        decomposition: input.atomicityDecomposition ?? "propose"
-      }
-    } : {},
-    ...agentSettableGate(input.gateEnforcement)
-  };
-}
-function duplicateBoardOptions(input) {
-  return {
-    ...input.title !== void 0 ? { title: input.title } : {},
-    ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
-    ...input.includeTasks !== void 0 ? { includeTasks: input.includeTasks } : {},
-    ...input.includeCompletedTasks !== void 0 ? { includeCompletedTasks: input.includeCompletedTasks } : {},
-    ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {}
-  };
-}
-
-// src/kanban-split-task-handler.ts
-import { getBoard as getBoard2, splitTask } from "@wrongstack/kanban";
-
-// src/kanban-tool-results.ts
-function atomicityNudge(task) {
-  if (task.atomicityAssessment?.verdict !== "needs_decomposition") return "";
-  const reasons = task.atomicityAssessment.criteria.filter((entry) => entry.score < 1).map((entry) => entry.reason).join(" | ");
-  return ` Atomicity: needs_decomposition (score ${task.atomicityAssessment.score}) \u2014 call propose_decomposition with 2+ subtasks before dispatch. Reasons: ${reasons}`;
-}
-function readEnvGateEnforcement() {
-  const raw = process.env["WRONGSTACK_KANBAN_GATE"]?.trim().toLowerCase();
-  return raw === "strict" || raw === "soft" || raw === "off" ? raw : void 0;
-}
-function fail(message) {
-  return { ok: false, message };
-}
-function okBoard(board, message = "Board loaded.") {
-  return { ok: true, message, board };
-}
-function okTask(board, task, message) {
-  return { ok: true, message, board, task };
-}
-
-// src/kanban-split-task-handler.ts
-async function handleSplitTask(projectRoot, input, extraSplitOptions) {
-  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": {
-      if (!input.boardId) return fail("get_contract_graph requires boardId.");
-      const found = await getContractGraph(projectRoot, input.boardId);
-      if (!found) return fail("Board not found.");
-      const evaluated = input.taskId ? await evaluateTaskContractGraph(projectRoot, input.boardId, input.taskId) : null;
-      if (input.taskId && !evaluated) return fail("Task not found on this board.");
-      return {
-        ok: true,
-        message: found.graph ? `Contract map: ${found.graph.nodes.length} node(s), ${found.graph.edges.length} edge(s), enforcement ${found.graph.enforcement}.` : "No contract map on this board yet. Call configure_contract_graph to start one.",
-        board: found.board,
-        contractGraph: found.graph,
-        ...evaluated ? { contractEvaluation: evaluated.evaluation } : {}
-      };
-    }
-    case "configure_contract_graph": {
-      if (!input.boardId) return fail("configure_contract_graph requires boardId.");
-      const enforcement = input.contractEnforcement ?? "advisory";
-      const board = await configureContractGraph(projectRoot, input.boardId, enforcement);
-      return board ? okBoard(board, `Contract map enforcement set to ${enforcement}.`) : fail("Board not found.");
-    }
-    case "upsert_contract_node": {
-      if (!input.boardId || !input.taskId) {
-        return fail("upsert_contract_node requires boardId and taskId.");
-      }
-      if (!input.contractNodeKind || !input.contractNodeTitle) {
-        return fail("upsert_contract_node requires contractNodeKind and contractNodeTitle.");
-      }
-      const waiver = input.contractNodeState === "waived" ? {
-        actor: actor ?? "agent",
-        reason: input.contractWaiverReason ?? "",
-        at: (/* @__PURE__ */ new Date()).toISOString()
-      } : void 0;
-      if (waiver && !waiver.reason.trim()) {
-        return fail("A waived contract node requires contractWaiverReason.");
-      }
-      const result = await upsertContractNode(projectRoot, input.boardId, {
-        taskId: input.taskId,
-        kind: input.contractNodeKind,
-        title: input.contractNodeTitle,
-        ...input.contractNodeId !== void 0 ? { id: input.contractNodeId } : {},
-        ...input.contractNodeDescription !== void 0 ? { description: input.contractNodeDescription } : {},
-        ...input.contractNodeState !== void 0 ? { state: input.contractNodeState } : {},
-        ...input.contractNodeEnforcement !== void 0 ? { enforcement: input.contractNodeEnforcement } : {},
-        ...input.contractCheckId !== void 0 ? { checkId: input.contractCheckId } : {},
-        ...input.contractMetricId !== void 0 ? { metricId: input.contractMetricId } : {},
-        ...waiver ? { waiver } : {},
-        ...actor !== void 0 ? { createdBy: actor } : {}
-      });
-      if (!result) return fail("Board or task not found.");
-      return {
-        ok: true,
-        message: `Contract node ${result.node.kind} "${result.node.title}" saved (${result.node.id}).`,
-        board: result.board,
-        contractGraph: result.board.contractGraph ?? null
-      };
-    }
-    case "remove_contract_node": {
-      if (!input.boardId || !input.contractNodeId) {
-        return fail("remove_contract_node requires boardId and contractNodeId.");
-      }
-      const board = await removeContractNode(projectRoot, input.boardId, input.contractNodeId);
-      return board ? okBoard(board, "Contract node removed, along with every edge that touched it.") : fail("Contract node not found.");
-    }
-    case "add_contract_edge": {
-      if (!input.boardId || !input.contractEdgeFrom || !input.contractEdgeTo) {
-        return fail("add_contract_edge requires boardId, contractEdgeFrom, and contractEdgeTo.");
-      }
-      if (!input.contractEdgeType) return fail("add_contract_edge requires contractEdgeType.");
-      const result = await addContractEdge(projectRoot, input.boardId, {
-        from: input.contractEdgeFrom,
-        to: input.contractEdgeTo,
-        type: input.contractEdgeType,
-        ...input.contractEdgeId !== void 0 ? { id: input.contractEdgeId } : {},
-        ...input.contractNodeEnforcement !== void 0 ? { enforcement: input.contractNodeEnforcement } : {},
-        ...input.contractEdgeRationale !== void 0 ? { rationale: input.contractEdgeRationale } : {},
-        ...actor !== void 0 ? { createdBy: actor } : {}
-      });
-      if (!result) return fail("Board not found.");
-      return {
-        ok: true,
-        message: `Contract edge ${result.edge.type}: ${result.edge.from} \u2192 ${result.edge.to}.`,
-        board: result.board,
-        contractGraph: result.board.contractGraph ?? null
-      };
-    }
-    case "remove_contract_edge": {
-      if (!input.boardId || !input.contractEdgeId) {
-        return fail("remove_contract_edge requires boardId and contractEdgeId.");
-      }
-      const board = await removeContractEdge(projectRoot, input.boardId, input.contractEdgeId);
-      return board ? okBoard(board, "Contract edge removed.") : fail("Contract edge not found.");
-    }
-    default:
-      return void 0;
-  }
-}
-
-// src/kanban-decomposition-actions.ts
-import {
-  assessTaskAtomicity,
-  proposeTaskDecomposition,
-  updateTask,
-  verifyTaskCompletion
-} from "@wrongstack/kanban";
-
-// src/kanban-evidence-bridge.ts
-import { recordCompletedWorkEvidence } from "@wrongstack/core/utils";
-function kanbanEvidenceKey(boardId, taskId) {
-  return `kanban:${boardId}:${taskId}`;
-}
-function kanbanEvidencePointer(boardId, taskId) {
-  return `kanban://${boardId}/${taskId}#verificationReport`;
-}
-function recordKanbanVerificationEvidence(ctx, report) {
-  try {
-    const passed = report.checks.filter((check) => check.status === "passed").length;
-    const completedAt = Date.parse(report.completedAt);
-    recordCompletedWorkEvidence(ctx, {
-      key: kanbanEvidenceKey(report.boardId, report.taskId),
-      source: "verification",
-      summary: `${report.taskTitle} \u2014 verification ${report.verdict} (${passed}/${report.checks.length} checks)`,
-      ...Number.isFinite(completedAt) ? { completedAt } : {},
-      evidence: kanbanEvidencePointer(report.boardId, report.taskId)
-    });
-  } catch {
-  }
-}
-
-// src/kanban-decomposition-actions.ts
-async function handleKanbanDecompositionAction(projectRoot, input, ctx) {
-  switch (input.action) {
-    case "assess_atomicity": {
-      if (!input.boardId || !input.taskId) {
-        return fail("assess_atomicity requires boardId and taskId.");
-      }
-      const result = await assessTaskAtomicity(projectRoot, input.boardId, input.taskId, {
-        assessedBy: "agent",
-        ...ctx.agentId !== void 0 ? { eventContext: { actor: ctx.agentId } } : {}
-      });
-      if (!result) return fail("Task not found.");
-      const failing = result.assessment.criteria.filter((entry) => entry.score < 1).map((entry) => entry.reason);
-      const guidance = result.assessment.verdict === "needs_decomposition" ? ` This task should be split before dispatch \u2014 call propose_decomposition with 2+ subtasks (each with one verifiable success criterion). Reasons: ${failing.join(" | ")}` : result.assessment.verdict === "composite" ? " Container task: work happens in its children; it is verified via subtask aggregation." : "";
-      return okTask(
-        result.board,
-        result.task,
-        `Atomicity verdict: ${result.assessment.verdict} (score ${result.assessment.score}).${guidance}`
-      );
-    }
-    case "propose_decomposition": {
-      if (!input.boardId || !input.taskId || !input.subtasks?.length) {
-        return fail("propose_decomposition requires boardId, taskId, and subtasks (2+).");
-      }
-      if (input.subtasks.length < 2) {
-        return fail("propose_decomposition requires at least two subtasks.");
-      }
-      const invalid = input.subtasks.find(
-        (subtask) => typeof subtask?.title !== "string" || !subtask.title.trim()
-      );
-      if (invalid) return fail("Every proposed subtask needs a non-blank title.");
-      const result = await proposeTaskDecomposition(
-        projectRoot,
-        input.boardId,
-        input.taskId,
-        {
-          subtasks: input.subtasks,
-          ...input.note !== void 0 ? { rationale: input.note } : {},
-          ...ctx.agentId !== void 0 ? { proposedBy: ctx.agentId } : {}
-        },
-        ctx.agentId !== void 0 ? { actor: ctx.agentId } : {}
-      );
-      if (!result) return fail("Task not found.");
-      const message = result.proposal.status === "applied" ? `Decomposition applied: ${result.proposal.appliedChildTaskIds?.length ?? 0} child tasks created (parent marked atomic).` : 'Decomposition proposal recorded \u2014 awaiting approval (board policy is "propose"). It can be approved from the WebUI or via update_task.';
-      return okTask(result.board, result.task, message);
-    }
-    case "verify_completion": {
-      if (!input.boardId || !input.taskId) {
-        return fail("verify_completion requires boardId and taskId.");
-      }
-      const verResult = await verifyTaskCompletion(projectRoot, input.boardId, input.taskId);
-      const persistedBoard = await updateTask(projectRoot, input.boardId, input.taskId, {
-        verificationReport: verResult.report,
-        successCriteria: verResult.task.successCriteria
-      });
-      if (!persistedBoard) {
-        return {
-          ok: false,
-          verdict: verResult.report.verdict,
-          message: `Verification succeeded but persist failed: ${verResult.report.markdownSummary}. Board may be stale \u2014 re-run verify_completion.`,
-          board: verResult.board
-        };
-      }
-      recordKanbanVerificationEvidence(ctx, verResult.report);
-      const freshTask = persistedBoard.tasks?.find((t) => t.id === input.taskId);
-      const deterministicVerdicts = ["passed", "failed", "needs_human", "incomplete"];
-      return {
-        ok: deterministicVerdicts.includes(
-          verResult.report.verdict
-        ),
-        verdict: verResult.report.verdict,
-        message: verResult.report.markdownSummary,
-        board: persistedBoard,
-        task: freshTask ?? verResult.task
-      };
-    }
-    default:
-      return void 0;
-  }
-}
-
-// src/kanban-detail-actions.ts
-import {
-  addCheckToTask,
-  addDependency,
-  addGoalMetricToTask,
-  addLinkToTask,
-  addNoteToTask,
-  getKanbanWorkbench,
-  removeCheckFromTask,
-  updateCheckOnTask,
-  updateGoalMetricOnTask
-} from "@wrongstack/kanban";
-async function handleKanbanDetailAction(projectRoot, input) {
-  switch (input.action) {
-    case "workbench": {
-      const workbench = await getKanbanWorkbench(projectRoot, {
-        ...input.limit !== void 0 ? { limitPerLane: input.limit, alertLimit: input.limit } : {}
-      });
-      return {
-        ok: true,
-        message: `${workbench.totals.now} now, ${workbench.totals.next} next, ${workbench.totals.blocked} blocked, ${workbench.totals.review} review; ${workbench.alertTotal} alert(s).`,
-        workbench
-      };
-    }
-    case "add_dependency": {
-      if (!input.boardId || !input.taskId || !input.dependencyTaskId) {
-        return fail("add_dependency requires boardId, taskId, and dependencyTaskId.");
-      }
-      const board = await addDependency(
-        projectRoot,
-        input.boardId,
-        input.taskId,
-        input.dependencyTaskId
-      );
-      return board ? okBoard(board, "Dependency added.") : fail("Task not found.");
-    }
-    case "add_goal_metric": {
-      if (!input.boardId || !input.taskId || !input.metricName) {
-        return fail("add_goal_metric requires boardId, taskId, and metricName.");
-      }
-      const board = await addGoalMetricToTask(projectRoot, input.boardId, input.taskId, {
-        name: input.metricName,
-        ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
-        ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
-        ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
-        ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
-        ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
-        ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
-      });
-      return board ? okBoard(board, "Goal metric added.") : fail("Task not found.");
-    }
-    case "update_goal_metric": {
-      if (!input.boardId || !input.taskId || !input.metricId) {
-        return fail("update_goal_metric requires boardId, taskId, and metricId.");
-      }
-      const board = await updateGoalMetricOnTask(
-        projectRoot,
-        input.boardId,
-        input.taskId,
-        input.metricId,
-        {
-          ...input.metricName !== void 0 ? { name: input.metricName } : {},
-          ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
-          ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
-          ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
-          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
-          ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
-          ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
-        }
-      );
-      return board ? okBoard(board, "Goal metric updated.") : fail("Metric not found.");
-    }
-    case "add_check": {
-      if (!input.boardId || !input.taskId || !input.checkDescription) {
-        return fail("add_check requires boardId, taskId, and checkDescription.");
-      }
-      const board = await addCheckToTask(projectRoot, input.boardId, input.taskId, {
-        description: input.checkDescription,
-        type: input.checkType ?? "manual",
-        status: input.checkStatus,
-        ...input.checkNotes !== void 0 ? { notes: input.checkNotes } : {}
-      });
-      return board ? okBoard(board, "Check added.") : fail("Task not found.");
-    }
-    case "update_check": {
-      if (!input.boardId || !input.taskId || !input.checkId) {
-        return fail("update_check requires boardId, taskId, and checkId.");
-      }
-      const board = await updateCheckOnTask(
-        projectRoot,
-        input.boardId,
-        input.taskId,
-        input.checkId,
-        {
-          ...input.checkDescription !== void 0 ? { description: input.checkDescription } : {},
-          ...input.checkStatus !== void 0 ? { status: input.checkStatus } : {},
-          // Promoting an existing manual criterion to an executable one is the
-          // common repair: the card was written before anyone knew the command.
-          ...input.checkType !== void 0 ? { type: input.checkType } : {},
-          ...input.checkNotes !== void 0 ? { notes: input.checkNotes } : {}
-        }
-      );
-      return board ? okBoard(board, "Check updated.") : fail("Check not found.");
-    }
-    case "remove_check": {
-      if (!input.boardId || !input.taskId || !input.checkId) {
-        return fail("remove_check requires boardId, taskId, and checkId.");
-      }
-      const board = await removeCheckFromTask(
-        projectRoot,
-        input.boardId,
-        input.taskId,
-        input.checkId
-      );
-      return board ? okBoard(board, "Acceptance criterion removed.") : fail("Check not found on this task.");
-    }
-    case "add_note": {
-      if (!input.boardId || !input.taskId || !input.note)
-        return fail("add_note requires boardId, taskId, and note.");
-      const board = await addNoteToTask(projectRoot, input.boardId, input.taskId, {
-        author: input.author ?? "agent",
-        content: input.note
-      });
-      return board ? okBoard(board, "Note added.") : fail("Task not found.");
-    }
-    case "add_link": {
-      if (!input.boardId || !input.taskId || !input.url)
-        return fail("add_link requires boardId, taskId, and url.");
-      const board = await addLinkToTask(projectRoot, input.boardId, input.taskId, {
-        url: input.url,
-        type: input.linkType ?? "url",
-        ...input.linkTitle !== void 0 ? { title: input.linkTitle } : {}
-      });
-      return board ? okBoard(board, "Link added.") : fail("Task not found.");
-    }
-    case "split_atomic": {
-      if (!input.boardId || !input.taskId || !input.childTitles?.length) {
-        return fail("split_atomic requires boardId, taskId, and childTitles (at least one).");
-      }
-      return handleSplitTask(projectRoot, input, { atomic: true });
-    }
-    default:
-      return void 0;
-  }
-}
-
-// src/kanban-lifecycle-actions.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-import {
-  addTask as addTask2,
-  assignTask,
-  claimReadyTask,
-  copyTaskToBoard,
-  evaluateContractGraphReadiness,
-  finalizeTaskCompletion,
-  getBoard as 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";
-import { clampSubagentCapabilities } from "@wrongstack/core/security";
-function taskInput(input) {
-  const assignment = hasAssignmentInput(input) ? assignmentForTaskCreate(input) : void 0;
-  return {
-    title: input.title ?? "",
-    columnId: input.columnId,
-    description: input.description,
-    dueDate: input.dueDate,
-    priority: input.priority,
-    ...input.taskType !== void 0 ? { type: input.taskType } : {},
-    status: input.status,
-    labels: input.labels,
-    ...assignment?.agentId ?? assignment?.role ?? assignment?.name ? { assignedAgent: assignment.agentId ?? assignment.role ?? assignment.name } : {},
-    ...input.assignee ?? assignment?.name ?? assignment?.agentId ? { assignee: input.assignee ?? assignment?.name ?? assignment?.agentId } : {},
-    ...mergedDependsOn(input) ? { dependsOn: mergedDependsOn(input) } : {},
-    ...input.estimatedHours !== void 0 ? { estimatedHours: input.estimatedHours } : {},
-    ...input.actualHours !== void 0 ? { actualHours: input.actualHours } : {},
-    ...assignment ? { assignment } : {},
-    ...input.order !== void 0 ? { order: input.order } : {},
-    ...input.retryPolicy !== void 0 ? { retryPolicy: input.retryPolicy } : {},
-    ...input.costCeilingUsd !== void 0 ? { costCeilingUsd: input.costCeilingUsd } : {},
-    // The system prompt has always told the model it may "set atomic: true"
-    // when creating a composite parent. It could not: the field reached
-    // neither the create input nor the patch, so the instruction described a
-    // capability that did not exist and the attempt was silently dropped.
-    ...input.atomic !== void 0 ? { atomic: input.atomic } : {},
-    ...input.childTitles !== void 0 ? { childTaskIds: input.childTitles } : {},
-    ...input.checkDescription !== void 0 ? {
-      successCriteria: [
-        {
-          id: randomUUID(),
-          description: input.checkDescription,
-          // `manual` only as the fallback. Hard-coding it here meant every
-          // agent-authored criterion was unverifiable by construction: the
-          // deterministic plugins never matched, the registry passed the
-          // hand-set status straight through, and "verified" collapsed into
-          // "the author ticked its own box".
-          type: input.checkType ?? "manual",
-          status: input.checkStatus ?? "pending",
-          ...input.checkNotes !== void 0 ? { notes: input.checkNotes } : {}
-        }
-      ]
-    } : {},
-    ...input.metricName !== void 0 ? {
-      goalMetrics: [
-        {
-          id: randomUUID(),
-          name: input.metricName,
-          status: input.metricStatus ?? "pending",
-          ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
-          ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
-          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
-          ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
-          ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
-        }
-      ]
-    } : {},
-    ...input.url !== void 0 ? {
-      links: [
-        {
-          url: input.url,
-          type: input.linkType ?? "url",
-          ...input.linkTitle !== void 0 ? { title: input.linkTitle } : {}
-        }
-      ]
-    } : {},
-    ...input.note !== void 0 ? {
-      notes: [
-        {
-          id: randomUUID(),
-          author: input.author ?? "agent",
-          content: input.note,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString()
-        }
-      ]
-    } : {},
-    ...[input.graphId, input.specId, input.specRequirementId].some((value) => value !== void 0) ? {
-      origin: {
-        system: input.sourceSystem ?? "kanban-tool",
-        ...input.graphId !== void 0 ? { graphId: input.graphId } : {},
-        ...input.specId !== void 0 ? { specId: input.specId } : {},
-        ...input.specRequirementId !== void 0 ? { specRequirementId: input.specRequirementId } : {},
-        ...input.phaseId !== void 0 ? { phaseId: input.phaseId } : {}
-      }
-    } : {}
-  };
-}
-function mergedDependsOn(input) {
-  if (input.dependsOn === void 0 && input.dependencyTaskId === void 0) return void 0;
-  return [
-    ...input.dependsOn ?? [],
-    ...input.dependencyTaskId !== void 0 ? [input.dependencyTaskId] : []
-  ].filter((id, i, arr) => id && arr.indexOf(id) === i);
-}
-function taskPatch(input) {
-  return {
-    title: input.title,
-    description: input.description,
-    dueDate: input.dueDate,
-    columnId: input.columnId,
-    order: input.order,
-    priority: input.priority,
-    ...input.taskType !== void 0 ? { type: input.taskType } : {},
-    status: input.status,
-    labels: input.labels,
-    assignedAgent: input.agentId,
-    ...mergedDependsOn(input) !== void 0 ? { dependsOn: mergedDependsOn(input) } : {},
-    // `atomic` and `childTaskIds` are the composite-parent contract, and the
-    // managed gate reads both: an `atomic` parent may not move forward without
-    // children, and may not reach Done until every child is completed. The
-    // manager has always accepted both on a patch; only this surface withheld
-    // them, so `split_atomic` was a one-way door — delete the children and the
-    // parent was stranded with no way to declare itself a leaf again.
-    ...input.atomic !== void 0 ? { atomic: input.atomic } : {},
-    ...input.childTaskIds !== void 0 ? { childTaskIds: input.childTaskIds } : {},
-    ...input.estimatedHours !== void 0 ? { estimatedHours: input.estimatedHours } : {},
-    ...input.actualHours !== void 0 ? { actualHours: input.actualHours } : {}
-  };
-}
-function clampRequestedCapabilities(requested) {
-  if (requested === void 0) return void 0;
-  return clampSubagentCapabilities(requested).granted;
-}
-function assignmentInput(input) {
-  return {
-    agentId: input.agentId,
-    name: input.name,
-    role: input.role,
-    provider: input.provider,
-    model: input.model,
-    fallbackProfile: input.fallbackProfile,
-    fallbackModels: input.fallbackModels,
-    tools: input.tools,
-    allowedCapabilities: clampRequestedCapabilities(input.allowedCapabilities),
-    assignee: input.assignee,
-    leaseId: input.leaseId,
-    claimedAt: input.claimedAt,
-    heartbeatAt: input.heartbeatAt,
-    leaseExpiresAt: input.leaseExpiresAt,
-    attempt: input.attempt,
-    maxAttempts: input.maxAttempts,
-    costCeilingUsd: input.costCeilingUsd,
-    retryPolicy: input.retryPolicy,
-    lastFailureKind: input.lastFailureKind
-  };
-}
-function hasAssignmentInput(input) {
-  return input.agentId !== void 0 || input.name !== void 0 || input.role !== void 0 || input.provider !== void 0 || input.model !== void 0 || input.fallbackProfile !== void 0 || input.fallbackModels !== void 0 || input.tools !== void 0 || input.allowedCapabilities !== void 0 || input.assignee !== void 0 || input.leaseId !== void 0 || input.claimedAt !== void 0 || input.heartbeatAt !== void 0 || input.leaseExpiresAt !== void 0 || input.attempt !== void 0 || input.maxAttempts !== void 0 || input.costCeilingUsd !== void 0 || input.retryPolicy !== void 0 || input.lastFailureKind !== void 0 || input.assignmentStatus !== void 0;
-}
-function assignmentForTaskCreate(input) {
-  return {
-    status: input.assignmentStatus ?? "assigned",
-    ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
-    ...input.name !== void 0 ? { name: input.name } : {},
-    ...input.role !== void 0 ? { role: input.role } : {},
-    ...input.provider !== void 0 ? { provider: input.provider } : {},
-    ...input.model !== void 0 ? { model: input.model } : {},
-    ...input.fallbackProfile !== void 0 ? { fallbackProfile: input.fallbackProfile } : {},
-    ...input.fallbackModels !== void 0 ? { fallbackModels: input.fallbackModels } : {},
-    ...input.tools !== void 0 ? { tools: input.tools } : {},
-    ...input.allowedCapabilities !== void 0 ? { allowedCapabilities: clampRequestedCapabilities(input.allowedCapabilities) } : {},
-    ...input.leaseId !== void 0 ? { leaseId: input.leaseId } : {},
-    ...input.claimedAt !== void 0 ? { claimedAt: input.claimedAt } : {},
-    ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
-    ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
-    ...input.attempt !== void 0 ? { attempt: input.attempt } : {},
-    ...input.maxAttempts !== void 0 ? { maxAttempts: input.maxAttempts } : {},
-    ...input.costCeilingUsd !== void 0 ? { costCeilingUsd: input.costCeilingUsd } : {},
-    ...input.retryPolicy !== void 0 ? { retryPolicy: input.retryPolicy } : {},
-    ...input.lastFailureKind !== void 0 ? { lastFailureKind: input.lastFailureKind } : {}
-  };
-}
-
-// src/kanban-lifecycle-actions.ts
-async function syncContextTask(ctx, task, options = {}) {
-  if (!ctx?.state || !task) return;
-  try {
-    await applySessionKanbanTaskToSource2(ctx, task, options);
-  } catch {
-  }
-}
-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.");
-      await syncContextTask(ctx, result.task);
-      return okTask(result.board, result.task, `Task added.${atomicityNudge(result.task)}`);
-    }
-    case "split_task": {
-      if (!input.boardId || !input.taskId || !input.childTitles?.length) {
-        return fail("split_task requires boardId, taskId, and childTitles.");
-      }
-      return handleSplitTask(projectRoot, input, {});
-    }
-    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);
-      await syncContextTask(ctx, task);
-      return okTask(
-        board,
-        task,
-        "Task is active; runtime Kanban governance is now bound to this run."
-      );
-    }
-    case "update_task": {
-      if (!input.boardId || !input.taskId) return fail("update_task requires boardId and taskId.");
-      const board = await updateTask2(projectRoot, input.boardId, input.taskId, taskPatch(input));
-      if (board) {
-        await syncContextTask(ctx, board.tasks.find((t) => t.id === input.taskId));
-      }
-      return board ? okBoard(board, "Task updated.") : fail("Task not found.");
-    }
-    case "transition_task": {
-      if (!input.boardId || !input.taskId || !input.lifecycleStage || !input.author || !input.transitionComment) {
-        return fail(
-          "transition_task requires boardId, taskId, lifecycleStage, author, and transitionComment."
-        );
-      }
-      if (input.lifecycleStage === "done") {
-        const boardBefore = await 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);
-      }
-      if (result?.task) {
-        await syncContextTask(ctx, result.task);
-      }
-      return result ? okTask(result.board, result.task, `Task advanced to ${result.transition.to}.`) : fail("Board or task not found.");
-    }
-    case "repair_managed_projection": {
-      if (!input.boardId || !input.taskId || !input.author || !input.transitionComment) {
-        return fail(
-          "repair_managed_projection requires boardId, taskId, author, and transitionComment."
-        );
-      }
-      const result = await repairManagedTaskProjection(projectRoot, input.boardId, input.taskId, {
-        actor: input.author,
-        comment: input.transitionComment
-      });
-      if (result?.task) {
-        await syncContextTask(ctx, result.task);
-      }
-      return result ? okTask(
-        result.board,
-        result.task,
-        "Managed card projection repaired from lifecycle history."
-      ) : fail("Board or task not found.");
-    }
-    case "move_task": {
-      if (!input.boardId || !input.taskId || !input.targetColumnId) {
-        return fail("move_task requires boardId, taskId, and targetColumnId.");
-      }
-      const board = await moveTask(
-        projectRoot,
-        input.boardId,
-        input.taskId,
-        input.targetColumnId,
-        input.order
-      );
-      if (board) {
-        await syncContextTask(ctx, board.tasks.find((t) => t.id === input.taskId));
-      }
-      return board ? okBoard(board, "Task moved.") : fail("Move failed.");
-    }
-    case "delete_task": {
-      if (!input.boardId || !input.taskId) return fail("delete_task requires boardId and taskId.");
-      const boardBefore = await getBoard4(projectRoot, input.boardId);
-      const taskToDelete = boardBefore?.tasks.find((t) => t.id === input.taskId);
-      const board = await removeTask(projectRoot, input.boardId, input.taskId);
-      if (board && ctx.currentKanbanTaskId === input.taskId) {
-        ctx.setCurrentKanbanTask?.(void 0, ctx.currentKanbanBoardId);
-      }
-      if (board && taskToDelete) {
-        await syncContextTask(ctx, taskToDelete, { remove: true });
-      }
-      return board ? okBoard(board, "Task deleted.") : fail("Task not found.");
-    }
-    case "set_chain": {
-      if (!input.boardId || !input.taskIds?.length) {
-        return fail("set_chain requires boardId and taskIds.");
-      }
-      const result = await setTaskChain(projectRoot, input.boardId, {
-        taskIds: input.taskIds,
-        ...input.chainId !== void 0 ? { chainId: input.chainId } : {},
-        ...input.enforceDependencies !== void 0 ? { enforceDependencies: input.enforceDependencies } : {}
-      });
-      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(" | ")}`;
-          await syncContextTask(ctx, finalized.task);
-          return {
-            ...okTask(finalized.board, finalized.task, `Assignment updated. ${gateMessage}`),
-            gate: gateSummary
-          };
-        }
-      } else if (board.lifecycle?.mode === "managed") {
-        const managedTask = board.tasks.find((candidate) => candidate.id === input.taskId);
-        const stage = managedTask?.lifecycle?.currentStage;
-        const actor = ctx.agentId ?? "kanban-agent";
-        let transitionResult = null;
-        const lifecycleWarnings = [];
-        if (assignmentStatus === "running" && stage === "todo") {
-          try {
-            transitionResult = await transitionTask(projectRoot, board.id, input.taskId, {
-              to: "running",
-              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}`);
-        await syncContextTask(ctx, responseTask);
-        return okTask(responseBoard, responseTask, msgParts.join(" "));
-      }
-      return okBoard(board, "Assignment updated.");
-    }
-    case "heartbeat_assignment": {
-      if (!input.boardId || !input.taskId) {
-        return fail("heartbeat_assignment requires boardId and taskId.");
-      }
-      const board = await heartbeatTaskAssignment(projectRoot, input.boardId, input.taskId, {
-        ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
-        ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
-        ...input.expectedLeaseId !== void 0 ? { expectedLeaseId: input.expectedLeaseId } : {}
-      });
-      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
-var KANBAN_TOOL_DESCRIPTION = "Durable project task boards: create and move cards, record checks, notes, links and assignments. The board is a record of the work, not a permit for it \u2014 nothing here gates other tools. Managed boards additionally enforce ordered Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions; release_managed_lifecycle turns that off.";
-var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything. Goal metrics pass when current >= target by default; when lower is better (error rate, cost ceiling, latency, open-bug count), pass metricDirection "at_most" with add_goal_metric / update_goal_metric so verification compares current <= target instead.';
-var KANBAN_INPUT_SCHEMA = {
-  type: "object",
-  properties: {
-    action: {
-      type: "string",
-      enum: [
-        "list_boards",
-        "get_board",
-        "create_board",
-        "duplicate_board",
-        "update_board",
-        "adopt_managed_lifecycle",
-        "release_managed_lifecycle",
-        "delete_board",
-        "generate_board",
-        "export_markdown",
-        "export_task_graph",
-        "sync_task_graph",
-        "create_from_graph",
-        "import_session_tasks",
-        "search_tasks",
-        "ready_tasks",
-        "snapshot",
-        "workbench",
-        "add_task",
-        "split_task",
-        "merge_tasks",
-        "copy_task",
-        "transfer_task",
-        "get_task",
-        "start_task",
-        "update_task",
-        "transition_task",
-        "repair_managed_projection",
-        "move_task",
-        "delete_task",
-        "set_chain",
-        "get_chain",
-        "claim_task",
-        "release_task",
-        "assign_task",
-        "mark_assignment",
-        "heartbeat_assignment",
-        "recover_stale",
-        "events",
-        "queue_health",
-        "add_dependency",
-        "add_goal_metric",
-        "update_goal_metric",
-        "add_check",
-        "update_check",
-        "remove_check",
-        "add_note",
-        "add_link",
-        "verify_completion",
-        "split_atomic",
-        "assess_atomicity",
-        "propose_decomposition",
-        "get_contract_graph",
-        "configure_contract_graph",
-        "upsert_contract_node",
-        "remove_contract_node",
-        "add_contract_edge",
-        "remove_contract_edge"
-      ]
-    },
-    boardId: { type: "string" },
-    taskId: { type: "string" },
-    taskIds: { type: "array", items: { type: "string" } },
-    chainId: { type: "string" },
-    fromNodeId: { type: "string" },
-    toNodeId: { type: "string" },
-    baseline: { oneOf: [{ type: "string" }, { type: "number" }] },
-    threshold: { oneOf: [{ type: "string" }, { type: "number" }] },
-    columnId: { type: "string" },
-    targetBoardId: { type: "string" },
-    targetColumnId: { type: "string" },
-    title: { type: "string" },
-    description: { type: "string" },
-    dueDate: { type: "string" },
-    tags: { type: "array", items: { type: "string" } },
-    labels: { type: "array", items: { type: "string" } },
-    priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
-    taskType: {
-      type: "string",
-      enum: ["feature", "bugfix", "refactor", "docs", "test", "chore"]
-    },
-    status: {
-      type: "string",
-      enum: [
-        "pending",
-        "ready",
-        "in_progress",
-        "blocked",
-        "review",
-        "completed",
-        "failed",
-        "archived"
-      ]
-    },
-    order: { type: "number" },
-    query: { type: "string" },
-    limit: { type: "number" },
-    agentId: { type: "string" },
-    name: { type: "string" },
-    role: { type: "string" },
-    provider: { type: "string" },
-    model: { type: "string" },
-    fallbackProfile: { type: "string" },
-    fallbackModels: { type: "array", items: { type: "string" } },
-    tools: { type: "array", items: { type: "string" } },
-    allowedCapabilities: { type: "array", items: { type: "string" } },
-    leaseId: { type: "string" },
-    claimedAt: { type: "string" },
-    heartbeatAt: { type: "string" },
-    leaseExpiresAt: { type: "string" },
-    attempt: { type: "number" },
-    maxAttempts: { type: "number" },
-    subagentId: { type: "string" },
-    runTaskId: { type: "string" },
-    lastResult: { type: "string" },
-    error: { type: "string" },
-    expectedLeaseId: { type: "string" },
-    assignmentStatus: {
-      type: "string",
-      enum: ["assigned", "queued", "running", "completed", "failed", "cancelled"]
-    },
-    lifecycleStage: {
-      type: "string",
-      enum: ["backlog", "todo", "running", "review", "done"]
-    },
-    transitionAction: { type: "string" },
-    transitionComment: { type: "string" },
-    tickChecks: {
-      type: "array",
-      items: {
-        type: "object",
-        properties: {
-          checkId: { type: "string" },
-          checkStatus: { type: "string", enum: ["passed", "failed", "skipped"] }
-        },
-        required: ["checkId", "checkStatus"]
-      },
-      description: "`transition_task` (to=done only): flip one or more manual criteria to `passed` before the gate fires. Read ids from kanban get_task. Non-manual criteria are refused."
-    },
-    attachmentUrl: { type: "string" },
-    attachmentTitle: { type: "string" },
-    attachmentType: {
-      type: "string",
-      enum: ["issue", "pr", "doc", "commit", "design", "file", "url", "other"]
-    },
-    releaseStatus: { type: "string", enum: ["pending", "ready", "blocked"] },
-    releaseReason: { type: "string" },
-    clearAssignee: { type: "boolean" },
-    recoveryMode: { type: "string", enum: ["auto", "release", "retry", "fail"] },
-    recoveryNow: { type: "string" },
-    recoveryPolicyFailOnCostCeiling: { type: "boolean" },
-    recoveryPolicyReleaseOnFailureKinds: { type: "array", items: { type: "string" } },
-    recoveryPolicyReleaseOnHeartbeatDue: { type: "boolean" },
-    recoveryPolicyRetryPolicyOverride: {
-      type: "string",
-      enum: ["off", "incremental", "exponential"]
-    },
-    assignee: { type: "string" },
-    costCeilingUsd: { type: "number" },
-    retryPolicy: { type: "string", enum: ["off", "incremental", "exponential"] },
-    lastFailureKind: { type: "string" },
-    dependsOn: {
-      type: "array",
-      items: { type: "string" },
-      description: "Task ids this card waits on. On update_task an explicit empty array clears them \u2014 use it when a dependency was recorded in error rather than completing work nobody wants."
-    },
-    atomic: {
-      type: "boolean",
-      description: "Composite parent (true) or executable leaf (false). Set false to make a stranded parent a leaf again after its children were dropped."
-    },
-    childTaskIds: {
-      type: "array",
-      items: { type: "string" },
-      description: "Children of a composite parent. On update_task an explicit empty array detaches them all."
-    },
-    estimatedHours: { type: "number" },
-    actualHours: { type: "number" },
-    taskGraph: { type: "object" },
-    graphId: { type: "string" },
-    specId: { type: "string" },
-    specRequirementId: { type: "string" },
-    sourceSystem: { type: "string" },
-    phaseId: { type: "string" },
-    preserveOriginTaskIds: { type: "boolean" },
-    includeArchived: { type: "boolean" },
-    archiveMissingTasks: { type: "boolean" },
-    preserveManualDependencies: { type: "boolean" },
-    dependencyTaskId: { type: "string" },
-    enforceDependencies: { type: "boolean" },
-    childTitles: { type: "array", items: { type: "string" } },
-    inheritAssignment: { type: "boolean" },
-    inheritLabels: { type: "boolean" },
-    inheritSuccessCriteria: { type: "boolean" },
-    inheritGoalMetrics: { type: "boolean" },
-    inheritDependencies: { type: "boolean" },
-    chainChildren: { type: "boolean" },
-    rewireDependents: { type: "boolean" },
-    closeSourceTasks: { type: "boolean" },
-    metricId: { type: "string" },
-    metricName: { type: "string" },
-    metricTarget: { oneOf: [{ type: "string" }, { type: "number" }] },
-    metricCurrent: { oneOf: [{ type: "string" }, { type: "number" }] },
-    metricDirection: { type: "string", enum: ["at_least", "at_most"] },
-    metricUnit: { type: "string" },
-    metricStatus: { type: "string", enum: ["pending", "met", "missed", "waived"] },
-    metricNotes: { type: "string" },
-    checkId: { type: "string" },
-    checkDescription: { type: "string" },
-    checkStatus: { type: "string", enum: ["pending", "passed", "failed", "skipped"] },
-    checkType: {
-      type: "string",
-      // Only types a verifier can actually execute. `manual` is the default and
-      // means a human or agent asserts the status by hand. The rest are run by
-      // `verify_completion` against the default deterministic registry. Types
-      // with no plugin in that registry (`auto`, `review`, `agent`, `council`)
-      // are deliberately omitted: offering them would produce criteria that
-      // silently report `skipped — no verifier plugin registered`.
-      enum: ["manual", "command", "test", "file_exists", "file_matches", "git_diff", "metric"],
-      description: 'How this acceptance criterion is verified. Default "manual" (status set by hand). Any other value makes verify_completion execute it, so the criterion becomes real evidence rather than a self-assertion. Pair with checkNotes.'
-    },
-    checkNotes: {
-      type: "string",
-      description: 'The executable body for a non-manual checkType, read in preference to checkDescription. command/test: the shell command or test pattern. file_exists: the path. file_matches: JSON {"file","pattern","flags"}. git_diff: JSON {"expectedFiles","minChanges","maxChanges"}.'
-    },
-    // ── Contract map ───────────────────────────────────────────────────
-    // The card contract: what this work targets, what it must not break, what
-    // it risks, and what verifies it. Advisory by default — the readiness gate
-    // deliberately does not require map structure, so a map is an operator
-    // review aid, not work the model must complete before implementing.
-    contractEnforcement: {
-      type: "string",
-      enum: ["off", "advisory", "strict"],
-      description: "Board-level contract map enforcement. Default when first configured: advisory."
-    },
-    contractNodeId: { type: "string" },
-    contractNodeKind: {
-      type: "string",
-      enum: ["objective", "guardrail", "risk", "component", "artifact", "verification"],
-      description: "objective = what this card is for; guardrail = what must keep working; risk = what could go wrong; component/artifact = what it touches; verification = what settles it."
-    },
-    contractNodeTitle: { type: "string" },
-    contractNodeDescription: { type: "string" },
-    contractNodeState: {
-      type: "string",
-      enum: ["unknown", "active", "satisfied", "violated", "waived", "resolved"]
-    },
-    contractNodeEnforcement: {
-      type: "string",
-      enum: ["blocking", "advisory", "informational"]
-    },
-    /** Bind a node to an acceptance criterion or goal metric already on the task. */
-    contractCheckId: { type: "string" },
-    contractMetricId: { type: "string" },
-    contractWaiverReason: {
-      type: "string",
-      description: 'Required, with an actor, when contractNodeState is "waived".'
-    },
-    contractEdgeId: { type: "string" },
-    contractEdgeFrom: {
-      type: "string",
-      description: 'A contract node id, or a task id (bare or "task:<id>") for the card endpoint.'
-    },
-    contractEdgeTo: { type: "string" },
-    contractEdgeType: {
-      type: "string",
-      enum: [
-        "targets",
-        "affects",
-        "must_preserve",
-        "exposes",
-        "verified_by",
-        "conflicts_with",
-        "derived_from",
-        "relates_to"
-      ]
-    },
-    contractEdgeRationale: { type: "string" },
-    note: { type: "string" },
-    author: { type: "string" },
-    url: { type: "string" },
-    linkTitle: { type: "string" },
-    linkType: {
-      type: "string",
-      enum: ["issue", "pr", "doc", "commit", "design", "file", "url", "other"]
-    },
-    context: { type: "string" },
-    columns: { type: "array", items: { type: "string" } },
-    generatedBy: { type: "string" },
-    includeTasks: { type: "boolean" },
-    includeCompletedTasks: { type: "boolean" },
-    preserveAssignment: { type: "boolean" },
-    preserveDependencies: { type: "boolean" },
-    moveTasksToColumnId: { type: "string" },
-    atomicityMode: { type: "string", enum: ["off", "assess", "enforce"] },
-    atomicityDecomposition: { type: "string", enum: ["auto", "propose"] },
-    gateEnforcement: {
-      type: "string",
-      // WS-023: `'off'` is deliberately absent. The agent whose work this gate
-      // checks must not be able to switch it off; it may only tighten. Turning
-      // a gate off stays a human decision, made through board config.
-      enum: ["strict", "soft"]
-    },
-    subtasks: {
-      type: "array",
-      minItems: 2,
-      items: {
-        type: "object",
-        properties: {
-          title: { type: "string" },
-          description: { type: "string" },
-          successCriteria: { type: "array", items: { type: "string" } },
-          dependsOnIndex: { type: "array", items: { type: "number" } }
-        },
-        required: ["title"]
-      }
-    }
-  },
-  required: ["action"]
-};
-
-// src/kanban.ts
-var kanbanTool = {
-  name: "kanban",
-  category: "Project",
-  description: KANBAN_TOOL_DESCRIPTION,
-  usageHint: KANBAN_TOOL_USAGE_HINT,
-  permission: "confirm",
-  subjectKey: "action",
-  mutating: true,
-  capabilities: ["fs.write"],
-  icon: "task",
-  timeoutMs: 3e4,
-  inputSchema: KANBAN_INPUT_SCHEMA,
-  async execute(input, ctx) {
-    const projectRoot = ctx.projectRoot;
-    if (!projectRoot) return fail("No project root is available.");
-    const withPresence = createKanbanPresenceWrapper(projectRoot, input, ctx);
-    try {
-      const result = await (async () => {
-        const decompositionResult = await handleKanbanDecompositionAction(projectRoot, input, ctx);
-        if (decompositionResult !== void 0) return decompositionResult;
-        const boardResult = await handleKanbanBoardAction(projectRoot, input, ctx);
-        if (boardResult !== void 0) return boardResult;
-        const lifecycleResult = await handleKanbanLifecycleAction(projectRoot, input, ctx);
-        if (lifecycleResult !== void 0) return lifecycleResult;
-        const contractResult = await handleKanbanContractAction(
-          projectRoot,
-          input,
-          input.author ?? input.agentId
-        );
-        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(stripLifecycleIssues2(err instanceof Error ? err.message : String(err)));
-    }
-  },
-  serialize(output, input) {
-    return serializeKanbanOutput(output, input);
-  }
-};
-
-// src/todo.ts
-function normalizedTitle(value) {
-  return value.trim().toLocaleLowerCase().replace(/\s+/g, " ");
-}
-function activeBoardId(items, ctx) {
-  const metaKanban = ctx.meta?.["kanban"];
-  const metaBoardId = metaKanban && typeof metaKanban === "object" ? metaKanban["boardId"] : void 0;
-  return ctx.currentKanbanBoardId ?? (typeof metaBoardId === "string" ? metaBoardId : void 0) ?? items.find((item) => item.kanbanBoardId)?.kanbanBoardId ?? "";
-}
-function bindTodosToBoard(items, previous, board) {
-  const previousById = new Map(previous.map((item) => [item.id, item]));
-  const available = board.tasks.filter(
-    (task) => task.status !== "archived" && task.mergedIntoTaskId === void 0 && (!task.childTaskIds || task.childTaskIds.length === 0)
-  ).sort(
-    (left, right) => left.createdAt.localeCompare(right.createdAt) || left.order - right.order
-  );
-  const used = /* @__PURE__ */ new Set();
-  return items.map((item) => {
-    const previousItem = previousById.get(item.id);
-    const requestedTaskId = item.kanbanBoardId === board.id ? item.kanbanTaskId : previousItem?.kanbanBoardId === board.id ? previousItem.kanbanTaskId : void 0;
-    const title = normalizedTitle(item.content);
-    const candidates = [
-      requestedTaskId ? board.tasks.find((task2) => task2.id === requestedTaskId) : void 0,
-      board.tasks.find((task2) => task2.id === item.id),
-      board.tasks.find((task2) => task2.origin?.taskId === item.id),
-      available.find((task2) => !used.has(task2.id) && normalizedTitle(task2.title) === title)
-    ];
-    const task = candidates.find((candidate) => candidate && !used.has(candidate.id));
-    if (!task) {
-      const { blockedBy: _discarded, ...rest } = item;
-      return { ...rest };
-    }
-    used.add(task.id);
-    const blockedBy = blockingTitles(board, task);
-    return {
-      ...item,
-      kanbanBoardId: board.id,
-      kanbanTaskId: task.id,
-      ...blockedBy.length ? { blockedBy } : { blockedBy: void 0 }
-    };
-  });
-}
-function demoteBlockedInProgress(items, warnings) {
-  return items.map((item) => {
-    if (item.status !== "in_progress" || !item.blockedBy?.length) return item;
-    warnings.push(
-      `"${item.content}" cannot start yet \u2014 it waits on: ${item.blockedBy.join("; ")}. Kept as pending; complete the blocking work first.`
-    );
-    return { ...item, status: "pending" };
-  });
-}
-async function createMissingManagedCards(items, board, ctx, warnings) {
-  const created = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    if (item.kanbanBoardId === board.id && item.kanbanTaskId) continue;
-    try {
-      const result = await addTask3(ctx.projectRoot, board.id, {
-        title: item.content,
-        description: item.activeForm?.trim() || `Added from the session todo list: ${item.content}`
-      });
-      if (!result) {
-        warnings.push(`Could not open a Kanban card for "${item.content}": board not found.`);
-        continue;
-      }
-      created.set(item.id, result.task.id);
-    } catch (error) {
-      warnings.push(
-        `Could not open a Kanban card for "${item.content}": ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  return created;
-}
-async function synchronizeManagedKanban(items, board, ctx, signal) {
-  let synced = 0;
-  const warnings = [];
-  const actor = ctx.agentId?.trim() || ctx.agentName?.trim() || "kanban-agent";
-  const execute = async (input) => {
-    const result = await kanbanTool.execute(input, ctx, { signal });
-    if (!result.ok) warnings.push(result.message);
-    else {
-      synced++;
-      if (result.message.includes("Warning:")) warnings.push(result.message);
-    }
-    return result;
-  };
-  for (const item of items) {
-    if (item.status !== "pending" || item.kanbanBoardId !== board.id || !item.kanbanTaskId) {
-      continue;
-    }
-    const task = board.tasks.find((candidate) => candidate.id === item.kanbanTaskId);
-    if (task?.lifecycle?.currentStage !== "running") continue;
-    const released = await execute({
-      action: "mark_assignment",
-      boardId: board.id,
-      taskId: task.id,
-      assignmentStatus: "assigned",
-      agentId: actor,
-      lastResult: `Todo returned to queue: ${item.content}`
-    });
-    if (!released.ok) continue;
-    await execute({
-      action: "transition_task",
-      boardId: board.id,
-      taskId: task.id,
-      lifecycleStage: "todo",
-      author: actor,
-      transitionComment: `Todo returned to queue: ${item.content}`
-    });
-  }
-  for (const item of items) {
-    if (item.status === "completed" || item.kanbanBoardId !== board.id || !item.kanbanTaskId) {
-      continue;
-    }
-    const task = board.tasks.find((candidate) => candidate.id === item.kanbanTaskId);
-    if (task?.status !== "completed") continue;
-    warnings.push(
-      `"${item.content}" is already Done on the Kanban board and a completed card cannot be reopened; the row stays completed. Create a follow-up card for any remaining work.`
-    );
-  }
-  for (const item of items) {
-    if (item.status !== "completed" || item.kanbanBoardId !== board.id || !item.kanbanTaskId) {
-      continue;
-    }
-    const task = board.tasks.find((candidate) => candidate.id === item.kanbanTaskId);
-    if (!task || task.status === "completed") continue;
-    const stage = task.lifecycle?.currentStage;
-    if (stage === "backlog" || stage === "todo") {
-      const started = await execute({
-        action: "start_task",
-        boardId: board.id,
-        taskId: task.id,
-        author: actor,
-        agentId: actor,
-        transitionComment: `Auto-started for completion: ${item.content}`
-      });
-      if (!started.ok) {
-        continue;
-      }
-    }
-    await execute({
-      action: "mark_assignment",
-      boardId: board.id,
-      taskId: task.id,
-      assignmentStatus: "completed",
-      agentId: actor,
-      lastResult: `Todo completed: ${item.content}`
-    });
-  }
-  const attemptedParents = /* @__PURE__ */ new Set();
-  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(
-        (childId) => afterCompletions?.tasks.find((candidate) => candidate.id === childId)?.status === "completed"
-      )
-    );
-    if (!parent) break;
-    attemptedParents.add(parent.id);
-    const started = await execute({
-      action: "start_task",
-      boardId: board.id,
-      taskId: parent.id,
-      author: actor,
-      agentId: actor,
-      transitionComment: "All child tasks completed; validating composite parent."
-    });
-    if (started.ok) {
-      await execute({
-        action: "mark_assignment",
-        boardId: board.id,
-        taskId: parent.id,
-        assignmentStatus: "completed",
-        agentId: actor,
-        lastResult: "All child tasks completed; composite result ready for verification."
-      });
-    }
-    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"
-  );
-  const active = items.find(
-    (item) => item.status === "in_progress" && item.kanbanBoardId === board.id && Boolean(item.kanbanTaskId)
-  );
-  const activeStage = active?.kanbanTaskId ? afterCompletions?.tasks.find((task) => task.id === active.kanbanTaskId)?.lifecycle?.currentStage : void 0;
-  if (active?.kanbanTaskId) {
-    if (activeStage === "review" || activeStage === "done") {
-      warnings.push(
-        `"${active.content}" is in ${activeStage === "review" ? "Review" : "Done"} awaiting acceptance; not re-activating it from the todo list. ` + (activeStage === "review" ? "Call kanban start_task explicitly to reopen it as a repair." : "Done is terminal; reopen only by creating a follow-up card.")
-      );
-    } else {
-      await execute({
-        action: "start_task",
-        boardId: board.id,
-        taskId: active.kanbanTaskId,
-        author: actor,
-        agentId: actor,
-        transitionComment: `Todo activated: ${active.content}`
-      });
-    }
-  }
-  if (active?.kanbanTaskId && activeStage === "review") {
-  } else if (active?.kanbanTaskId && completionPending) {
-    warnings.push(
-      "A completed todo is still awaiting acceptance; the next independent Kanban task was started."
-    );
-  } else if (!active && ctx.currentKanbanBoardId === board.id) {
-    ctx.setCurrentKanbanTask(void 0, board.id);
-  }
-  return { synced, warnings };
-}
-var todoTool = {
-  name: "todo",
-  category: "Session",
-  description: "Manage the compact active-work list. With a managed Kanban binding, every row resolves to a real card and status changes advance that card; without Kanban it remains session-only state. Each call replaces ordering and supplied fields, but unfinished omitted rows are retained until completed.",
-  usageHint: "BEST PRACTICE for complex tasks:\n- At the beginning of a non-trivial task, create a clear todo list with specific, actionable items.\n- Only **one** item should be `in_progress` at any time.\n- Update the list frequently as work progresses (mark items done, add new ones, change status).\n- **Re-order items** to reflect current priorities. Omission is not cancellation: unfinished rows are retained until completed.\n- When all items are completed the board auto-clears \u2014 you do NOT need to send an empty list.\n- The system and user can see this list, so keep it honest and up-to-date.\nThis tool is extremely valuable for maintaining focus and giving the user visibility into your plan.",
-  permission: "confirm",
-  mutating: true,
-  timeoutMs: 3e4,
-  capabilities: ["session.todo", "fs.write"],
-  subjectKey: "todos",
-  icon: "todo",
-  inputSchema: {
-    type: "object",
-    properties: {
-      todos: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string",
-              description: 'Unique identifier for the todo item (e.g. "1", "auth-flow").'
-            },
-            content: {
-              type: "string",
-              description: "Clear, actionable description of the task."
-            },
-            status: {
-              type: "string",
-              enum: ["pending", "in_progress", "completed"],
-              description: 'Current status. Only one item should be "in_progress" at a time.'
-            },
-            activeForm: {
-              type: "string",
-              description: 'Optional present-tense form shown while the task is active (e.g. "Fixing auth bug").'
-            },
-            kanbanBoardId: {
-              type: "string",
-              description: "Kanban board that owns this UI row when Kanban is active."
-            },
-            kanbanTaskId: {
-              type: "string",
-              description: "Real Kanban task represented by this UI row."
-            }
-          },
-          required: ["id", "content", "status"]
-        },
-        description: "The desired todo list. Supplied rows are replaced/reordered; unfinished omitted rows are retained."
-      }
-    },
-    required: ["todos"]
-  },
-  async execute(input, ctx, call) {
-    if (!Array.isArray(input?.todos)) {
-      throw new Error("todo: todos must be an array");
-    }
-    const items = input.todos.filter((t) => Boolean(t?.id && t.content));
-    const todoIdentity = (item) => item.kanbanBoardId && item.kanbanTaskId ? `kanban:${item.kanbanBoardId}:${item.kanbanTaskId}` : item.promotedFromTask ? `task:${item.promotedFromTask}` : item.promotedFromPlan ? `plan:${item.promotedFromPlan}` : `todo:${item.id}`;
-    const requestedIdentities = new Set(items.map(todoIdentity));
-    for (const previous of ctx.todos ?? []) {
-      const identity = todoIdentity(previous);
-      if (previous.status === "completed" || requestedIdentities.has(identity)) {
-        continue;
-      }
-      items.push({ ...previous });
-      requestedIdentities.add(identity);
-    }
-    const inProgress = items.filter((t) => t.status === "in_progress");
-    if (inProgress.length > 1) {
-      let seenInProgress = false;
-      for (const item of items) {
-        if (item.status === "in_progress") {
-          if (seenInProgress) item.status = "pending";
-          seenInProgress = true;
-        }
-      }
-    }
-    const boardId = activeBoardId(items, ctx);
-    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 = [];
-    if (managed && board) {
-      const managedBoardId = board.id;
-      const created = await createMissingManagedCards(boundItems, board, ctx, creationWarnings);
-      if (created.size > 0) {
-        boundItems = boundItems.map((item) => {
-          const taskId = created.get(item.id);
-          return taskId ? { ...item, kanbanBoardId: managedBoardId, kanbanTaskId: taskId } : item;
-        });
-        board = await getBoard5(ctx.projectRoot, managedBoardId) ?? board;
-        boundItems = bindTodosToBoard(boundItems, ctx.todos ?? [], board);
-      }
-      boundItems = demoteBlockedInProgress(boundItems, creationWarnings);
-    }
-    ctx.state.replaceTodos(boundItems);
-    const kanbanSync = managed && board ? await synchronizeManagedKanban(boundItems, board, ctx, call.signal) : { synced: 0, warnings: [] };
-    kanbanSync.warnings.unshift(...creationWarnings);
-    if (managed && board) {
-      const unresolved = boundItems.filter(
-        (item) => item.kanbanBoardId !== board.id || !item.kanbanTaskId
-      );
-      if (unresolved.length > 0) {
-        kanbanSync.warnings.push(
-          `${unresolved.length} Todo row(s) could not be bound to a Kanban task and were not applied. Preserve kanbanBoardId/kanbanTaskId when updating the projection.`
-        );
-      }
-    }
-    const mirrorFailure = takeSessionMirrorFailure(ctx.projectRoot, ctx.session?.id ?? "");
-    if (mirrorFailure) kanbanSync.warnings.push(mirrorFailure);
-    let projectedBoard = board;
-    if (managed && board) {
-      const refreshed = await getBoard5(ctx.projectRoot, board.id);
-      if (refreshed) {
-        projectedBoard = refreshed;
-        applyManagedKanbanBoardToTodos2(ctx, refreshed);
-      }
-    }
-    if (!managed) {
-      mirrorSessionTodosToKanban(ctx.projectRoot, items, ctx.session?.id ?? "session");
-    }
-    const completedPlanIds = /* @__PURE__ */ new Set();
-    const completedTaskIds = /* @__PURE__ */ new Set();
-    const pendingPlanIds = /* @__PURE__ */ new Set();
-    const pendingTaskIds = /* @__PURE__ */ new Set();
-    for (const item of items) {
-      if (item.promotedFromPlan) {
-        (item.status === "completed" ? completedPlanIds : pendingPlanIds).add(
-          item.promotedFromPlan
-        );
-      }
-      if (item.promotedFromTask) {
-        (item.status === "completed" ? completedTaskIds : pendingTaskIds).add(
-          item.promotedFromTask
-        );
-      }
-    }
-    for (const planId of completedPlanIds) {
-      if (pendingPlanIds.has(planId)) continue;
-      const meta = ctx.meta;
-      const planPath = meta["plan.path.resolved"] ?? meta["plan.path"];
-      if (typeof planPath !== "string" || !planPath) continue;
-      try {
-        const plan = await loadPlan2(planPath);
-        if (plan) {
-          const updated = setPlanItemStatus(plan, planId, "done");
-          await savePlan(planPath, updated);
-        }
-      } catch {
-      }
-    }
-    for (const taskId of completedTaskIds) {
-      if (pendingTaskIds.has(taskId)) continue;
-      const meta = ctx.meta;
-      const taskPath = meta["task.path.resolved"] ?? meta["task.path"];
-      if (typeof taskPath !== "string" || !taskPath) continue;
-      try {
-        const file = await loadTasks3(taskPath);
-        if (file) {
-          const task = file.tasks.find((t) => t.id === taskId);
-          if (task && task.status !== "completed") {
-            task.status = "completed";
-            task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-            await saveTasks(taskPath, file);
-          }
-        }
-      } catch {
-      }
-    }
-    return {
-      count: items.length,
-      in_progress: (ctx.todos ?? boundItems).filter((t) => t.status === "in_progress").length,
-      ...kanbanSync.synced > 0 ? { kanban_synced: kanbanSync.synced } : {},
-      ...kanbanSync.warnings.length > 0 ? { kanban_warnings: kanbanSync.warnings } : {},
-      ...projectedBoard?.lifecycle?.mode === "managed" ? {
-        kanban_bindings: boundItems.flatMap((item) => {
-          if (item.kanbanBoardId !== projectedBoard.id || !item.kanbanTaskId) return [];
-          const task = projectedBoard.tasks.find(
-            (candidate) => candidate.id === item.kanbanTaskId
-          );
-          return task ? [
-            {
-              todoId: item.id,
-              boardId: projectedBoard.id,
-              taskId: task.id,
-              taskStatus: task.status
-            }
-          ] : [];
-        })
-      } : {}
-    };
-  }
-};
-
-// src/plan.ts
-var planTool = {
-  name: "plan",
-  category: "Session",
-  description: 'Manage a session-persistent strategic plan. The plan is written to disk and survives conversation resumptions within the same session, but is isolated to this session \u2014 other sessions have their own separate plans. Unlike todos (which are per-turn and lost on restart), a plan tracks high-level progress across multiple turns. Use this to outline big-picture work, then promote concrete items into the todo list when ready to execute. By default plans are isolated to this session; use `scope: "project"` to store the plan in a shared project-level file visible to all sessions.',
-  usageHint: 'RECOMMENDED FOR COMPLEX, MULTI-PHASE WORK:\n\n- Start by creating a high-level plan with `action: "add"` or using templates (`template_use`).\n- Use `action: "status"` with `open`, `in_progress`, or `done` for exact status changes.\n- Use `promote` to turn a plan item into actionable todos.\n- Use `taskify` to convert a plan item into a structured task (with type/priority/deps).\n- Unfinished plan items cannot be removed or cleared; complete them first.\n- Keep plans at the "why and what" level, and todos at the "how and next step" level.\n- Common templates: "new-feature", "bug-fix", "refactor", "release", "security-audit".\n\nThis tool is excellent for maintaining long-term direction across many turns within a session. Plans survive resume but are not shared across separate sessions.\nUse `scope: "project"` to use a shared project-level plan file.',
-  permission: "confirm",
-  // WS-046: gives permission decisions something to key on.
-  // The action performed; plan has no single file or path subject.
-  subjectKey: "action",
-  mutating: true,
-  capabilities: ["fs.write"],
-  icon: "plan",
-  timeoutMs: 3e4,
-  inputSchema: {
-    type: "object",
-    properties: {
-      action: {
-        type: "string",
-        enum: [
-          "show",
-          "add",
-          "status",
-          "start",
-          "done",
-          "remove",
-          "promote",
-          "template_use",
-          "clear",
-          "taskify"
-        ],
-        description: "The operation to perform on the plan board."
-      },
-      title: {
-        type: "string",
-        description: "Title of the plan item. Required for action=add."
-      },
-      details: {
-        type: "string",
-        description: "Additional details or description for a new plan item (action=add)."
-      },
-      target: {
-        type: "string",
-        description: "Identifier for the target plan item (id, 1-based index, or partial title). Required for most actions except add/show/clear."
-      },
-      status: {
-        type: "string",
-        enum: ["open", "in_progress", "done"],
-        description: "Exact plan item status for action=status."
-      },
-      subtasks: {
-        type: "array",
-        items: { type: "string" },
-        description: "List of subtask titles. Used with promote to break a plan item into multiple todos."
-      },
-      template: {
-        type: "string",
-        description: "Template identifier when using action=template_use. Common values: new-feature, bug-fix, refactor, release, security-audit."
-      },
-      scope: {
-        type: "string",
-        enum: ["session", "project"],
-        description: 'Storage scope: "session" (default, isolated to this session) or "project" (shared across all sessions for this project).'
-      }
-    },
-    required: ["action"]
-  },
-  async execute(input, ctx) {
-    const sessionPlanPath = ctx.meta["plan.path"];
-    let planPath;
-    if (input.scope === "project") {
-      if (typeof sessionPlanPath === "string") {
-        const lastSep = Math.max(
-          sessionPlanPath.lastIndexOf("/"),
-          sessionPlanPath.lastIndexOf("\\")
-        );
-        if (lastSep < 0) {
-          return {
-            ok: false,
-            message: `Cannot derive the project-scoped plan path: session plan path "${sessionPlanPath}" has no directory component.`,
-            plan: "",
-            count: 0,
-            open: 0
-          };
-        }
-        planPath = sessionPlanPath.slice(0, lastSep + 1) + "backlog.plan.json";
-      }
-    } else {
-      planPath = sessionPlanPath;
-    }
-    if (typeof planPath !== "string" || !planPath) {
-      return {
-        ok: false,
-        message: "Plan storage path is not configured for this session.",
-        plan: "",
-        count: 0,
-        open: 0
-      };
-    }
-    const sessionId = ctx.session?.id ?? "unknown";
-    let early = null;
-    const taskifyMeta = { title: "", details: "" };
-    let didTaskify = false;
-    let todosToReplace = null;
-    let plan;
-    try {
-      plan = await mutatePlan2(planPath, sessionId, async (p) => {
-        switch (input.action) {
-          case "show":
-            break;
-          case "add": {
-            const title = input.title?.trim();
-            if (!title) {
-              early = mkResult(p, false, "add requires `title`.");
-              return p;
-            }
-            const { plan: updated } = addPlanItem(p, title, input.details?.trim() || void 0);
-            return updated;
-          }
-          case "start":
-          case "done": {
-            if (!input.target) {
-              early = mkResult(
-                p,
-                false,
-                `${input.action} requires \`target\` (id|index|substring).`
-              );
-              return p;
-            }
-            const next = setPlanItemStatus2(
-              p,
-              input.target,
-              input.action === "start" ? "in_progress" : "done"
-            );
-            if (next === p) {
-              early = mkResult(p, false, `No plan item matched "${input.target}".`);
-              return p;
-            }
-            return next;
-          }
-          case "status": {
-            if (!input.target || !input.status) {
-              early = mkResult(
-                p,
-                false,
-                "status requires `target` (id|index|substring) and `status`."
-              );
-              return p;
-            }
-            const next = setPlanItemStatus2(p, input.target, input.status);
-            if (next === p) {
-              early = mkResult(p, false, `No plan item matched "${input.target}".`);
-              return p;
-            }
-            return next;
-          }
-          case "remove": {
-            if (!input.target) {
-              early = mkResult(p, false, "remove requires `target` (id|index|substring).");
-              return p;
-            }
-            const next = removePlanItem(p, input.target);
-            if (next === p) {
-              early = mkResult(p, false, `No plan item matched "${input.target}".`);
-              return p;
-            }
-            const nextIds = new Set(next.items.map((item) => item.id));
-            const removed = p.items.find((item) => !nextIds.has(item.id));
-            if (removed?.status !== "done") {
-              early = mkResult(
-                p,
-                false,
-                `Plan item "${removed?.title ?? input.target}" is not done and cannot be removed. Complete it first.`
-              );
-              return p;
-            }
-            return next;
-          }
-          case "promote": {
-            if (!input.target) {
-              early = mkResult(
-                p,
-                false,
-                `${input.action} requires \`target\` (id|index|substring).`
-              );
-              return p;
-            }
-            const derived = deriveTodosFromPlanItem(p, input.target, input.subtasks);
-            if (!derived) {
-              early = mkResult(p, false, `No plan item matched "${input.target}".`);
-              return p;
-            }
-            todosToReplace = derived.todos;
-            early = mkResult(
-              derived.plan,
-              true,
-              `${input.action} ok \u2014 ${derived.todos.length} todo(s) created.`,
-              derived.todos
-            );
-            return derived.plan;
-          }
-          case "template_use": {
-            const templateName = input.template?.trim();
-            if (!templateName) {
-              early = mkResult(p, false, "template_use requires `template` name.");
-              return p;
-            }
-            const template = getPlanTemplate(templateName);
-            if (!template) {
-              early = mkResult(p, false, `Unknown template "${templateName}".`);
-              return p;
-            }
-            let updated = p;
-            for (const item of template.items) {
-              ({ plan: updated } = addPlanItem(updated, item.title, item.details));
-            }
-            early = mkResult(
-              updated,
-              true,
-              `Applied template "${template.name}" \u2014 ${template.items.length} items added.`
-            );
-            return updated;
-          }
-          case "clear":
-            if (p.items.some((item) => item.status !== "done")) {
-              early = mkResult(
-                p,
-                false,
-                "Plan contains unfinished items and cannot be cleared. Complete them first."
-              );
-              return p;
-            }
-            return clearPlan(p);
-          case "taskify": {
-            if (!input.target) {
-              early = mkResult(
-                p,
-                false,
-                "taskify requires `target` (plan item id|index|substring)."
-              );
-              return p;
-            }
-            let itemIdx = -1;
-            const asNum = Number.parseInt(input.target, 10);
-            if (!Number.isNaN(asNum) && asNum >= 1 && asNum <= p.items.length) {
-              itemIdx = asNum - 1;
-            } else {
-              itemIdx = p.items.findIndex((it) => it.id === input.target);
-              if (itemIdx === -1) {
-                const lower = input.target.toLowerCase();
-                itemIdx = p.items.findIndex((it) => it.title.toLowerCase().includes(lower));
-              }
-            }
-            if (itemIdx === -1 || !p.items[itemIdx]) {
-              early = mkResult(p, false, `No plan item matched "${input.target}".`);
-              return p;
-            }
-            const item = p.items[itemIdx];
-            taskifyMeta.title = item.title;
-            taskifyMeta.details = item.details ?? "";
-            didTaskify = true;
-            break;
-          }
-          default:
-            early = mkResult(p, false, `Unknown action "${input.action}".`);
-            return p;
-        }
-        return p;
-      });
-    } catch (err) {
-      return {
-        ok: false,
-        message: `Plan change not saved \u2014 ${err instanceof Error ? err.message : String(err)}`,
-        plan: "",
-        count: 0,
-        open: 0
-      };
-    }
-    ctx.meta["plan.path.resolved"] = planPath;
-    await projectSessionPlanToKanban(ctx.projectRoot, plan.items, sessionId);
-    if (todosToReplace) {
-      await todoTool.execute({ todos: todosToReplace }, ctx, {
-        signal: AbortSignal.timeout(3e4)
-      });
-    }
-    if (early) return early;
-    if (didTaskify) {
-      const taskPathRaw = ctx.meta["task.path"];
-      if (typeof taskPathRaw !== "string" || !taskPathRaw) {
-        return mkResult(plan, false, "Task storage path not configured \u2014 cannot taskify.");
-      }
-      let taskPath = taskPathRaw;
-      if (input.scope === "project") {
-        const lastSep = Math.max(taskPath.lastIndexOf("/"), taskPath.lastIndexOf("\\"));
-        taskPath = lastSep >= 0 ? taskPath.slice(0, lastSep + 1) + "backlog.tasks.json" : "backlog.tasks.json";
-      }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      try {
-        const taskFile = await mutateTasks2(taskPath, sessionId, (f) => {
-          f.tasks.push({
-            id: `task_${randomUUID3()}`,
-            title: taskifyMeta.title,
-            description: taskifyMeta.details || void 0,
-            type: "feature",
-            priority: "medium",
-            status: "pending",
-            createdAt: now,
-            updatedAt: now
-          });
-          return f;
-        });
-        ctx.meta["task.path.resolved"] = taskPath;
-        return mkResult(
-          plan,
-          true,
-          `taskify ok \u2014 added "${taskifyMeta.title}" to tasks.
-${formatTaskList(taskFile.tasks)}`
-        );
-      } catch (err) {
-        return mkResult(
-          plan,
-          false,
-          `taskify: task not saved \u2014 ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    return mkResult(plan, true, `Plan ${input.action} ok.`);
-  }
-};
-function mkResult(plan, ok, message, todos) {
-  const open = plan.items.filter((i) => i.status !== "done").length;
-  const result = {
-    ok,
-    message,
-    plan: formatPlan(plan),
-    count: plan.items.length,
-    open
-  };
-  if (todos !== void 0) result.todos = todos;
-  return result;
-}
+  planTool
+} from "./chunk-KXNDHMUB.js";
+import "./chunk-J4SRJKBW.js";
+import "./chunk-55KF77OK.js";
+import "./chunk-QNJ7AQ4B.js";
 export {
   planTool
 };