@wrongstack/tools 0.313.0 → 0.313.1

package/dist/chunk-QNJ7AQ4B.js

@@ -0,0 +1,1000 @@
+// src/session-kanban.ts
+import { watch } from "node:fs";
+import { basename, dirname } from "node:path";
+import { loadPlan, loadTasks } from "@wrongstack/core/storage";
+import { deserializeTaskGraph } from "@wrongstack/core/tasking";
+import {
+  bridgeKanbanSupervisor,
+  compactSessionMirrorBoard,
+  createBoard,
+  DEFAULT_COLUMNS,
+  getBoard,
+  getKanbanOrchestrationSnapshot,
+  listBoards,
+  pruneSessionBoards,
+  removeBoard,
+  syncBoardFromTaskGraph,
+  touchKanbanPresence,
+  updateBoard
+} from "@wrongstack/kanban";
+
+// src/session-kanban-graph.ts
+var PLAN_STATUS_TO_TASK = {
+  open: "pending",
+  in_progress: "in_progress",
+  done: "completed"
+};
+function todoListToSerializedGraph(todos, sessionId) {
+  const graphId = `todo:${sessionId}`;
+  const nodes = todos.map((todo, index) => ({
+    id: todo.id,
+    title: todo.content,
+    description: todo.activeForm ?? "",
+    type: "chore",
+    priority: "medium",
+    status: todo.status,
+    specRequirementId: `${graphId}:${todo.id}`,
+    createdAt: index,
+    updatedAt: index
+  }));
+  return {
+    id: graphId,
+    specId: graphId,
+    requiredRequirementIds: nodes.map((node) => node.specRequirementId),
+    title: "Session todos",
+    nodes,
+    edges: [],
+    rootNodes: nodes.map((node) => node.id),
+    createdAt: 0,
+    updatedAt: 0
+  };
+}
+function taskFileToSerializedGraph(tasks, sessionId) {
+  const graphId = `session:${sessionId}`;
+  const ids = new Set(tasks.map((task) => task.id));
+  const nodes = tasks.map((task, index) => ({
+    id: task.id,
+    title: task.title,
+    description: task.description ?? "",
+    type: task.type,
+    priority: task.priority,
+    status: task.status,
+    specRequirementId: `${graphId}:${task.id}`,
+    ...task.assignee ? { assignee: task.assignee } : {},
+    ...task.estimateHours !== void 0 ? { estimateHours: task.estimateHours } : {},
+    createdAt: index,
+    updatedAt: index
+  }));
+  const edges = tasks.flatMap(
+    (task) => (task.dependsOn ?? []).filter((dependency) => ids.has(dependency)).map((dependency) => ({
+      id: `${dependency}->${task.id}`,
+      from: dependency,
+      to: task.id,
+      type: "depends_on"
+    }))
+  );
+  const hasIncoming = new Set(edges.map((edge) => edge.to));
+  const rootNodes = nodes.filter((node) => !hasIncoming.has(node.id)).map((node) => node.id);
+  return {
+    // Keep the historical graph id so existing mirrored task cards are reused.
+    id: graphId,
+    specId: graphId,
+    requiredRequirementIds: nodes.map((node) => node.specRequirementId),
+    title: "Session tasks",
+    nodes,
+    edges,
+    rootNodes: rootNodes.length ? rootNodes : nodes[0] ? [nodes[0].id] : [],
+    createdAt: 0,
+    updatedAt: 0
+  };
+}
+function planFileToSerializedGraph(items, sessionId) {
+  const graphId = `plan:${sessionId}`;
+  const nodes = items.map((item, index) => ({
+    id: item.id,
+    title: item.title,
+    description: item.details ?? "",
+    type: "chore",
+    priority: "medium",
+    status: PLAN_STATUS_TO_TASK[item.status],
+    specRequirementId: `${graphId}:${item.id}`,
+    createdAt: index,
+    updatedAt: index
+  }));
+  return {
+    id: graphId,
+    specId: graphId,
+    requiredRequirementIds: nodes.map((node) => node.specRequirementId),
+    title: "Session plan",
+    nodes,
+    edges: [],
+    rootNodes: nodes.map((node) => node.id),
+    createdAt: 0,
+    updatedAt: 0
+  };
+}
+
+// src/session-kanban-sync.ts
+import { getSharedProjectMailbox } from "@wrongstack/core/coordination";
+import { mutatePlan, mutateTasks } from "@wrongstack/core/storage";
+import { formatTodosForModel, resolveWstackPaths } from "@wrongstack/core/utils";
+import {
+  getDependencyReadinessIssues
+} from "@wrongstack/kanban";
+function sourceStatus(task) {
+  if (task.status === "completed") return "completed";
+  if (task.status === "in_progress") return "in_progress";
+  if (task.status === "review") return "review";
+  if (task.status === "blocked") return "blocked";
+  if (task.status === "failed") return "failed";
+  return "pending";
+}
+function todoStatus(task) {
+  const status = sourceStatus(task);
+  if (status === "completed") return "completed";
+  if (status === "review" && task.assignment?.status === "completed") return "completed";
+  if (status === "in_progress" || status === "review") return "in_progress";
+  return "pending";
+}
+function sessionTodoFromTask(task, board) {
+  const blockedBy = board ? blockingTitles(board, task) : [];
+  return {
+    id: task.origin?.taskId ?? task.id,
+    content: task.title,
+    status: todoStatus(task),
+    ...task.description ? { activeForm: task.description } : {},
+    ...blockedBy.length ? { blockedBy } : {}
+  };
+}
+function managedTodoFromTask(task, board) {
+  return {
+    ...sessionTodoFromTask(task, board),
+    kanbanBoardId: board.id,
+    kanbanTaskId: task.id
+  };
+}
+function blockingTitles(board, task) {
+  return getDependencyReadinessIssues(board, task).map((issue) => {
+    const dependency = board.tasks.find((candidate) => candidate.id === issue.dependencyId);
+    if (!dependency) return `${issue.dependencyId} (missing)`;
+    return dependency.title;
+  });
+}
+var PRIORITY_ORDER = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3
+};
+function orderTasksForTodos(board, tasks) {
+  const columnOrder = new Map(board.columns.map((column) => [column.id, column.order]));
+  const baseline = [...tasks].sort(
+    (left, right) => (columnOrder.get(left.columnId) ?? 0) - (columnOrder.get(right.columnId) ?? 0) || (PRIORITY_ORDER[left.priority] ?? 2) - (PRIORITY_ORDER[right.priority] ?? 2) || left.order - right.order || left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id)
+  );
+  const included = new Set(baseline.map((task) => task.id));
+  const remaining = new Map(baseline.map((task) => [task.id, task]));
+  const emitted = [];
+  const done = /* @__PURE__ */ new Set();
+  while (remaining.size > 0) {
+    const ready = baseline.filter(
+      (task) => remaining.has(task.id) && (task.dependsOn ?? []).every(
+        (dependencyId) => !included.has(dependencyId) || done.has(dependencyId)
+      )
+    );
+    if (ready.length === 0) break;
+    for (const task of ready) {
+      remaining.delete(task.id);
+      done.add(task.id);
+      emitted.push(task);
+    }
+  }
+  for (const task of baseline) if (remaining.has(task.id)) emitted.push(task);
+  return emitted;
+}
+function sameTodos(left, right) {
+  return left.length === right.length && left.every((todo, index) => {
+    const candidate = right[index];
+    return candidate?.id === todo.id && candidate.content === todo.content && candidate.status === todo.status && candidate.activeForm === todo.activeForm && candidate.promotedFromPlan === todo.promotedFromPlan && candidate.promotedFromTask === todo.promotedFromTask && candidate.kanbanBoardId === todo.kanbanBoardId && candidate.kanbanTaskId === todo.kanbanTaskId && (candidate.blockedBy ?? []).join("\0") === (todo.blockedBy ?? []).join("\0");
+  });
+}
+function broadcastTodoUpdate(context, todos) {
+  const sessionId = context.session?.id ?? "";
+  if (!context.agentId || !sessionId) return;
+  const statusCounts = { pending: 0, inProgress: 0, completed: 0 };
+  for (const todo of todos) {
+    if (todo.status === "completed") statusCounts.completed++;
+    else if (todo.status === "in_progress") statusCounts.inProgress++;
+    else statusCounts.pending++;
+  }
+  const projectDir = resolveWstackPaths({ projectRoot: context.projectRoot }).projectDir;
+  const mailbox = getSharedProjectMailbox(projectDir);
+  void mailbox.send({
+    from: context.agentId,
+    to: `@session:${sessionId}`,
+    type: "status",
+    subject: `Kanban todo list updated (${todos.length} item${todos.length === 1 ? "" : "s"})`,
+    body: `Shared Kanban board synced this session's todo list: ${todos.length} item${todos.length === 1 ? "" : "s"} \u2014 ${statusCounts.completed} completed, ${statusCounts.inProgress} in progress, ${statusCounts.pending} pending.`,
+    priority: "normal",
+    senderSessionId: sessionId
+  }).catch(() => {
+  });
+}
+function notifyTodoUpdate(context, todos) {
+  const summary = formatTodosForModel(todos);
+  const text = `[KANBAN TODO UPDATE]
+Another Kanban agent reassessed the shared board. The canonical todo list is now:
+${summary}
+Reassess your current plan before continuing; do not rely on the initial todo snapshot. Preserve each row's <kanban board/task> binding verbatim on your next \`todo\` call \u2014 a row that loses it stops advancing its card.`;
+  const state = context.state;
+  if (typeof state.appendBlockToLastUserMessage === "function") {
+    if (state.appendBlockToLastUserMessage({ type: "text", text })) return;
+  }
+  if (typeof state.appendMessage === "function") {
+    state.appendMessage({ role: "user", content: [{ type: "text", text }] });
+  }
+}
+function todosNeedingSessionMirror(todos, activeBoardId) {
+  if (!activeBoardId) return todos;
+  return todos.filter((todo) => todo.kanbanBoardId !== activeBoardId || !todo.kanbanTaskId);
+}
+function applySessionKanbanBoardToTodos(context, board, options) {
+  const sessionId = context.session?.id ?? "";
+  if (!sessionId || options.sessionIdFromTags(board.tags) !== sessionId || !options.isOwnedSessionBoard(board.tags)) {
+    return [...context.todos];
+  }
+  if (options.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];
+  options.suppressedTodoMirrors.add(context);
+  try {
+    context.state.replaceTodos(projectedTodos);
+  } finally {
+    options.suppressedTodoMirrors.delete(context);
+  }
+  notifyTodoUpdate(context, context.todos);
+  broadcastTodoUpdate(context, context.todos);
+  return [...context.todos];
+}
+function applyManagedKanbanBoardToTodos(context, board, suppressedTodoMirrors2, options = {}) {
+  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 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 bindings = /* @__PURE__ */ new WeakMap();
+var suppressedTodoMirrors = /* @__PURE__ */ new WeakSet();
+var activeSessionBoards = /* @__PURE__ */ new Map();
+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 isOwnedSessionBoard(tags) {
+  return Boolean(tags?.includes(SESSION_BOARD_TAG) && sessionIdFromTags(tags));
+}
+function retainActiveSessionBoard(projectRoot, sessionId) {
+  const key = boardKey(projectRoot, sessionId);
+  activeSessionBoards.set(key, (activeSessionBoards.get(key) ?? 0) + 1);
+}
+function releaseActiveSessionBoard(projectRoot, sessionId) {
+  const key = boardKey(projectRoot, sessionId);
+  const remaining = (activeSessionBoards.get(key) ?? 0) - 1;
+  if (remaining > 0) activeSessionBoards.set(key, remaining);
+  else activeSessionBoards.delete(key);
+}
+function isSessionBoardActive(projectRoot, sessionId) {
+  return (activeSessionBoards.get(boardKey(projectRoot, sessionId)) ?? 0) > 0;
+}
+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 removeEmptySessionBoard(projectRoot, boardId, sessionId) {
+  return enqueueBoardWork(projectRoot, sessionId, async () => {
+    if (isSessionBoardActive(projectRoot, sessionId)) return null;
+    const board = await getBoard(projectRoot, boardId);
+    if (!board || board.tasks.length > 0 || !isOwnedSessionBoard(board.tags)) return null;
+    if (sessionIdFromTags(board.tags) !== sessionId) return null;
+    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 [];
+  const candidates = (await listBoards(projectRoot)).filter(
+    (board) => board.taskCount === 0 && isOwnedSessionBoard(board.tags) && sessionIdFromTags(board.tags) === sessionId
+  );
+  const removed = await Promise.all(
+    candidates.map((board) => removeEmptySessionBoard(projectRoot, board.id, sessionId))
+  );
+  return removed.filter((boardId) => Boolean(boardId));
+}
+async function cleanupEmptySessionKanbanBoards(projectRoot, activeSessionId = "") {
+  if (!projectRoot || process.env[MIRROR_DISABLED_ENV] === "0") return [];
+  const candidates = (await listBoards(projectRoot)).flatMap((board) => {
+    const ownerSessionId = sessionIdFromTags(board.tags);
+    return board.taskCount === 0 && isOwnedSessionBoard(board.tags) && ownerSessionId && ownerSessionId !== activeSessionId && !isSessionBoardActive(projectRoot, ownerSessionId) ? [{ boardId: board.id, sessionId: ownerSessionId }] : [];
+  });
+  const removed = await Promise.all(
+    candidates.map(
+      ({ boardId, sessionId }) => removeEmptySessionBoard(projectRoot, boardId, sessionId)
+    )
+  );
+  return removed.filter((boardId) => Boolean(boardId));
+}
+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 hasInFlightTodoMirror(projectRoot, sessionId) {
+  if (!projectRoot || !sessionId) return false;
+  const key = mirrorKey(projectRoot, sessionId, "session-todo");
+  return pendingMirrors.has(key) || activeMirrors.has(key);
+}
+function projectSessionTodosToKanban(projectRoot, todos, sessionId) {
+  return projectGraph(
+    projectRoot,
+    sessionId,
+    todoListToSerializedGraph(todos, sessionId),
+    "session-todo"
+  );
+}
+function projectSessionTasksToKanban(projectRoot, tasks, sessionId) {
+  return projectGraph(
+    projectRoot,
+    sessionId,
+    taskFileToSerializedGraph(tasks, sessionId),
+    "session-task"
+  );
+}
+function projectSessionPlanToKanban(projectRoot, items, sessionId) {
+  return projectGraph(
+    projectRoot,
+    sessionId,
+    planFileToSerializedGraph(items, sessionId),
+    "session-plan"
+  );
+}
+function fireAndForget(context, work) {
+  void work.catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.warn(
+      JSON.stringify({
+        level: "warn",
+        event: "session-kanban",
+        context,
+        message,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  });
+}
+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 mirrorSessionPlanToKanban(projectRoot, items, sessionId) {
+  queueLatestMirror(
+    projectRoot,
+    sessionId,
+    planFileToSerializedGraph(items, sessionId),
+    "session-plan"
+  );
+}
+function attachSessionKanbanMirror(context) {
+  const existing = bindings.get(context);
+  if (existing) return existing;
+  const attachedProjectRoot = context.projectRoot ?? "";
+  let registeredSessionId = "";
+  const syncActiveSessionRegistration = () => {
+    if (!attachedProjectRoot) return;
+    const currentSessionId = context.session?.id ?? "";
+    if (currentSessionId === registeredSessionId) return;
+    if (registeredSessionId) {
+      releaseActiveSessionBoard(attachedProjectRoot, registeredSessionId);
+      fireAndForget(
+        "cleanup-board",
+        cleanupSessionKanbanBoard(attachedProjectRoot, registeredSessionId)
+      );
+    }
+    registeredSessionId = currentSessionId;
+    if (registeredSessionId) {
+      retainActiveSessionBoard(attachedProjectRoot, registeredSessionId);
+    }
+  };
+  syncActiveSessionRegistration();
+  let watcher = null;
+  let watchedDir = "";
+  let timer = null;
+  let unsubscribeBoardEvents = null;
+  let watchedBoardId = "";
+  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;
+    const planPath = context.meta["plan.path"];
+    if (typeof planPath === "string" && planPath) {
+      const plan = await loadPlan(planPath);
+      if (plan) await projectSessionPlanToKanban(context.projectRoot, plan.items, id);
+    }
+    const taskPath = context.meta["task.path"];
+    if (typeof taskPath === "string" && taskPath) {
+      const tasks = await loadTasks(taskPath);
+      if (tasks) await projectSessionTasksToKanban(context.projectRoot, tasks.tasks, id);
+    }
+  };
+  const refreshBoard = async () => {
+    if (!watchedBoardId) return;
+    const board = await getBoard(context.projectRoot, watchedBoardId);
+    if (!board) return;
+    if (board.lifecycle?.mode === "managed") applyManagedKanbanBoardToTodos2(context, board);
+    else applySessionKanbanBoardToTodos2(context, board);
+  };
+  const configureBoardWatcher = async () => {
+    const id = sessionId();
+    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;
+    try {
+      unsubscribeBoardEvents = bridgeKanbanSupervisor(
+        context.projectRoot,
+        (event) => {
+          const data = event.data;
+          if (data?.boardId !== board.id) return;
+          if (boardTimer) clearTimeout(boardTimer);
+          boardTimer = setTimeout(() => fireAndForget("refresh-board", refreshBoard()), 60);
+        },
+        { autoReconnect: true, reconnectDelayMs: 1e3 }
+      );
+      const touchPresence = () => touchKanbanPresence(context.projectRoot, board.id, {
+        sessionId: id,
+        agentId: context.agentId,
+        agentName: context.agentName
+      });
+      fireAndForget("touch-presence", touchPresence());
+      if (presenceTimer) clearInterval(presenceTimer);
+      presenceTimer = setInterval(() => fireAndForget("touch-presence", touchPresence()), 6e4);
+      presenceTimer.unref?.();
+      if (board.lifecycle?.mode === "managed") applyManagedKanbanBoardToTodos2(context, board);
+    } catch {
+      unsubscribeBoardEvents = null;
+      watchedBoardId = "";
+    }
+  };
+  const configureWatcher = () => {
+    const planPath = context.meta["plan.path"];
+    const taskPath = context.meta["task.path"];
+    const candidate = typeof planPath === "string" && planPath ? dirname(planPath) : typeof taskPath === "string" && taskPath ? dirname(taskPath) : "";
+    if (!candidate || candidate === watchedDir) return;
+    watcher?.close();
+    watcher = null;
+    watchedDir = candidate;
+    try {
+      watcher = watch(candidate, { persistent: false }, (_event, filename) => {
+        const name = filename?.toString();
+        const currentPlanPath = context.meta["plan.path"];
+        const currentTaskPath = context.meta["task.path"];
+        const planName = typeof currentPlanPath === "string" ? basename(currentPlanPath) : "";
+        const taskName = typeof currentTaskPath === "string" ? basename(currentTaskPath) : "";
+        if (name && name !== planName && name !== taskName) return;
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(() => fireAndForget("refresh-files", refreshFiles()), 60);
+      });
+      watcher.on("error", () => watcher?.close());
+    } catch {
+      watcher = null;
+      watchedDir = "";
+    }
+  };
+  const unsubscribe = context.state.onChange((change) => {
+    if (change.kind === "todos_replaced" && !suppressedTodoMirrors.has(context)) {
+      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" || change.key === "kanban")) {
+      syncActiveSessionRegistration();
+      configureWatcher();
+      if (!activeManagedBoardId()) {
+        fireAndForget("ensure-board", ensureSessionKanbanBoard(context.projectRoot, sessionId()));
+      }
+      fireAndForget("configure-watcher", configureBoardWatcher());
+      fireAndForget("refresh-board", refreshBoard());
+      fireAndForget("refresh-files", refreshFiles());
+    }
+  });
+  configureWatcher();
+  fireAndForget("configure-watcher", configureBoardWatcher());
+  const detach = () => {
+    unsubscribe();
+    if (timer) clearTimeout(timer);
+    if (boardTimer) clearTimeout(boardTimer);
+    if (presenceTimer) clearInterval(presenceTimer);
+    watcher?.close();
+    unsubscribeBoardEvents?.();
+    bindings.delete(context);
+    if (attachedProjectRoot && registeredSessionId) {
+      releaseActiveSessionBoard(attachedProjectRoot, registeredSessionId);
+      fireAndForget(
+        "cleanup-board",
+        cleanupSessionKanbanBoard(attachedProjectRoot, registeredSessionId)
+      );
+      registeredSessionId = "";
+    }
+  };
+  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);
+  }
+  const planPath = context.meta["plan.path"];
+  if (typeof planPath === "string" && planPath) {
+    const plan = await loadPlan(planPath);
+    if (plan) board = await projectSessionPlanToKanban(context.projectRoot, plan.items, id);
+  }
+  const taskPath = context.meta["task.path"];
+  if (typeof taskPath === "string" && taskPath) {
+    const tasks = await loadTasks(taskPath);
+    if (tasks) board = await projectSessionTasksToKanban(context.projectRoot, tasks.tasks, id);
+  }
+  return board;
+}
+function applySessionKanbanBoardToTodos2(context, board) {
+  return applySessionKanbanBoardToTodos(context, board, {
+    sessionIdFromTags,
+    isOwnedSessionBoard,
+    hasInFlightTodoMirror,
+    suppressedTodoMirrors
+  });
+}
+function applyManagedKanbanBoardToTodos2(context, board) {
+  return applyManagedKanbanBoardToTodos(context, board, suppressedTodoMirrors, {
+    sessionOwnerFromTags: sessionIdFromTags
+  });
+}
+function applySessionKanbanTaskToSource2(context, task, options = {}) {
+  return applySessionKanbanTaskToSource(context, task, suppressedTodoMirrors, options);
+}
+
+export {
+  PLAN_STATUS_TO_TASK,
+  todoListToSerializedGraph,
+  taskFileToSerializedGraph,
+  planFileToSerializedGraph,
+  blockingTitles,
+  orderTasksForTodos,
+  todosNeedingSessionMirror,
+  SESSION_KANBAN_COLUMNS,
+  ensureSessionKanbanBoard,
+  cleanupSessionKanbanBoard,
+  cleanupSessionKanbanBoardIfEmpty,
+  cleanupEmptySessionKanbanBoards,
+  takeSessionMirrorFailure,
+  projectSessionTodosToKanban,
+  projectSessionTasksToKanban,
+  projectSessionPlanToKanban,
+  mirrorSessionTodosToKanban,
+  mirrorSessionTasksToKanban,
+  mirrorSessionPlanToKanban,
+  attachSessionKanbanMirror,
+  rebindSessionKanbanTask,
+  sessionKanbanDegradation,
+  hydrateSessionKanban,
+  applySessionKanbanBoardToTodos2 as applySessionKanbanBoardToTodos,
+  applyManagedKanbanBoardToTodos2 as applyManagedKanbanBoardToTodos,
+  applySessionKanbanTaskToSource2 as applySessionKanbanTaskToSource
+};
+//# sourceMappingURL=chunk-QNJ7AQ4B.js.map