@wrongstack/tools 0.302.2 → 0.305.0

package/dist/session-kanban.js

@@ -9,12 +9,17 @@ import {
   mutateTasks
 } from "@wrongstack/core/storage";
 import { deserializeTaskGraph } from "@wrongstack/core/tasking";
-import { resolveWstackPaths } from "@wrongstack/core/utils";
+import { formatTodosForModel, resolveWstackPaths } from "@wrongstack/core/utils";
 import {
   bridgeKanbanSupervisor,
+  compactSessionMirrorBoard,
   createBoard,
+  DEFAULT_COLUMNS,
   getBoard,
+  getDependencyReadinessIssues,
+  getKanbanOrchestrationSnapshot,
   listBoards,
+  pruneSessionBoards,
   removeBoard,
   syncBoardFromTaskGraph,
   touchKanbanPresence,
@@ -22,16 +27,14 @@ import {
 } from "@wrongstack/kanban";
 var SESSION_BOARD_TAG = "session-work";
 var MIRROR_DISABLED_ENV = "WRONGSTACK_KANBAN_TASK_MIRROR";
-var SESSION_KANBAN_COLUMNS = [
-  { id: "todo", title: "Todo", order: 0, wipLimit: 0, color: "#2563eb" },
-  { id: "in-progress", title: "Running", order: 1, wipLimit: 1, color: "#d97706" },
-  { id: "review", title: "Preview", order: 2, wipLimit: 0, color: "#7c3aed" },
-  { id: "done", title: "Done", order: 3, wipLimit: 0, color: "#16a34a" }
-];
+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 bindings = /* @__PURE__ */ new WeakMap();
 var suppressedTodoMirrors = /* @__PURE__ */ new WeakSet();
 var activeSessionBoards = /* @__PURE__ */ new Map();
@@ -41,6 +44,33 @@ function boardKey(projectRoot, 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}`;
 }
@@ -135,6 +165,26 @@ async function removeEmptySessionBoard(projectRoot, boardId, sessionId) {
     return await removeBoard(projectRoot, board.id) ? board.id : null;
   });
 }
+async function removeOwnedSessionBoard(projectRoot, boardId, sessionId) {
+  return enqueueBoardWork(projectRoot, sessionId, async () => {
+    if (isSessionBoardActive(projectRoot, sessionId)) return null;
+    const board = await getBoard(projectRoot, boardId);
+    if (!board || !isOwnedSessionBoard(board.tags)) return null;
+    if (sessionIdFromTags(board.tags) !== sessionId) return null;
+    return await removeBoard(projectRoot, board.id) ? board.id : null;
+  });
+}
+async function cleanupSessionKanbanBoard(projectRoot, sessionId) {
+  if (!projectRoot || !sessionId || process.env[MIRROR_DISABLED_ENV] === "0") return [];
+  if (isSessionBoardActive(projectRoot, sessionId)) return [];
+  const candidates = (await listBoards(projectRoot)).filter(
+    (board) => isOwnedSessionBoard(board.tags) && sessionIdFromTags(board.tags) === sessionId
+  );
+  const removed = await Promise.all(
+    candidates.map((board) => removeOwnedSessionBoard(projectRoot, board.id, sessionId))
+  );
+  return removed.filter((boardId) => Boolean(boardId));
+}
 async function cleanupSessionKanbanBoardIfEmpty(projectRoot, sessionId) {
   if (!projectRoot || !sessionId || process.env[MIRROR_DISABLED_ENV] === "0") return [];
   if (isSessionBoardActive(projectRoot, sessionId)) return [];
@@ -172,16 +222,44 @@ async function projectGraph(projectRoot, sessionId, graph, sourceSystem) {
         sourceSystem,
         tags: [.../* @__PURE__ */ new Set([...board.tags ?? [], ...sessionBoardTags(sessionId)])],
         archiveMissingTasks: true,
-        includeCompletedTasks: true
+        includeCompletedTasks: true,
+        // The scope ledger stays declared and accurate, but it may not veto a
+        // projection. A session mirror reflects a tactical list that shrinks by
+        // design, and refusing the sync never protected the removed row — it
+        // froze the entire board, permanently, because the stored scope then
+        // outlived every later snapshot (`session-kanban.mirror-failed`).
+        // Nothing is lost by shrinking here: `archiveMissingTasks` keeps the
+        // removed card on the board as `archived`, the reconciliation pass
+        // first walks vanished completed rows to Done, and the session journal
+        // remains the durable record.
+        allowRequirementScopeShrink: true
       }
     );
-    return result?.board ?? null;
+    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);
-  pendingMirrors.set(key, { projectRoot, sessionId, graph, 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 () => {
@@ -191,13 +269,37 @@ function queueLatestMirror(projectRoot, sessionId, graph, sourceSystem) {
         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
           );
-        } catch {
+          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 {
@@ -215,7 +317,21 @@ function queueLatestMirror(projectRoot, sessionId, graph, 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 hasInFlightTodoMirror(projectRoot, sessionId) {
+  if (!projectRoot || !sessionId) return false;
+  const key = mirrorKey(projectRoot, sessionId, "session-todo");
+  return pendingMirrors.has(key) || activeMirrors.has(key);
+}
 function todoListToSerializedGraph(todos, sessionId) {
+  const graphId = `todo:${sessionId}`;
   const nodes = todos.map((todo, index) => ({
     id: todo.id,
     title: todo.content,
@@ -223,12 +339,14 @@ function todoListToSerializedGraph(todos, sessionId) {
     type: "chore",
     priority: "medium",
     status: todo.status,
+    specRequirementId: `${graphId}:${todo.id}`,
     createdAt: index,
     updatedAt: index
   }));
   return {
-    id: `todo:${sessionId}`,
-    specId: `todo:${sessionId}`,
+    id: graphId,
+    specId: graphId,
+    requiredRequirementIds: nodes.map((node) => node.specRequirementId),
     title: "Session todos",
     nodes,
     edges: [],
@@ -238,6 +356,7 @@ function todoListToSerializedGraph(todos, sessionId) {
   };
 }
 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,
@@ -246,6 +365,7 @@ function taskFileToSerializedGraph(tasks, sessionId) {
     type: task.type,
     priority: task.priority,
     status: task.status,
+    specRequirementId: `${graphId}:${task.id}`,
     ...task.assignee ? { assignee: task.assignee } : {},
     ...task.estimateHours !== void 0 ? { estimateHours: task.estimateHours } : {},
     createdAt: index,
@@ -263,8 +383,9 @@ function taskFileToSerializedGraph(tasks, sessionId) {
   const rootNodes = nodes.filter((node) => !hasIncoming.has(node.id)).map((node) => node.id);
   return {
     // Keep the historical graph id so existing mirrored task cards are reused.
-    id: `session:${sessionId}`,
-    specId: `session:${sessionId}`,
+    id: graphId,
+    specId: graphId,
+    requiredRequirementIds: nodes.map((node) => node.specRequirementId),
     title: "Session tasks",
     nodes,
     edges,
@@ -279,6 +400,7 @@ var PLAN_STATUS_TO_TASK = {
   done: "completed"
 };
 function planFileToSerializedGraph(items, sessionId) {
+  const graphId = `plan:${sessionId}`;
   const nodes = items.map((item, index) => ({
     id: item.id,
     title: item.title,
@@ -286,12 +408,14 @@ function planFileToSerializedGraph(items, sessionId) {
     type: "chore",
     priority: "medium",
     status: PLAN_STATUS_TO_TASK[item.status],
+    specRequirementId: `${graphId}:${item.id}`,
     createdAt: index,
     updatedAt: index
   }));
   return {
-    id: `plan:${sessionId}`,
-    specId: `plan:${sessionId}`,
+    id: graphId,
+    specId: graphId,
+    requiredRequirementIds: nodes.map((node) => node.specRequirementId),
     title: "Session plan",
     nodes,
     edges: [],
@@ -367,11 +491,11 @@ function broadcastTodoUpdate(context, todos) {
   });
 }
 function notifyTodoUpdate(context, todos) {
-  const summary = todos.length ? todos.map((todo) => `- [${todo.status}] ${todo.content} (${todo.id})`).join("\n") : "- No active todos remain.";
+  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.`;
+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;
@@ -380,6 +504,10 @@ Reassess your current plan before continuing; do not rely on the initial todo sn
     state.appendMessage({ role: "user", content: [{ type: "text", text }] });
   }
 }
+function todosNeedingSessionMirror(todos, activeBoardId) {
+  if (!activeBoardId) return todos;
+  return todos.filter((todo) => todo.kanbanBoardId !== activeBoardId || !todo.kanbanTaskId);
+}
 function mirrorSessionTodosToKanban(projectRoot, todos, sessionId) {
   queueLatestMirror(
     projectRoot,
@@ -417,7 +545,7 @@ function attachSessionKanbanMirror(context) {
       releaseActiveSessionBoard(attachedProjectRoot, registeredSessionId);
       fireAndForget(
         "cleanup-board",
-        cleanupSessionKanbanBoardIfEmpty(attachedProjectRoot, registeredSessionId)
+        cleanupSessionKanbanBoard(attachedProjectRoot, registeredSessionId)
       );
     }
     registeredSessionId = currentSessionId;
@@ -434,6 +562,11 @@ function attachSessionKanbanMirror(context) {
   let boardTimer = null;
   let presenceTimer = null;
   const sessionId = () => context.session?.id ?? "";
+  const activeManagedBoardId = () => {
+    const metaKanban = context.meta["kanban"];
+    const metaBoardId = metaKanban && typeof metaKanban === "object" ? metaKanban["boardId"] : void 0;
+    return context.currentKanbanBoardId ?? (typeof metaBoardId === "string" && metaBoardId ? metaBoardId : "");
+  };
   const refreshFiles = async () => {
     const id = sessionId();
     if (!id) return;
@@ -451,12 +584,19 @@ function attachSessionKanbanMirror(context) {
   const refreshBoard = async () => {
     if (!watchedBoardId) return;
     const board = await getBoard(context.projectRoot, watchedBoardId);
-    if (board) applySessionKanbanBoardToTodos(context, board);
+    if (!board) return;
+    if (board.lifecycle?.mode === "managed") applyManagedKanbanBoardToTodos(context, board);
+    else applySessionKanbanBoardToTodos(context, board);
   };
   const configureBoardWatcher = async () => {
     const id = sessionId();
-    const board = id ? await ensureSessionKanbanBoard(context.projectRoot, id) : null;
-    if (!board || board.id === watchedBoardId) return;
+    const managedBoardId = activeManagedBoardId();
+    const board = managedBoardId ? await getBoard(context.projectRoot, managedBoardId) : id ? await ensureSessionKanbanBoard(context.projectRoot, id) : null;
+    if (!board) return;
+    if (board.id === watchedBoardId) {
+      await refreshBoard();
+      return;
+    }
     unsubscribeBoardEvents?.();
     unsubscribeBoardEvents = null;
     watchedBoardId = board.id;
@@ -480,6 +620,7 @@ function attachSessionKanbanMirror(context) {
       if (presenceTimer) clearInterval(presenceTimer);
       presenceTimer = setInterval(() => fireAndForget("touch-presence", touchPresence()), 6e4);
       presenceTimer.unref?.();
+      if (board.lifecycle?.mode === "managed") applyManagedKanbanBoardToTodos(context, board);
     } catch {
       unsubscribeBoardEvents = null;
       watchedBoardId = "";
@@ -512,18 +653,20 @@ function attachSessionKanbanMirror(context) {
   };
   const unsubscribe = context.state.onChange((change) => {
     if (change.kind === "todos_replaced" && !suppressedTodoMirrors.has(context)) {
-      mirrorSessionTodosToKanban(
-        context.projectRoot,
-        change.completedSnapshot ?? change.todos,
-        sessionId()
-      );
+      const snapshot = change.completedSnapshot ?? change.todos;
+      const unbound = todosNeedingSessionMirror(snapshot, activeManagedBoardId());
+      if (snapshot.length > 0 && unbound.length === 0) return;
+      mirrorSessionTodosToKanban(context.projectRoot, unbound, sessionId());
       return;
     }
-    if (change.kind === "meta_set" && (change.key === "plan.path" || change.key === "task.path")) {
+    if (change.kind === "meta_set" && (change.key === "plan.path" || change.key === "task.path" || change.key === "kanban")) {
       syncActiveSessionRegistration();
       configureWatcher();
-      fireAndForget("ensure-board", ensureSessionKanbanBoard(context.projectRoot, sessionId()));
+      if (!activeManagedBoardId()) {
+        fireAndForget("ensure-board", ensureSessionKanbanBoard(context.projectRoot, sessionId()));
+      }
       fireAndForget("configure-watcher", configureBoardWatcher());
+      fireAndForget("refresh-board", refreshBoard());
       fireAndForget("refresh-files", refreshFiles());
     }
   });
@@ -541,7 +684,7 @@ function attachSessionKanbanMirror(context) {
       releaseActiveSessionBoard(attachedProjectRoot, registeredSessionId);
       fireAndForget(
         "cleanup-board",
-        cleanupSessionKanbanBoardIfEmpty(attachedProjectRoot, registeredSessionId)
+        cleanupSessionKanbanBoard(attachedProjectRoot, registeredSessionId)
       );
       registeredSessionId = "";
     }
@@ -549,10 +692,42 @@ function attachSessionKanbanMirror(context) {
   bindings.set(context, detach);
   return detach;
 }
+async function rebindSessionKanbanTask(context) {
+  const sessionId = context.session?.id;
+  if (!sessionId || !context.projectRoot) return null;
+  if (context.currentKanbanTaskId) return null;
+  let best;
+  try {
+    const snapshot = await getKanbanOrchestrationSnapshot(context.projectRoot);
+    const nowMs = Date.now();
+    for (const result of snapshot.running) {
+      const assignment = result.task.assignment;
+      if (assignment?.status !== "running") continue;
+      const expiresAt = assignment.leaseExpiresAt ? Date.parse(assignment.leaseExpiresAt) : Number.NaN;
+      if (Number.isFinite(expiresAt) && expiresAt <= nowMs) continue;
+      const entry = result.board.presence?.find(
+        (candidate) => candidate.sessionId === sessionId && candidate.taskId === result.task.id
+      );
+      if (!entry) continue;
+      if (!best || entry.lastSeenAt > best.lastSeenAt) {
+        best = { boardId: result.board.id, taskId: result.task.id, lastSeenAt: entry.lastSeenAt };
+      }
+    }
+  } catch {
+    return null;
+  }
+  if (!best) return null;
+  context.setCurrentKanbanTask(best.taskId, best.boardId);
+  return { boardId: best.boardId, taskId: best.taskId };
+}
 async function hydrateSessionKanban(context) {
   const id = context.session?.id ?? "";
   if (!id) return null;
+  await rebindSessionKanbanTask(context);
   await cleanupEmptySessionKanbanBoards(context.projectRoot, id);
+  if (context.projectRoot) {
+    fireAndForget("prune-session-boards", pruneSessionBoards(context.projectRoot));
+  }
   let board = await ensureSessionKanbanBoard(context.projectRoot, id);
   if (context.todos.length) {
     board = await projectSessionTodosToKanban(context.projectRoot, context.todos, id);
@@ -583,18 +758,68 @@ function todoStatus(task) {
   if (status === "in_progress" || status === "review") return "in_progress";
   return "pending";
 }
-function sessionTodoFromTask(task) {
+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 } : {}
+    ...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;
+    return candidate?.id === todo.id && candidate.content === todo.content && candidate.status === todo.status && candidate.activeForm === todo.activeForm && candidate.promotedFromPlan === todo.promotedFromPlan && candidate.promotedFromTask === todo.promotedFromTask && candidate.kanbanBoardId === todo.kanbanBoardId && candidate.kanbanTaskId === todo.kanbanTaskId && // Readiness is part of the projection: when a dependency completes,
+    // the rows are otherwise identical and the unblocking would never
+    // reach the model.
+    (candidate.blockedBy ?? []).join("\0") === (todo.blockedBy ?? []).join("\0");
   });
 }
 function applySessionKanbanBoardToTodos(context, board) {
@@ -602,13 +827,13 @@ function applySessionKanbanBoardToTodos(context, board) {
   if (!sessionId || sessionIdFromTags(board.tags) !== sessionId || !isOwnedSessionBoard(board.tags)) {
     return [...context.todos];
   }
-  const projectedTodos = board.tasks.filter(
-    (task) => task.status !== "archived" && (!task.origin || task.origin.system === "session-todo" || (task.origin.graphId ?? "").startsWith("todo:"))
-  ).sort((left, right) => {
-    const leftColumn = board.columns.find((column) => column.id === left.columnId)?.order ?? 0;
-    const rightColumn = board.columns.find((column) => column.id === right.columnId)?.order ?? 0;
-    return leftColumn - rightColumn || left.order - right.order || left.createdAt.localeCompare(right.createdAt);
-  }).map(sessionTodoFromTask);
+  if (hasInFlightTodoMirror(context.projectRoot, sessionId)) return [...context.todos];
+  const projectedTodos = orderTasksForTodos(
+    board,
+    board.tasks.filter(
+      (task) => task.status !== "archived" && (!task.origin || task.origin.system === "session-todo" || (task.origin.graphId ?? "").startsWith("todo:"))
+    )
+  ).map((task) => sessionTodoFromTask(task, board));
   const allCompleted = projectedTodos.length > 0 && projectedTodos.every((todo) => todo.status === "completed");
   const effectiveTodos = allCompleted ? [] : projectedTodos;
   if (sameTodos(context.todos, effectiveTodos)) return [...context.todos];
@@ -622,6 +847,30 @@ function applySessionKanbanBoardToTodos(context, board) {
   broadcastTodoUpdate(context, context.todos);
   return [...context.todos];
 }
+function applyManagedKanbanBoardToTodos(context, board) {
+  const metaKanban = context.meta["kanban"];
+  const metaBoardId = metaKanban && typeof metaKanban === "object" ? metaKanban["boardId"] : void 0;
+  const activeBoardId = context.currentKanbanBoardId ?? (typeof metaBoardId === "string" ? metaBoardId : void 0);
+  if (!activeBoardId || board.id !== activeBoardId || board.lifecycle?.mode !== "managed") {
+    return [...context.todos];
+  }
+  const projectedTodos = orderTasksForTodos(
+    board,
+    board.tasks.filter(
+      (task) => task.status !== "archived" && task.mergedIntoTaskId === void 0 && (!task.childTaskIds || task.childTaskIds.length === 0)
+    )
+  ).map((task) => managedTodoFromTask(task, board));
+  if (sameTodos(context.todos, projectedTodos)) return [...context.todos];
+  suppressedTodoMirrors.add(context);
+  try {
+    context.state.replaceTodos(projectedTodos);
+  } finally {
+    suppressedTodoMirrors.delete(context);
+  }
+  notifyTodoUpdate(context, context.todos);
+  broadcastTodoUpdate(context, context.todos);
+  return [...context.todos];
+}
 async function applySessionKanbanTaskToSource(context, task, options = {}) {
   const originId = task.origin?.taskId;
   const graphId = task.origin?.graphId ?? "";
@@ -645,7 +894,11 @@ async function applySessionKanbanTaskToSource(context, task, options = {}) {
   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) return { source: "plan" };
+    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(),
@@ -663,7 +916,11 @@ async function applySessionKanbanTaskToSource(context, task, options = {}) {
   }
   if (task.origin?.system === "session-task" || task.origin?.system === "session" || graphId.startsWith("session:")) {
     const taskPath = context.meta["task.path"];
-    if (typeof taskPath !== "string" || !taskPath) return { source: "task" };
+    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(
@@ -682,21 +939,28 @@ async function applySessionKanbanTaskToSource(context, task, options = {}) {
 }
 export {
   SESSION_KANBAN_COLUMNS,
+  applyManagedKanbanBoardToTodos,
   applySessionKanbanBoardToTodos,
   applySessionKanbanTaskToSource,
   attachSessionKanbanMirror,
+  blockingTitles,
   cleanupEmptySessionKanbanBoards,
+  cleanupSessionKanbanBoard,
   cleanupSessionKanbanBoardIfEmpty,
   ensureSessionKanbanBoard,
   hydrateSessionKanban,
   mirrorSessionPlanToKanban,
   mirrorSessionTasksToKanban,
   mirrorSessionTodosToKanban,
+  orderTasksForTodos,
   planFileToSerializedGraph,
   projectSessionPlanToKanban,
   projectSessionTasksToKanban,
   projectSessionTodosToKanban,
+  rebindSessionKanbanTask,
+  takeSessionMirrorFailure,
   taskFileToSerializedGraph,
-  todoListToSerializedGraph
+  todoListToSerializedGraph,
+  todosNeedingSessionMirror
 };
 //# sourceMappingURL=session-kanban.js.map

package/dist/task.d.ts

@@ -1,13 +1,14 @@
-import type { TaskStatus } from '@wrongstack/core/types';
+import type { TaskStatus, Tool } from '@wrongstack/core/types';
 import { type TaskItem } from '@wrongstack/core/utils';
-import type { Tool } from '@wrongstack/core/types';
+type TaskReplacementItem = Omit<TaskItem, 'createdAt' | 'updatedAt'> & Partial<Pick<TaskItem, 'createdAt' | 'updatedAt'>>;
+type TaskAdditionItem = Omit<TaskItem, 'id' | 'createdAt' | 'updatedAt' | 'status'> & Partial<Pick<TaskItem, 'status'>>;
 interface TaskInput {
     /** Replace: set new task list. Add: append a task. Status: update task status. Promote: convert a task to todo items. */
     action: 'replace' | 'add' | 'status' | 'show' | 'promote' | 'planify';
     /** Full task list for action=replace. */
-    tasks?: TaskItem[] | undefined;
+    tasks?: TaskReplacementItem[] | undefined;
     /** Single task for action=add. id, createdAt, updatedAt are auto-generated. */
-    task?: Omit<TaskItem, 'id' | 'createdAt' | 'updatedAt'> | undefined;
+    task?: TaskAdditionItem | undefined;
     /** Task id for action=status or target for action=promote. */
     id?: string | undefined;
     /** New status for action=status. */