@wrongstack/tools 0.313.0 → 0.313.1

package/dist/task.js

@@ -1,3414 +1,9 @@
-// src/task.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { addPlanItem, formatPlan, mutatePlan as mutatePlan2, mutateTasks as mutateTasks2 } from "@wrongstack/core/storage";
-import { computeTaskItemProgress, 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
-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
-  };
-}
-
-// 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 mirrorSessionTodosToKanban(projectRoot, todos, sessionId) {
-  queueLatestMirror(
-    projectRoot,
-    sessionId,
-    todoListToSerializedGraph(todos, sessionId),
-    "session-todo"
-  );
-}
-function mirrorSessionTasksToKanban(projectRoot, tasks, sessionId) {
-  queueLatestMirror(
-    projectRoot,
-    sessionId,
-    taskFileToSerializedGraph(tasks, sessionId),
-    "session-task"
-  );
-}
-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/task.ts
-function findTaskIndex(tasks, query) {
-  const asNum = Number.parseInt(query, 10);
-  if (!Number.isNaN(asNum)) {
-    const idx = asNum - 1;
-    if (tasks[idx]) return idx;
-  }
-  const byId = tasks.findIndex((t) => t.id === query);
-  if (byId >= 0) return byId;
-  const lower = query.toLowerCase();
-  return tasks.findIndex((t) => t.title.toLowerCase().includes(lower));
-}
-var taskTool = {
-  name: "task",
-  category: "Session",
-  description: 'Manage session-persistent structured work items with dependencies, types, and priorities. Unlike `todo` (flat, tactical), `task` supports typed work (feature/bugfix/refactor/etc.), dependencies between items, priority ranking, and agent assignment. Tasks are written to disk and survive session resumes. By default they are isolated to this session; use `scope: "project"` to store tasks in a shared project-level file visible to all sessions.',
-  usageHint: 'USE FOR STRUCTURED WORK:\n- `action: "replace"` \u2014 replace task details/order without omitting unfinished persisted tasks\n- `action: "add"` \u2014 append a single task\n- `action: "status"` \u2014 update a task\'s status (e.g. pending\u2192in_progress, in_progress\u2192completed)\n- `action: "show"` \u2014 view current tasks without changing them\n- `action: "promote"` \u2014 convert a task into actionable todo items via `target` (id|index|substring)\n- `action: "planify"` \u2014 promote a task to a plan item (strategic level) via `target` (id|index|substring)\n\nTask fields:\n- `dependsOn`: list of task IDs this one waits for\n- `type`: "feature" | "bugfix" | "refactor" | "docs" | "test" | "chore"\n- `priority`: "critical" | "high" | "medium" | "low"\n- `assignee`: agent/subagent name (e.g. "bug-hunter", "refactor-planner")\n- `estimateHours`: rough time estimate\n- `scope`: "session" (default, isolated) or "project" (shared across sessions)',
-  permission: "confirm",
-  mutating: true,
-  subjectKey: "action",
-  capabilities: ["fs.write"],
-  icon: "task",
-  timeoutMs: 5e3,
-  inputSchema: {
-    type: "object",
-    properties: {
-      action: {
-        type: "string",
-        enum: ["replace", "add", "status", "show", "promote", "planify"],
-        description: "replace = set full list, add = append, status = update task status, show = view only, promote = convert task to todos, planify = convert task to plan item."
-      },
-      tasks: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            id: { type: "string", description: 'Unique id (e.g. "t1", "auth-flow").' },
-            title: { type: "string", description: "Short title." },
-            description: { type: "string", description: "Optional details." },
-            type: {
-              type: "string",
-              enum: ["feature", "bugfix", "refactor", "docs", "test", "chore"]
-            },
-            priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
-            status: {
-              type: "string",
-              enum: ["pending", "in_progress", "blocked", "failed", "review", "completed"]
-            },
-            dependsOn: {
-              type: "array",
-              items: { type: "string" },
-              description: "IDs of tasks this one depends on."
-            },
-            assignee: { type: "string", description: "Agent/subagent assigned." },
-            estimateHours: { type: "number", description: "Estimated hours." },
-            tags: { type: "array", items: { type: "string" }, description: "Optional tags." },
-            createdAt: { type: "string" },
-            updatedAt: { type: "string" }
-          },
-          required: ["id", "title", "type", "priority", "status"]
-        },
-        description: "Complete desired task list. Existing unfinished tasks may not be omitted; complete them first."
-      },
-      task: {
-        type: "object",
-        properties: {
-          title: { type: "string" },
-          description: { type: "string" },
-          type: {
-            type: "string",
-            enum: ["feature", "bugfix", "refactor", "docs", "test", "chore"]
-          },
-          priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
-          status: {
-            type: "string",
-            enum: ["pending", "in_progress", "blocked", "failed", "review", "completed"]
-          },
-          dependsOn: { type: "array", items: { type: "string" } },
-          assignee: { type: "string" },
-          estimateHours: { type: "number" },
-          tags: { type: "array", items: { type: "string" } }
-        },
-        required: ["title", "type", "priority"],
-        description: "Single task to append (id/createdAt/updatedAt auto-generated)."
-      },
-      id: {
-        type: "string",
-        description: "Task id for action=status or target for action=promote."
-      },
-      status: {
-        type: "string",
-        enum: ["pending", "in_progress", "blocked", "failed", "review", "completed"],
-        description: "New status for action=status."
-      },
-      target: {
-        type: "string",
-        description: "Target task identifier (id, 1-based index, or title substring) for action=promote."
-      },
-      subtasks: {
-        type: "array",
-        items: { type: "string" },
-        description: "Optional subtask titles for action=promote. Each becomes a pending todo."
-      },
-      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 sessionTaskPath = ctx.meta["task.path"];
-    let taskPath;
-    if (input.scope === "project") {
-      if (typeof sessionTaskPath === "string") {
-        const lastSep = Math.max(
-          sessionTaskPath.lastIndexOf("/"),
-          sessionTaskPath.lastIndexOf("\\")
-        );
-        taskPath = lastSep >= 0 ? sessionTaskPath.slice(0, lastSep + 1) + "backlog.tasks.json" : "backlog.tasks.json";
-      }
-    } else {
-      taskPath = sessionTaskPath;
-    }
-    if (typeof taskPath !== "string" || !taskPath) {
-      return {
-        ok: false,
-        message: "Task storage path not configured.",
-        count: 0,
-        completed: 0,
-        inProgress: 0
-      };
-    }
-    const sessionId = ctx.session?.id ?? "unknown";
-    let early = null;
-    const promoteMeta = { count: 0, title: "" };
-    const planifyMeta = { title: "", details: "" };
-    let didPlanify = false;
-    let todosToReplace = null;
-    let file;
-    try {
-      file = await mutateTasks2(taskPath, sessionId, async (f) => {
-        switch (input.action) {
-          case "show":
-            break;
-          case "replace": {
-            if (!Array.isArray(input.tasks)) {
-              early = {
-                ok: false,
-                message: "action=replace requires `tasks` array.",
-                count: 0,
-                completed: 0,
-                inProgress: 0
-              };
-              return f;
-            }
-            const newIds = new Set(input.tasks.map((t) => t.id));
-            if (newIds.size !== input.tasks.length) {
-              const seen = /* @__PURE__ */ new Set();
-              const dupes = [
-                ...new Set(
-                  input.tasks.map((t) => t.id).filter((id) => {
-                    if (seen.has(id)) return true;
-                    seen.add(id);
-                    return false;
-                  })
-                )
-              ];
-              early = {
-                ok: false,
-                message: `action=replace has duplicate task IDs: ${dupes.join(", ")}. Each task id must be unique.`,
-                count: 0,
-                completed: 0,
-                inProgress: 0
-              };
-              return f;
-            }
-            const omittedUnfinished = f.tasks.filter(
-              (task) => task.status !== "completed" && !newIds.has(task.id)
-            );
-            if (omittedUnfinished.length > 0) {
-              early = {
-                ok: false,
-                message: `action=replace cannot omit unfinished tasks: ${omittedUnfinished.map((task) => task.id).join(", ")}. Complete them first.`,
-                count: f.tasks.length,
-                ...computeTaskItemProgress(f.tasks)
-              };
-              return f;
-            }
-            for (const t of input.tasks) {
-              if (t.dependsOn && t.dependsOn.length > 0) {
-                const missing = t.dependsOn.filter((d) => !newIds.has(d));
-                if (missing.length > 0) {
-                  early = {
-                    ok: false,
-                    message: `dependsOn validation failed: task "${t.id}" references unknown IDs: ${missing.join(", ")}`,
-                    count: 0,
-                    completed: 0,
-                    inProgress: 0
-                  };
-                  return f;
-                }
-              }
-              if (t.status === "in_progress" || t.status === "completed") {
-                const unmet = (t.dependsOn ?? []).filter(
-                  (dependencyId) => input.tasks?.find((candidate) => candidate.id === dependencyId)?.status !== "completed"
-                );
-                if (unmet.length > 0) {
-                  early = {
-                    ok: false,
-                    message: `dependency status validation failed: task "${t.id}" cannot be ${t.status} before completion of ${unmet.join(", ")}.`,
-                    count: f.tasks.length,
-                    ...computeTaskItemProgress(f.tasks)
-                  };
-                  return f;
-                }
-              }
-            }
-            const now = (/* @__PURE__ */ new Date()).toISOString();
-            f.tasks = input.tasks.map((t) => ({
-              ...t,
-              createdAt: t.createdAt || now,
-              updatedAt: now
-            }));
-            break;
-          }
-          case "add": {
-            const t = input.task;
-            if (!t?.title) {
-              early = {
-                ok: false,
-                message: "action=add requires `task` with at least `title`.",
-                count: 0,
-                completed: 0,
-                inProgress: 0
-              };
-              return f;
-            }
-            if (t.dependsOn && t.dependsOn.length > 0) {
-              const existingIds = new Set(f.tasks.map((e) => e.id));
-              const missing = t.dependsOn.filter((d) => !existingIds.has(d));
-              if (missing.length > 0) {
-                early = {
-                  ok: false,
-                  message: `dependsOn validation failed: unknown task IDs: ${missing.join(", ")}`,
-                  count: 0,
-                  completed: 0,
-                  inProgress: 0
-                };
-                return f;
-              }
-            }
-            const now = (/* @__PURE__ */ new Date()).toISOString();
-            const newTask = {
-              id: `task_${Date.now()}_${randomUUID3().slice(0, 8)}`,
-              title: t.title,
-              description: t.description,
-              type: t.type || "feature",
-              priority: t.priority || "medium",
-              status: t.status || "pending",
-              dependsOn: t.dependsOn,
-              assignee: t.assignee,
-              estimateHours: t.estimateHours,
-              tags: t.tags,
-              createdAt: now,
-              updatedAt: now
-            };
-            f.tasks.push(newTask);
-            break;
-          }
-          case "status": {
-            if (!input.id || !input.status) {
-              early = {
-                ok: false,
-                message: "action=status requires `id` and `status`.",
-                count: 0,
-                completed: 0,
-                inProgress: 0
-              };
-              return f;
-            }
-            const task = f.tasks.find((t) => t.id === input.id);
-            if (!task) {
-              early = {
-                ok: false,
-                message: `Task "${input.id}" not found.`,
-                count: 0,
-                completed: 0,
-                inProgress: 0
-              };
-              return f;
-            }
-            if (input.status === "in_progress" || input.status === "completed") {
-              const unmet = (task.dependsOn ?? []).filter(
-                (dependencyId) => f.tasks.find((candidate) => candidate.id === dependencyId)?.status !== "completed"
-              );
-              if (unmet.length > 0) {
-                early = {
-                  ok: false,
-                  message: `Task "${task.id}" cannot be ${input.status} before dependencies complete: ${unmet.join(", ")}.`,
-                  count: f.tasks.length,
-                  ...computeTaskItemProgress(f.tasks)
-                };
-                return f;
-              }
-            }
-            task.status = input.status;
-            task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-            break;
-          }
-          case "promote": {
-            const target = input.target?.trim();
-            if (!target) {
-              early = {
-                ok: false,
-                message: "action=promote requires `target` (task id, index, or title substring).",
-                count: 0,
-                completed: 0,
-                inProgress: 0
-              };
-              return f;
-            }
-            const idx = findTaskIndex(f.tasks, target);
-            if (idx === -1) {
-              early = {
-                ok: false,
-                message: `No task matched "${target}".`,
-                count: 0,
-                completed: 0,
-                inProgress: 0
-              };
-              return f;
-            }
-            const match = f.tasks[idx];
-            if (!match) {
-              early = {
-                ok: false,
-                message: `No task matched "${target}".`,
-                count: 0,
-                completed: 0,
-                inProgress: 0
-              };
-              return f;
-            }
-            if (match.status !== "completed" && match.status !== "failed") {
-              match.status = "in_progress";
-              match.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-            }
-            const todos = [];
-            const ts = Date.now();
-            todos.push({
-              id: `todo_${ts}_task`,
-              content: match.title,
-              status: "in_progress",
-              activeForm: match.title,
-              promotedFromTask: match.id
-            });
-            if (match.description) {
-              todos.push({
-                id: `todo_${ts}_${randomUUID3().slice(0, 6)}`,
-                content: match.description.slice(0, 200),
-                status: "pending",
-                promotedFromTask: match.id
-              });
-            }
-            if (input.subtasks && input.subtasks.length > 0) {
-              for (const st of input.subtasks) {
-                todos.push({
-                  id: `todo_${ts}_${randomUUID3().slice(0, 6)}`,
-                  content: st,
-                  status: "pending",
-                  promotedFromTask: match.id
-                });
-              }
-            }
-            todosToReplace = todos;
-            promoteMeta.count = todos.length;
-            promoteMeta.title = match.title;
-            break;
-          }
-          case "planify": {
-            const target = input.target?.trim();
-            if (!target) {
-              early = {
-                ok: false,
-                message: "action=planify requires `target` (task id, index, or title substring).",
-                count: 0,
-                completed: 0,
-                inProgress: 0
-              };
-              return f;
-            }
-            const idx = findTaskIndex(f.tasks, target);
-            if (idx === -1) {
-              early = {
-                ok: false,
-                message: `No task matched "${target}".`,
-                count: 0,
-                completed: 0,
-                inProgress: 0
-              };
-              return f;
-            }
-            const match = f.tasks[idx];
-            if (!match) {
-              early = {
-                ok: false,
-                message: `No task matched "${target}".`,
-                count: 0,
-                completed: 0,
-                inProgress: 0
-              };
-              return f;
-            }
-            planifyMeta.title = match.title;
-            planifyMeta.details = match.description ?? "";
-            didPlanify = true;
-            break;
-          }
-          default:
-            early = {
-              ok: false,
-              message: `Unknown action "${input.action}". Use replace | add | status | show | promote | planify.`,
-              count: 0,
-              completed: 0,
-              inProgress: 0
-            };
-            return f;
-        }
-        return f;
-      });
-    } catch (err) {
-      return {
-        ok: false,
-        message: `Task change not saved \u2014 ${err instanceof Error ? err.message : String(err)}`,
-        count: 0,
-        completed: 0,
-        inProgress: 0
-      };
-    }
-    ctx.meta["task.path.resolved"] = taskPath;
-    if (todosToReplace) {
-      await todoTool.execute({ todos: todosToReplace }, ctx, {
-        signal: AbortSignal.timeout(3e4)
-      });
-    }
-    mirrorSessionTasksToKanban(ctx.projectRoot, file.tasks, sessionId);
-    if (early) return early;
-    if (didPlanify) {
-      const { title, details } = planifyMeta;
-      const planPathRaw = ctx.meta["plan.path"];
-      const prog = computeTaskItemProgress(file.tasks);
-      if (typeof planPathRaw === "string" && planPathRaw) {
-        let planPath = planPathRaw;
-        if (input.scope === "project") {
-          const lastSep = Math.max(planPath.lastIndexOf("/"), planPath.lastIndexOf("\\"));
-          planPath = lastSep >= 0 ? planPath.slice(0, lastSep + 1) + "backlog.plan.json" : "backlog.plan.json";
-        }
-        let formatted = "";
-        try {
-          await mutatePlan2(planPath, sessionId, (pf) => {
-            const { plan: updated } = addPlanItem(pf, title, details || void 0);
-            formatted = formatPlan(updated);
-            return updated;
-          });
-          ctx.meta["plan.path.resolved"] = planPath;
-        } catch (err) {
-          return {
-            ok: false,
-            message: `planify: plan not saved \u2014 ${err instanceof Error ? err.message : String(err)}`,
-            count: file.tasks.length,
-            completed: prog.completed,
-            inProgress: prog.inProgress
-          };
-        }
-        return {
-          ok: true,
-          message: `planify ok \u2014 added "${title}" to plan.
-${formatted}`,
-          count: file.tasks.length,
-          completed: prog.completed,
-          inProgress: prog.inProgress
-        };
-      }
-      return {
-        ok: false,
-        message: "Plan storage path not configured \u2014 cannot planify.",
-        count: file.tasks.length,
-        completed: prog.completed,
-        inProgress: prog.inProgress
-      };
-    }
-    const p = computeTaskItemProgress(file.tasks);
-    const summary = promoteMeta.count > 0 ? `promote ok \u2014 ${promoteMeta.count} todo(s) created from "${promoteMeta.title}".
-${formatTaskList(file.tasks)}` : file.tasks.length > 0 ? formatTaskList(file.tasks) : "No tasks.";
-    return {
-      ok: true,
-      message: summary,
-      count: file.tasks.length,
-      completed: p.completed,
-      inProgress: p.inProgress
-    };
-  }
-};
+  taskTool
+} from "./chunk-FW65TP4G.js";
+import "./chunk-J4SRJKBW.js";
+import "./chunk-55KF77OK.js";
+import "./chunk-QNJ7AQ4B.js";
 export {
   taskTool
 };