@wrongstack/tools 0.286.0 → 0.289.0

package/dist/session-kanban.js

@@ -0,0 +1,626 @@
+// src/session-kanban.ts
+import { watch } from "node:fs";
+import { basename, dirname } from "node:path";
+import {
+  deserializeTaskGraph,
+  GlobalMailbox,
+  loadPlan,
+  loadTasks,
+  mutatePlan,
+  mutateTasks
+} from "@wrongstack/core";
+import { resolveWstackPaths } from "@wrongstack/core/utils";
+import {
+  createBoard,
+  getBoard,
+  getKanbanDir,
+  listBoards,
+  removeBoard,
+  syncBoardFromTaskGraph,
+  touchKanbanPresence,
+  updateBoard
+} 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 boardQueue = /* @__PURE__ */ new Map();
+var boardEnsures = /* @__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 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}`
+      });
+    }
+    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 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
+      }
+    );
+    return result?.board ?? null;
+  });
+}
+function todoListToSerializedGraph(todos, sessionId) {
+  const nodes = todos.map((todo, index) => ({
+    id: todo.id,
+    title: todo.content,
+    description: todo.activeForm ?? "",
+    type: "chore",
+    priority: "medium",
+    status: todo.status,
+    createdAt: index,
+    updatedAt: index
+  }));
+  return {
+    id: `todo:${sessionId}`,
+    specId: `todo:${sessionId}`,
+    title: "Session todos",
+    nodes,
+    edges: [],
+    rootNodes: nodes.map((node) => node.id),
+    createdAt: 0,
+    updatedAt: 0
+  };
+}
+function taskFileToSerializedGraph(tasks, 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,
+    ...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: `session:${sessionId}`,
+    specId: `session:${sessionId}`,
+    title: "Session tasks",
+    nodes,
+    edges,
+    rootNodes: rootNodes.length ? rootNodes : nodes[0] ? [nodes[0].id] : [],
+    createdAt: 0,
+    updatedAt: 0
+  };
+}
+var PLAN_STATUS_TO_TASK = {
+  open: "pending",
+  in_progress: "in_progress",
+  done: "completed"
+};
+function planFileToSerializedGraph(items, 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],
+    createdAt: index,
+    updatedAt: index
+  }));
+  return {
+    id: `plan:${sessionId}`,
+    specId: `plan:${sessionId}`,
+    title: "Session plan",
+    nodes,
+    edges: [],
+    rootNodes: nodes.map((node) => node.id),
+    createdAt: 0,
+    updatedAt: 0
+  };
+}
+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(work) {
+  void work.catch(() => {
+  });
+}
+function broadcastTodoUpdate(context, todos) {
+  const sessionId = context.session?.id ?? "";
+  if (!context.agentId || !sessionId) return;
+  const projectDir = resolveWstackPaths({ projectRoot: context.projectRoot }).projectDir;
+  const mailbox = new GlobalMailbox(projectDir);
+  void mailbox.send({
+    from: context.agentId,
+    to: "*",
+    type: "status",
+    subject: `Kanban todo list updated (${todos.length} item${todos.length === 1 ? "" : "s"})`,
+    body: JSON.stringify({
+      kind: "kanban.todos.updated",
+      sessionId,
+      revision: context.state.revision,
+      todos
+    }),
+    priority: "normal",
+    senderSessionId: sessionId,
+    ttlMs: 6 * 60 * 60 * 1e3
+  }).catch(() => {
+  });
+}
+function notifyTodoUpdate(context, todos) {
+  const summary = todos.length ? todos.map((todo) => `- [${todo.status}] ${todo.content} (${todo.id})`).join("\n") : "- No active todos remain.";
+  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.`;
+  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 mirrorSessionTodosToKanban(projectRoot, todos, sessionId) {
+  fireAndForget(projectSessionTodosToKanban(projectRoot, todos, sessionId));
+}
+function mirrorSessionTasksToKanban(projectRoot, tasks, sessionId) {
+  fireAndForget(projectSessionTasksToKanban(projectRoot, tasks, sessionId));
+}
+function mirrorSessionPlanToKanban(projectRoot, items, sessionId) {
+  fireAndForget(projectSessionPlanToKanban(projectRoot, items, sessionId));
+}
+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(cleanupSessionKanbanBoardIfEmpty(attachedProjectRoot, registeredSessionId));
+    }
+    registeredSessionId = currentSessionId;
+    if (registeredSessionId) {
+      retainActiveSessionBoard(attachedProjectRoot, registeredSessionId);
+    }
+  };
+  syncActiveSessionRegistration();
+  let watcher = null;
+  let watchedDir = "";
+  let timer = null;
+  let boardWatcher = null;
+  let watchedBoardId = "";
+  let boardTimer = null;
+  let presenceTimer = null;
+  const sessionId = () => context.session?.id ?? "";
+  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) applySessionKanbanBoardToTodos(context, board);
+  };
+  const configureBoardWatcher = async () => {
+    const id = sessionId();
+    const board = id ? await ensureSessionKanbanBoard(context.projectRoot, id) : null;
+    if (!board || board.id === watchedBoardId) return;
+    boardWatcher?.close();
+    boardWatcher = null;
+    watchedBoardId = board.id;
+    try {
+      const boardFileName = `${board.id}.json`;
+      boardWatcher = watch(
+        getKanbanDir(context.projectRoot),
+        { persistent: false },
+        (_event, filename) => {
+          if (filename?.toString() !== boardFileName) return;
+          if (boardTimer) clearTimeout(boardTimer);
+          boardTimer = setTimeout(() => fireAndForget(refreshBoard()), 60);
+        }
+      );
+      const touchPresence = () => touchKanbanPresence(context.projectRoot, board.id, {
+        sessionId: id,
+        agentId: context.agentId,
+        agentName: context.agentName
+      });
+      fireAndForget(touchPresence());
+      if (presenceTimer) clearInterval(presenceTimer);
+      presenceTimer = setInterval(() => fireAndForget(touchPresence()), 6e4);
+      presenceTimer.unref?.();
+      boardWatcher.on("error", () => {
+        boardWatcher?.close();
+        boardWatcher = null;
+        watchedBoardId = "";
+      });
+    } catch {
+      boardWatcher = 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(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)) {
+      mirrorSessionTodosToKanban(
+        context.projectRoot,
+        change.completedSnapshot ?? change.todos,
+        sessionId()
+      );
+      return;
+    }
+    if (change.kind === "meta_set" && (change.key === "plan.path" || change.key === "task.path")) {
+      syncActiveSessionRegistration();
+      configureWatcher();
+      fireAndForget(ensureSessionKanbanBoard(context.projectRoot, sessionId()));
+      fireAndForget(configureBoardWatcher());
+      fireAndForget(refreshFiles());
+    }
+  });
+  configureWatcher();
+  fireAndForget(configureBoardWatcher());
+  const detach = () => {
+    unsubscribe();
+    if (timer) clearTimeout(timer);
+    if (boardTimer) clearTimeout(boardTimer);
+    if (presenceTimer) clearInterval(presenceTimer);
+    watcher?.close();
+    boardWatcher?.close();
+    bindings.delete(context);
+    if (attachedProjectRoot && registeredSessionId) {
+      releaseActiveSessionBoard(attachedProjectRoot, registeredSessionId);
+      fireAndForget(cleanupSessionKanbanBoardIfEmpty(attachedProjectRoot, registeredSessionId));
+      registeredSessionId = "";
+    }
+  };
+  bindings.set(context, detach);
+  return detach;
+}
+async function hydrateSessionKanban(context) {
+  const id = context.session?.id ?? "";
+  if (!id) return null;
+  await cleanupEmptySessionKanbanBoards(context.projectRoot, id);
+  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 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 === "in_progress" || status === "review") return "in_progress";
+  return "pending";
+}
+function sessionTodoFromTask(task) {
+  return {
+    id: task.origin?.taskId ?? task.id,
+    content: task.title,
+    status: todoStatus(task),
+    ...task.description ? { activeForm: task.description } : {}
+  };
+}
+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;
+  });
+}
+function applySessionKanbanBoardToTodos(context, board) {
+  const sessionId = context.session?.id ?? "";
+  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);
+  const allCompleted = projectedTodos.length > 0 && projectedTodos.every((todo) => todo.status === "completed");
+  const effectiveTodos = allCompleted ? [] : projectedTodos;
+  if (sameTodos(context.todos, effectiveTodos)) 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 ?? "";
+  if (!originId) return { source: null };
+  if (task.origin?.system === "session-todo" || graphId.startsWith("todo:")) {
+    const next = options.remove ? context.todos.filter((todo) => todo.id !== originId) : context.todos.map(
+      (todo) => todo.id === originId ? {
+        ...todo,
+        content: task.title,
+        status: sourceStatus(task) === "completed" ? "completed" : sourceStatus(task) === "in_progress" || sourceStatus(task) === "review" ? "in_progress" : "pending"
+      } : todo
+    );
+    suppressedTodoMirrors.add(context);
+    try {
+      context.state.replaceTodos(next);
+    } finally {
+      suppressedTodoMirrors.delete(context);
+    }
+    return { source: "todo", todos: [...context.todos] };
+  }
+  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" };
+    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) return { source: "task" };
+    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 };
+}
+export {
+  SESSION_KANBAN_COLUMNS,
+  applySessionKanbanBoardToTodos,
+  applySessionKanbanTaskToSource,
+  attachSessionKanbanMirror,
+  cleanupEmptySessionKanbanBoards,
+  cleanupSessionKanbanBoardIfEmpty,
+  ensureSessionKanbanBoard,
+  hydrateSessionKanban,
+  mirrorSessionPlanToKanban,
+  mirrorSessionTasksToKanban,
+  mirrorSessionTodosToKanban,
+  planFileToSerializedGraph,
+  projectSessionPlanToKanban,
+  projectSessionTasksToKanban,
+  projectSessionTodosToKanban,
+  taskFileToSerializedGraph,
+  todoListToSerializedGraph
+};
+//# sourceMappingURL=session-kanban.js.map