@wrongstack/tools 0.303.0 → 0.305.1

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}`;
 }
@@ -192,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 () => {
@@ -211,20 +269,34 @@ 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
           );
+          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: error instanceof Error ? error.message : String(error),
+              message,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             })
           );
@@ -245,6 +317,19 @@ 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) => ({
@@ -406,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;
@@ -419,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,
@@ -565,16 +654,9 @@ function attachSessionKanbanMirror(context) {
   const unsubscribe = context.state.onChange((change) => {
     if (change.kind === "todos_replaced" && !suppressedTodoMirrors.has(context)) {
       const snapshot = change.completedSnapshot ?? change.todos;
-      if (snapshot.length > 0 && snapshot.every(
-        (todo) => todo.kanbanBoardId === activeManagedBoardId() && Boolean(todo.kanbanTaskId)
-      )) {
-        return;
-      }
-      mirrorSessionTodosToKanban(
-        context.projectRoot,
-        change.completedSnapshot ?? change.todos,
-        sessionId()
-      );
+      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" || change.key === "kanban")) {
@@ -610,10 +692,57 @@ 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 };
+}
+var degradationReason;
+function sessionKanbanDegradation() {
+  return degradationReason;
+}
 async function hydrateSessionKanban(context) {
   const id = context.session?.id ?? "";
   if (!id) return null;
+  try {
+    const board = await hydrateSessionKanbanBoard(context, id);
+    degradationReason = void 0;
+    return board;
+  } catch (error) {
+    degradationReason = error instanceof Error ? error.message : String(error);
+    fireAndForget("hydrate", Promise.reject(error));
+    return null;
+  }
+}
+async function hydrateSessionKanbanBoard(context, id) {
+  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);
@@ -644,26 +773,68 @@ function todoStatus(task) {
   if (status === "in_progress" || status === "review") return "in_progress";
   return "pending";
 }
-function sessionTodoFromTask(task, boardId) {
+function sessionTodoFromTask(task, board) {
+  const blockedBy = board ? blockingTitles(board, task) : [];
   return {
     id: task.origin?.taskId ?? task.id,
     content: task.title,
     status: todoStatus(task),
-    kanbanBoardId: boardId,
-    kanbanTaskId: task.id,
-    ...task.description ? { activeForm: task.description } : {}
+    ...task.description ? { activeForm: task.description } : {},
+    ...blockedBy.length ? { blockedBy } : {}
   };
 }
-function managedTodoFromTask(task, boardId) {
+function managedTodoFromTask(task, board) {
   return {
-    ...sessionTodoFromTask(task, boardId),
-    status: task.status === "completed" ? "completed" : task.status === "in_progress" ? "in_progress" : "pending"
+    ...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;
+    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) {
@@ -671,13 +842,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((task) => sessionTodoFromTask(task, board.id));
+  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];
@@ -698,11 +869,12 @@ function applyManagedKanbanBoardToTodos(context, board) {
   if (!activeBoardId || board.id !== activeBoardId || board.lifecycle?.mode !== "managed") {
     return [...context.todos];
   }
-  const projectedTodos = 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
-  ).map((task) => managedTodoFromTask(task, board.id));
+  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 {
@@ -737,7 +909,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(),
@@ -755,7 +931,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(
@@ -778,6 +958,7 @@ export {
   applySessionKanbanBoardToTodos,
   applySessionKanbanTaskToSource,
   attachSessionKanbanMirror,
+  blockingTitles,
   cleanupEmptySessionKanbanBoards,
   cleanupSessionKanbanBoard,
   cleanupSessionKanbanBoardIfEmpty,
@@ -786,11 +967,16 @@ export {
   mirrorSessionPlanToKanban,
   mirrorSessionTasksToKanban,
   mirrorSessionTodosToKanban,
+  orderTasksForTodos,
   planFileToSerializedGraph,
   projectSessionPlanToKanban,
   projectSessionTasksToKanban,
   projectSessionTodosToKanban,
+  rebindSessionKanbanTask,
+  sessionKanbanDegradation,
+  takeSessionMirrorFailure,
   taskFileToSerializedGraph,
-  todoListToSerializedGraph
+  todoListToSerializedGraph,
+  todosNeedingSessionMirror
 };
 //# sourceMappingURL=session-kanban.js.map