@saga-ai/dashboard 3.0.0

package/dist/cli.cjs

@@ -0,0 +1,1736 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path10 = require("node:path");
+var import_node_process6 = __toESM(require("node:process"), 1);
+var import_commander = require("commander");
+
+// src/commands/dashboard.ts
+var import_node_process4 = __toESM(require("node:process"), 1);
+
+// src/server/index.ts
+var import_node_http = require("node:http");
+var import_node_path8 = require("node:path");
+var import_express3 = __toESM(require("express"), 1);
+
+// src/server/routes.ts
+var import_node_path4 = require("node:path");
+var import_express2 = require("express");
+
+// src/server/parser.ts
+var import_promises2 = require("node:fs/promises");
+var import_node_path2 = require("node:path");
+var import_gray_matter2 = __toESM(require("gray-matter"), 1);
+
+// src/utils/saga-scanner.ts
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+var EPIC_TITLE_PATTERN = /^#\s+(.+)$/m;
+var STORY_MD_SUFFIX_PATTERN = /\/story\.md$/;
+async function isDirectory(path) {
+  try {
+    const stats = await (0, import_promises.stat)(path);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function fileExists(path) {
+  try {
+    await (0, import_promises.stat)(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function extractEpicTitle(content) {
+  const match = content.match(EPIC_TITLE_PATTERN);
+  return match ? match[1].trim() : null;
+}
+async function parseStoryFile(storyPath, epicSlug, options = {}) {
+  try {
+    const content = await (0, import_promises.readFile)(storyPath, "utf-8");
+    const storyDir = storyPath.replace(STORY_MD_SUFFIX_PATTERN, "");
+    const dirName = storyDir.split("/").pop() || "unknown";
+    const parsed = (0, import_gray_matter.default)(content);
+    const frontmatter = parsed.data;
+    const body = parsed.content;
+    const journalPath = (0, import_node_path.join)(storyDir, "journal.md");
+    const hasJournal = await fileExists(journalPath);
+    return {
+      slug: frontmatter.id || frontmatter.slug || dirName,
+      title: frontmatter.title || dirName,
+      status: frontmatter.status || "ready",
+      epicSlug,
+      storyPath,
+      worktreePath: options.worktreePath,
+      journalPath: hasJournal ? journalPath : void 0,
+      archived: options.archived,
+      frontmatter,
+      body
+    };
+  } catch {
+    return null;
+  }
+}
+async function scanWorktrees(sagaRoot) {
+  const worktreesDir = (0, import_node_path.join)(sagaRoot, ".saga", "worktrees");
+  if (!await isDirectory(worktreesDir)) {
+    return [];
+  }
+  const epicEntries = await (0, import_promises.readdir)(worktreesDir);
+  const epicPromises = epicEntries.map(async (epicSlug) => {
+    const epicWorktreesDir = (0, import_node_path.join)(worktreesDir, epicSlug);
+    if (!await isDirectory(epicWorktreesDir)) {
+      return [];
+    }
+    const storyEntries = await (0, import_promises.readdir)(epicWorktreesDir);
+    const storyPromises = storyEntries.map(async (storySlug) => {
+      const worktreePath = (0, import_node_path.join)(epicWorktreesDir, storySlug);
+      if (!await isDirectory(worktreePath)) {
+        return null;
+      }
+      const storyPath = (0, import_node_path.join)(
+        worktreePath,
+        ".saga",
+        "epics",
+        epicSlug,
+        "stories",
+        storySlug,
+        "story.md"
+      );
+      return await parseStoryFile(storyPath, epicSlug, { worktreePath });
+    });
+    const stories = await Promise.all(storyPromises);
+    return stories.filter((story) => story !== null);
+  });
+  const epicStories = await Promise.all(epicPromises);
+  return epicStories.flat();
+}
+async function scanEpicsStories(sagaRoot) {
+  const epicsDir = (0, import_node_path.join)(sagaRoot, ".saga", "epics");
+  if (!await isDirectory(epicsDir)) {
+    return [];
+  }
+  const epicEntries = await (0, import_promises.readdir)(epicsDir);
+  const epicPromises = epicEntries.map(async (epicSlug) => {
+    const storiesDir = (0, import_node_path.join)(epicsDir, epicSlug, "stories");
+    if (!await isDirectory(storiesDir)) {
+      return [];
+    }
+    const storyEntries = await (0, import_promises.readdir)(storiesDir);
+    const storyPromises = storyEntries.map(async (storySlug) => {
+      const storyDir = (0, import_node_path.join)(storiesDir, storySlug);
+      if (!await isDirectory(storyDir)) {
+        return null;
+      }
+      const storyPath = (0, import_node_path.join)(storyDir, "story.md");
+      return await parseStoryFile(storyPath, epicSlug);
+    });
+    const stories = await Promise.all(storyPromises);
+    return stories.filter((story) => story !== null);
+  });
+  const epicStories = await Promise.all(epicPromises);
+  return epicStories.flat();
+}
+async function scanArchive(sagaRoot) {
+  const archiveDir = (0, import_node_path.join)(sagaRoot, ".saga", "archive");
+  if (!await isDirectory(archiveDir)) {
+    return [];
+  }
+  const epicEntries = await (0, import_promises.readdir)(archiveDir);
+  const epicPromises = epicEntries.map(async (epicSlug) => {
+    const epicArchiveDir = (0, import_node_path.join)(archiveDir, epicSlug);
+    if (!await isDirectory(epicArchiveDir)) {
+      return [];
+    }
+    const storyEntries = await (0, import_promises.readdir)(epicArchiveDir);
+    const storyPromises = storyEntries.map(async (storySlug) => {
+      const storyDir = (0, import_node_path.join)(epicArchiveDir, storySlug);
+      if (!await isDirectory(storyDir)) {
+        return null;
+      }
+      const storyPath = (0, import_node_path.join)(storyDir, "story.md");
+      return await parseStoryFile(storyPath, epicSlug, { archived: true });
+    });
+    const stories = await Promise.all(storyPromises);
+    return stories.filter((story) => story !== null);
+  });
+  const epicStories = await Promise.all(epicPromises);
+  return epicStories.flat();
+}
+async function scanAllStories(sagaRoot) {
+  const [worktreeStories, epicsStories, archivedStories] = await Promise.all([
+    scanWorktrees(sagaRoot),
+    scanEpicsStories(sagaRoot),
+    scanArchive(sagaRoot)
+  ]);
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const story of worktreeStories) {
+    const key = `${story.epicSlug}/${story.slug}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(story);
+    }
+  }
+  for (const story of epicsStories) {
+    const key = `${story.epicSlug}/${story.slug}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(story);
+    }
+  }
+  for (const story of archivedStories) {
+    const key = `${story.epicSlug}/${story.slug}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(story);
+    }
+  }
+  return result;
+}
+async function scanEpics(sagaRoot) {
+  const epicsDir = (0, import_node_path.join)(sagaRoot, ".saga", "epics");
+  if (!await isDirectory(epicsDir)) {
+    return [];
+  }
+  const epicEntries = await (0, import_promises.readdir)(epicsDir);
+  const epicPromises = epicEntries.map(async (epicSlug) => {
+    const epicPath = (0, import_node_path.join)(epicsDir, epicSlug);
+    if (!await isDirectory(epicPath)) {
+      return null;
+    }
+    const epicMdPath = (0, import_node_path.join)(epicPath, "epic.md");
+    let content = "";
+    let title = epicSlug;
+    try {
+      content = await (0, import_promises.readFile)(epicMdPath, "utf-8");
+      title = extractEpicTitle(content) || epicSlug;
+    } catch {
+    }
+    return {
+      slug: epicSlug,
+      title,
+      epicPath,
+      epicMdPath,
+      content
+    };
+  });
+  const epics = await Promise.all(epicPromises);
+  return epics.filter((epic) => epic !== null);
+}
+
+// src/server/parser.ts
+var STORY_MD_SUFFIX_PATTERN2 = /\/story\.md$/;
+var JOURNAL_SECTION_PATTERN = /^##\s+/m;
+function toApiStoryStatus(status) {
+  return status === "in_progress" ? "inProgress" : status;
+}
+function toApiTaskStatus(status) {
+  return status === "in_progress" ? "inProgress" : status;
+}
+function validateStatus(status) {
+  const validStatuses = ["ready", "in_progress", "blocked", "completed"];
+  if (typeof status === "string" && validStatuses.includes(status)) {
+    return status;
+  }
+  return "ready";
+}
+function validateTaskStatus(status) {
+  const validStatuses = ["pending", "in_progress", "completed"];
+  if (typeof status === "string" && validStatuses.includes(status)) {
+    return status;
+  }
+  return "pending";
+}
+function parseTasks(tasks) {
+  if (!Array.isArray(tasks)) {
+    return [];
+  }
+  return tasks.filter((t) => typeof t === "object" && t !== null).map((t) => ({
+    id: typeof t.id === "string" ? t.id : "unknown",
+    title: typeof t.title === "string" ? t.title : "Unknown Task",
+    status: toApiTaskStatus(validateTaskStatus(t.status))
+  }));
+}
+async function toStoryDetail(story, sagaRoot) {
+  let tasks = [];
+  try {
+    const content = await (0, import_promises2.readFile)(story.storyPath, "utf-8");
+    const parsed = (0, import_gray_matter2.default)(content);
+    tasks = parseTasks(parsed.data.tasks);
+  } catch {
+    tasks = parseTasks(story.frontmatter.tasks);
+  }
+  return {
+    slug: story.slug,
+    epicSlug: story.epicSlug,
+    title: story.title,
+    status: toApiStoryStatus(validateStatus(story.status)),
+    tasks,
+    content: story.body || void 0,
+    archived: story.archived,
+    paths: {
+      storyMd: (0, import_node_path2.relative)(sagaRoot, story.storyPath),
+      ...story.journalPath ? { journalMd: (0, import_node_path2.relative)(sagaRoot, story.journalPath) } : {},
+      ...story.worktreePath ? { worktree: (0, import_node_path2.relative)(sagaRoot, story.worktreePath) } : {}
+    }
+  };
+}
+async function buildEpic(scannedEpic, epicStories, sagaRoot) {
+  const stories = await Promise.all(epicStories.map((s) => toStoryDetail(s, sagaRoot)));
+  const storyCounts = {
+    total: stories.length,
+    ready: stories.filter((s) => s.status === "ready").length,
+    inProgress: stories.filter((s) => s.status === "inProgress").length,
+    blocked: stories.filter((s) => s.status === "blocked").length,
+    completed: stories.filter((s) => s.status === "completed").length
+  };
+  return {
+    slug: scannedEpic.slug,
+    title: scannedEpic.title,
+    content: scannedEpic.content,
+    storyCounts,
+    stories,
+    path: (0, import_node_path2.relative)(sagaRoot, scannedEpic.epicPath)
+  };
+}
+async function parseStory(storyPath, epicSlug) {
+  const { join: join10 } = await import("node:path");
+  const { stat: stat4 } = await import("node:fs/promises");
+  let content;
+  try {
+    content = await (0, import_promises2.readFile)(storyPath, "utf-8");
+  } catch {
+    return null;
+  }
+  const storyDir = storyPath.replace(STORY_MD_SUFFIX_PATTERN2, "");
+  const dirName = storyDir.split("/").pop() || "unknown";
+  let frontmatter = {};
+  let bodyContent = "";
+  try {
+    const parsed = (0, import_gray_matter2.default)(content);
+    frontmatter = parsed.data;
+    bodyContent = parsed.content;
+  } catch {
+  }
+  const slug = frontmatter.id || frontmatter.slug || dirName;
+  const title = frontmatter.title || dirName;
+  const status = toApiStoryStatus(validateStatus(frontmatter.status));
+  const tasks = parseTasks(frontmatter.tasks);
+  const journalPath = join10(storyDir, "journal.md");
+  let hasJournal = false;
+  try {
+    await stat4(journalPath);
+    hasJournal = true;
+  } catch {
+  }
+  return {
+    slug,
+    epicSlug,
+    title,
+    status,
+    tasks,
+    content: bodyContent || void 0,
+    paths: {
+      storyMd: storyPath,
+      ...hasJournal ? { journalMd: journalPath } : {}
+    }
+  };
+}
+async function parseJournal(journalPath) {
+  try {
+    const content = await (0, import_promises2.readFile)(journalPath, "utf-8");
+    const entries = [];
+    const sections = content.split(JOURNAL_SECTION_PATTERN).slice(1);
+    for (const section of sections) {
+      const lines = section.split("\n");
+      const headerLine = lines[0] || "";
+      const sectionContent = lines.slice(1).join("\n").trim();
+      if (headerLine.toLowerCase().startsWith("session:")) {
+        const timestamp = headerLine.substring("session:".length).trim();
+        entries.push({
+          timestamp,
+          type: "session",
+          title: `Session ${timestamp}`,
+          content: sectionContent
+        });
+      } else if (headerLine.toLowerCase().startsWith("blocker:")) {
+        const title = headerLine.substring("blocker:".length).trim();
+        entries.push({
+          timestamp: "",
+          // Blockers may not have timestamps
+          type: "blocker",
+          title,
+          content: sectionContent
+        });
+      } else if (headerLine.toLowerCase().startsWith("resolution:")) {
+        const title = headerLine.substring("resolution:".length).trim();
+        entries.push({
+          timestamp: "",
+          // Resolutions may not have timestamps
+          type: "resolution",
+          title,
+          content: sectionContent
+        });
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+async function scanSagaDirectory(sagaRoot) {
+  const [scannedEpics, scannedStories] = await Promise.all([
+    scanEpics(sagaRoot),
+    scanAllStories(sagaRoot)
+  ]);
+  const storiesByEpic = /* @__PURE__ */ new Map();
+  for (const story of scannedStories) {
+    const existing = storiesByEpic.get(story.epicSlug) || [];
+    existing.push(story);
+    storiesByEpic.set(story.epicSlug, existing);
+  }
+  const epicPromises = scannedEpics.map((scannedEpic) => {
+    const epicStories = storiesByEpic.get(scannedEpic.slug) || [];
+    return buildEpic(scannedEpic, epicStories, sagaRoot);
+  });
+  return Promise.all(epicPromises);
+}
+
+// src/server/session-routes.ts
+var import_express = require("express");
+
+// src/lib/sessions.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_promises3 = require("node:fs/promises");
+var import_node_path3 = require("node:path");
+var import_node_process = __toESM(require("node:process"), 1);
+var SESSION_NAME_PARTS_COUNT = 4;
+var PREVIEW_LINES_COUNT = 5;
+var PREVIEW_MAX_LENGTH = 500;
+var SESSION_NAME_PATTERN = /^(saga__[a-z0-9_-]+):/;
+var OUTPUT_DIR = "/tmp/saga-sessions";
+async function extractFileTimestamps(outputFile, status) {
+  try {
+    const stats = await (0, import_promises3.stat)(outputFile);
+    return {
+      startTime: stats.birthtime,
+      endTime: status === "completed" ? stats.mtime : void 0
+    };
+  } catch {
+    return { startTime: /* @__PURE__ */ new Date() };
+  }
+}
+async function generateOutputPreview(outputFile) {
+  try {
+    const content = await (0, import_promises3.readFile)(outputFile, "utf-8");
+    const lines = content.split("\n").filter((line) => line.length > 0);
+    if (lines.length === 0) {
+      return void 0;
+    }
+    const lastLines = lines.slice(-PREVIEW_LINES_COUNT);
+    let preview = lastLines.join("\n");
+    if (preview.length > PREVIEW_MAX_LENGTH) {
+      const truncated = preview.slice(0, PREVIEW_MAX_LENGTH);
+      const lastNewline = truncated.lastIndexOf("\n");
+      preview = lastNewline > 0 ? truncated.slice(0, lastNewline) : truncated;
+    }
+    return preview;
+  } catch {
+    return void 0;
+  }
+}
+function listSessions() {
+  const result = (0, import_node_child_process.spawnSync)("tmux", ["ls"], { encoding: "utf-8" });
+  if (result.status !== 0) {
+    return [];
+  }
+  const sessions = [];
+  const lines = result.stdout.trim().split("\n");
+  for (const line of lines) {
+    const match = line.match(SESSION_NAME_PATTERN);
+    if (match) {
+      const name = match[1];
+      sessions.push({
+        name,
+        status: "running",
+        // If it shows up in tmux ls, it's running
+        outputFile: (0, import_node_path3.join)(OUTPUT_DIR, `${name}.out`)
+      });
+    }
+  }
+  return sessions;
+}
+function getSessionStatus(sessionName) {
+  const result = (0, import_node_child_process.spawnSync)("tmux", ["has-session", "-t", sessionName], {
+    encoding: "utf-8"
+  });
+  return {
+    running: result.status === 0
+  };
+}
+function streamLogs(sessionName) {
+  const outputFile = (0, import_node_path3.join)(OUTPUT_DIR, `${sessionName}.out`);
+  if (!(0, import_node_fs.existsSync)(outputFile)) {
+    throw new Error(`Output file not found: ${outputFile}`);
+  }
+  return new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process.spawn)("tail", ["-f", outputFile], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (chunk) => {
+      import_node_process.default.stdout.write(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      import_node_process.default.stderr.write(chunk);
+    });
+    child.on("error", (err) => {
+      reject(new Error(`Failed to stream logs: ${err.message}`));
+    });
+    child.on("close", (_code) => {
+      resolve();
+    });
+    const sigintHandler = () => {
+      child.kill("SIGTERM");
+      import_node_process.default.removeListener("SIGINT", sigintHandler);
+    };
+    import_node_process.default.on("SIGINT", sigintHandler);
+  });
+}
+function parseSessionName(name) {
+  if (!name?.startsWith("saga__")) {
+    return null;
+  }
+  const parts = name.split("__");
+  if (parts.length !== SESSION_NAME_PARTS_COUNT) {
+    return null;
+  }
+  const [, epicSlug, storySlug, pid] = parts;
+  if (!(epicSlug && storySlug && pid)) {
+    return null;
+  }
+  return {
+    epicSlug,
+    storySlug
+  };
+}
+async function buildSessionInfo(name, status) {
+  const parsed = parseSessionName(name);
+  if (!parsed) {
+    return null;
+  }
+  const outputFile = (0, import_node_path3.join)(OUTPUT_DIR, `${name}.out`);
+  const outputAvailable = (0, import_node_fs.existsSync)(outputFile);
+  let startTime = /* @__PURE__ */ new Date();
+  let endTime;
+  let outputPreview;
+  if (outputAvailable) {
+    const timestamps = await extractFileTimestamps(outputFile, status);
+    startTime = timestamps.startTime;
+    endTime = timestamps.endTime;
+    outputPreview = await generateOutputPreview(outputFile);
+  }
+  return {
+    name,
+    epicSlug: parsed.epicSlug,
+    storySlug: parsed.storySlug,
+    status,
+    outputFile,
+    outputAvailable,
+    startTime,
+    endTime,
+    outputPreview
+  };
+}
+
+// src/lib/session-polling.ts
+var POLLING_INTERVAL_MS = 3e3;
+var pollingInterval = null;
+var currentSessions = [];
+var isFirstPoll = true;
+function createSessionMap(sessions) {
+  return new Map(sessions.map((s) => [s.name, s]));
+}
+function hasSessionSetChanged(newMap, currentMap) {
+  for (const name of newMap.keys()) {
+    if (!currentMap.has(name)) {
+      return true;
+    }
+  }
+  for (const name of currentMap.keys()) {
+    if (!newMap.has(name)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasSessionPropertiesChanged(newMap, currentMap) {
+  for (const [name, newSession] of newMap) {
+    const currentSession = currentMap.get(name);
+    if (!currentSession) {
+      continue;
+    }
+    if (currentSession.status !== newSession.status) {
+      return true;
+    }
+    if (currentSession.outputPreview !== newSession.outputPreview) {
+      return true;
+    }
+  }
+  return false;
+}
+function detectChanges(newSessions) {
+  if (isFirstPoll) {
+    return true;
+  }
+  if (newSessions.length !== currentSessions.length) {
+    return true;
+  }
+  const newSessionMap = createSessionMap(newSessions);
+  const currentSessionMap = createSessionMap(currentSessions);
+  if (hasSessionSetChanged(newSessionMap, currentSessionMap)) {
+    return true;
+  }
+  return hasSessionPropertiesChanged(newSessionMap, currentSessionMap);
+}
+async function buildSessionInfoSafe(sessionName, status) {
+  try {
+    return await buildSessionInfo(sessionName, status);
+  } catch {
+    return null;
+  }
+}
+async function discoverSessions() {
+  const rawSessions = listSessions();
+  const sessionPromises = rawSessions.map((session) => {
+    const statusResult = getSessionStatus(session.name);
+    const status = statusResult.running ? "running" : "completed";
+    return buildSessionInfoSafe(session.name, status);
+  });
+  const results = await Promise.all(sessionPromises);
+  const detailedSessions = results.filter((s) => s !== null);
+  detailedSessions.sort((a, b) => b.startTime.getTime() - a.startTime.getTime());
+  return detailedSessions;
+}
+async function pollSessions(broadcast) {
+  try {
+    const sessions = await discoverSessions();
+    const hasChanges = detectChanges(sessions);
+    if (hasChanges) {
+      currentSessions = sessions;
+      isFirstPoll = false;
+      broadcast({
+        type: "sessions:updated",
+        data: sessions
+      });
+    }
+  } catch {
+  }
+}
+function getCurrentSessions() {
+  return [...currentSessions];
+}
+function startSessionPolling(broadcast) {
+  stopSessionPolling();
+  pollSessions(broadcast);
+  pollingInterval = setInterval(() => {
+    pollSessions(broadcast);
+  }, POLLING_INTERVAL_MS);
+}
+function stopSessionPolling() {
+  if (pollingInterval) {
+    clearInterval(pollingInterval);
+    pollingInterval = null;
+  }
+  currentSessions = [];
+  isFirstPoll = true;
+}
+
+// src/server/session-routes.ts
+var HTTP_NOT_FOUND = 404;
+var HTTP_INTERNAL_ERROR = 500;
+function createSessionApiRouter() {
+  const router = (0, import_express.Router)();
+  router.get("/sessions", (_req, res) => {
+    try {
+      let sessions = getCurrentSessions();
+      const { epicSlug, storySlug, status } = _req.query;
+      if (epicSlug && typeof epicSlug === "string") {
+        sessions = sessions.filter((s) => s.epicSlug === epicSlug);
+        if (storySlug && typeof storySlug === "string") {
+          sessions = sessions.filter((s) => s.storySlug === storySlug);
+        }
+      }
+      if (status && typeof status === "string" && (status === "running" || status === "completed")) {
+        sessions = sessions.filter((s) => s.status === status);
+      }
+      res.json(sessions);
+    } catch (_error) {
+      res.status(HTTP_INTERNAL_ERROR).json({ error: "Failed to fetch sessions" });
+    }
+  });
+  router.get("/sessions/:sessionName", (req, res) => {
+    try {
+      const { sessionName } = req.params;
+      const sessions = getCurrentSessions();
+      const session = sessions.find((s) => s.name === sessionName);
+      if (!session) {
+        res.status(HTTP_NOT_FOUND).json({ error: "Session not found" });
+        return;
+      }
+      res.json(session);
+    } catch (_error) {
+      res.status(HTTP_INTERNAL_ERROR).json({ error: "Failed to fetch session" });
+    }
+  });
+  return router;
+}
+
+// src/server/routes.ts
+var HTTP_NOT_FOUND2 = 404;
+var HTTP_INTERNAL_ERROR2 = 500;
+function getEpics(sagaRoot) {
+  return scanSagaDirectory(sagaRoot);
+}
+function toEpicSummary(epic) {
+  return {
+    slug: epic.slug,
+    title: epic.title,
+    storyCounts: epic.storyCounts,
+    path: epic.path
+  };
+}
+function registerEpicsRoutes(router, sagaRoot) {
+  router.get("/epics", async (_req, res) => {
+    try {
+      const epics = await getEpics(sagaRoot);
+      const summaries = epics.map(toEpicSummary);
+      res.json(summaries);
+    } catch (_error) {
+      res.status(HTTP_INTERNAL_ERROR2).json({ error: "Failed to fetch epics" });
+    }
+  });
+  router.get("/epics/:slug", async (req, res) => {
+    try {
+      const { slug } = req.params;
+      const epics = await getEpics(sagaRoot);
+      const epic = epics.find((e) => e.slug === slug);
+      if (!epic) {
+        res.status(HTTP_NOT_FOUND2).json({ error: `Epic not found: ${slug}` });
+        return;
+      }
+      res.json(epic);
+    } catch (_error) {
+      res.status(HTTP_INTERNAL_ERROR2).json({ error: "Failed to fetch epic" });
+    }
+  });
+}
+function registerStoriesRoutes(router, sagaRoot) {
+  router.get("/stories/:epicSlug/:storySlug", async (req, res) => {
+    try {
+      const { epicSlug, storySlug } = req.params;
+      const epics = await getEpics(sagaRoot);
+      const epic = epics.find((e) => e.slug === epicSlug);
+      if (!epic) {
+        res.status(HTTP_NOT_FOUND2).json({ error: `Epic not found: ${epicSlug}` });
+        return;
+      }
+      const story = epic.stories.find((s) => s.slug === storySlug);
+      if (!story) {
+        res.status(HTTP_NOT_FOUND2).json({ error: `Story not found: ${storySlug}` });
+        return;
+      }
+      if (story.paths.journalMd) {
+        const journalPath = (0, import_node_path4.join)(sagaRoot, story.paths.journalMd);
+        const journal = await parseJournal(journalPath);
+        if (journal.length > 0) {
+          story.journal = journal;
+        }
+      }
+      res.json(story);
+    } catch (_error) {
+      res.status(HTTP_INTERNAL_ERROR2).json({ error: "Failed to fetch story" });
+    }
+  });
+}
+function createApiRouter(sagaRoot) {
+  const router = (0, import_express2.Router)();
+  registerEpicsRoutes(router, sagaRoot);
+  registerStoriesRoutes(router, sagaRoot);
+  router.use(createSessionApiRouter());
+  router.use((_req, res) => {
+    res.status(HTTP_NOT_FOUND2).json({ error: "API endpoint not found" });
+  });
+  return router;
+}
+
+// src/server/websocket.ts
+var import_node_path7 = require("node:path");
+var import_ws = require("ws");
+
+// src/lib/log-stream-manager.ts
+var import_node_fs2 = require("node:fs");
+var import_promises4 = require("node:fs/promises");
+var import_node_path5 = require("node:path");
+var import_chokidar = __toESM(require("chokidar"), 1);
+var LogStreamManager = class {
+  /**
+   * Active file watchers indexed by session name
+   */
+  watchers = /* @__PURE__ */ new Map();
+  /**
+   * Current file position (byte offset) per session for incremental reads
+   */
+  filePositions = /* @__PURE__ */ new Map();
+  /**
+   * Client subscriptions per session
+   */
+  subscriptions = /* @__PURE__ */ new Map();
+  /**
+   * Function to send messages to clients
+   */
+  sendToClient;
+  /**
+   * Create a new LogStreamManager instance
+   *
+   * @param sendToClient - Function to send log data messages to clients
+   */
+  constructor(sendToClient2) {
+    this.sendToClient = sendToClient2;
+  }
+  /**
+   * Get the number of subscriptions for a session
+   *
+   * @param sessionName - The session to check
+   * @returns Number of subscribed clients
+   */
+  getSubscriptionCount(sessionName) {
+    const subs = this.subscriptions.get(sessionName);
+    return subs ? subs.size : 0;
+  }
+  /**
+   * Check if a watcher exists for a session
+   *
+   * @param sessionName - The session to check
+   * @returns True if a watcher exists
+   */
+  hasWatcher(sessionName) {
+    return this.watchers.has(sessionName);
+  }
+  /**
+   * Get the current file position for a session
+   *
+   * @param sessionName - The session to check
+   * @returns The current byte offset, or 0 if not tracked
+   */
+  getFilePosition(sessionName) {
+    return this.filePositions.get(sessionName) ?? 0;
+  }
+  /**
+   * Subscribe a client to a session's log stream
+   *
+   * Reads the full file content and sends it as the initial message.
+   * Adds the client to the subscription set for incremental updates.
+   * Creates a file watcher if this is the first subscriber.
+   *
+   * @param sessionName - The session to subscribe to
+   * @param ws - The WebSocket client to subscribe
+   */
+  async subscribe(sessionName, ws) {
+    const outputFile = (0, import_node_path5.join)(OUTPUT_DIR, `${sessionName}.out`);
+    if (!(0, import_node_fs2.existsSync)(outputFile)) {
+      this.sendToClient(ws, {
+        type: "logs:error",
+        sessionName,
+        error: `Output file not found: ${outputFile}`
+      });
+      return;
+    }
+    const content = await (0, import_promises4.readFile)(outputFile, "utf-8");
+    this.sendToClient(ws, {
+      type: "logs:data",
+      sessionName,
+      data: content,
+      isInitial: true,
+      isComplete: false
+    });
+    this.filePositions.set(sessionName, content.length);
+    let subs = this.subscriptions.get(sessionName);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.subscriptions.set(sessionName, subs);
+    }
+    subs.add(ws);
+    if (!this.watchers.has(sessionName)) {
+      this.createWatcher(sessionName, outputFile);
+    }
+  }
+  /**
+   * Create a chokidar file watcher for a session's output file
+   *
+   * The watcher detects changes and triggers incremental content delivery
+   * to all subscribed clients.
+   *
+   * @param sessionName - The session name
+   * @param outputFile - Path to the session output file
+   */
+  createWatcher(sessionName, outputFile) {
+    const watcher = import_chokidar.default.watch(outputFile, {
+      persistent: true,
+      awaitWriteFinish: false
+    });
+    watcher.on("change", async () => {
+      await this.sendIncrementalContent(sessionName, outputFile);
+    });
+    this.watchers.set(sessionName, watcher);
+  }
+  /**
+   * Clean up a watcher and associated state for a session
+   *
+   * Closes the file watcher and removes all tracking state for the session.
+   * Should be called when the last subscriber unsubscribes or disconnects.
+   *
+   * @param sessionName - The session to clean up
+   */
+  cleanupWatcher(sessionName) {
+    const watcher = this.watchers.get(sessionName);
+    if (watcher) {
+      watcher.close();
+      this.watchers.delete(sessionName);
+    }
+    this.filePositions.delete(sessionName);
+    this.subscriptions.delete(sessionName);
+  }
+  /**
+   * Send incremental content to all subscribed clients for a session
+   *
+   * Reads from the last known position to the end of the file and sends
+   * the new content to all subscribed clients.
+   *
+   * @param sessionName - The session name
+   * @param outputFile - Path to the session output file
+   */
+  async sendIncrementalContent(sessionName, outputFile) {
+    const lastPosition = this.filePositions.get(sessionName) ?? 0;
+    const fileStat = await (0, import_promises4.stat)(outputFile);
+    const currentSize = fileStat.size;
+    if (currentSize <= lastPosition) {
+      return;
+    }
+    const newContent = await this.readFromPosition(outputFile, lastPosition, currentSize);
+    this.filePositions.set(sessionName, currentSize);
+    const subs = this.subscriptions.get(sessionName);
+    if (subs) {
+      const message = {
+        type: "logs:data",
+        sessionName,
+        data: newContent,
+        isInitial: false,
+        isComplete: false
+      };
+      for (const ws of subs) {
+        this.sendToClient(ws, message);
+      }
+    }
+  }
+  /**
+   * Read file content from a specific position
+   *
+   * @param filePath - Path to the file
+   * @param start - Starting byte position
+   * @param end - Ending byte position
+   * @returns The content read from the file
+   */
+  readFromPosition(filePath, start, end) {
+    return new Promise((resolve, reject) => {
+      let content = "";
+      const stream = (0, import_node_fs2.createReadStream)(filePath, {
+        start,
+        end: end - 1,
+        // createReadStream end is inclusive
+        encoding: "utf-8"
+      });
+      stream.on("data", (chunk) => {
+        content += chunk;
+      });
+      stream.on("end", () => {
+        resolve(content);
+      });
+      stream.on("error", reject);
+    });
+  }
+  /**
+   * Unsubscribe a client from a session's log stream
+   *
+   * Removes the client from the subscription set. If this was the last
+   * subscriber, cleans up the watcher and associated state.
+   *
+   * @param sessionName - The session to unsubscribe from
+   * @param ws - The WebSocket client to unsubscribe
+   */
+  unsubscribe(sessionName, ws) {
+    const subs = this.subscriptions.get(sessionName);
+    if (subs) {
+      subs.delete(ws);
+      if (subs.size === 0) {
+        this.cleanupWatcher(sessionName);
+      }
+    }
+  }
+  /**
+   * Handle client disconnect by removing from all subscriptions
+   *
+   * Should be called when a WebSocket connection closes to clean up
+   * any subscriptions the client may have had. Also triggers watcher
+   * cleanup for any sessions that no longer have subscribers.
+   *
+   * @param ws - The WebSocket client that disconnected
+   */
+  handleClientDisconnect(ws) {
+    for (const [sessionName, subs] of this.subscriptions) {
+      subs.delete(ws);
+      if (subs.size === 0) {
+        this.cleanupWatcher(sessionName);
+      }
+    }
+  }
+  /**
+   * Notify that a session has completed
+   *
+   * Reads any remaining content from the file and sends it with isComplete=true
+   * to all subscribed clients, then cleans up the watcher regardless of
+   * subscription count. Called by session polling when it detects completion.
+   *
+   * @param sessionName - The session that has completed
+   */
+  async notifySessionCompleted(sessionName) {
+    const subs = this.subscriptions.get(sessionName);
+    if (!subs || subs.size === 0) {
+      return;
+    }
+    const outputFile = (0, import_node_path5.join)(OUTPUT_DIR, `${sessionName}.out`);
+    let finalContent = "";
+    try {
+      if ((0, import_node_fs2.existsSync)(outputFile)) {
+        const lastPosition = this.filePositions.get(sessionName) ?? 0;
+        const fileStat = await (0, import_promises4.stat)(outputFile);
+        const currentSize = fileStat.size;
+        if (currentSize > lastPosition) {
+          finalContent = await this.readFromPosition(outputFile, lastPosition, currentSize);
+        }
+      }
+    } catch {
+    }
+    const message = {
+      type: "logs:data",
+      sessionName,
+      data: finalContent,
+      isInitial: false,
+      isComplete: true
+    };
+    for (const ws of subs) {
+      this.sendToClient(ws, message);
+    }
+    this.cleanupWatcher(sessionName);
+  }
+  /**
+   * Clean up all watchers and subscriptions
+   *
+   * Call this when shutting down the server.
+   */
+  async dispose() {
+    const closePromises = [];
+    for (const [, watcher] of this.watchers) {
+      closePromises.push(watcher.close());
+    }
+    await Promise.all(closePromises);
+    this.watchers.clear();
+    this.filePositions.clear();
+    this.subscriptions.clear();
+  }
+};
+
+// src/server/watcher.ts
+var import_node_events = require("node:events");
+var import_node_path6 = require("node:path");
+var import_node_process2 = __toESM(require("node:process"), 1);
+var import_chokidar2 = __toESM(require("chokidar"), 1);
+var MIN_PATH_PARTS = 4;
+var ARCHIVE_STORY_PARTS = 5;
+var EPIC_FILE_PARTS = 4;
+var STORY_FILE_PARTS = 6;
+var DEBOUNCE_DELAY_MS = 100;
+function shouldUsePolling() {
+  return import_node_process2.default.env.SAGA_USE_POLLING === "1";
+}
+function isStoryMarkdownFile(fileName) {
+  return fileName === "story.md" || fileName === "journal.md";
+}
+function parseArchivePath(parts, epicSlug) {
+  if (parts.length >= ARCHIVE_STORY_PARTS) {
+    const storySlug = parts[3];
+    const fileName = parts[4];
+    if (isStoryMarkdownFile(fileName)) {
+      return {
+        epicSlug,
+        storySlug,
+        archived: true,
+        isEpicFile: false,
+        isStoryFile: true,
+        isMainStoryFile: fileName === "story.md"
+      };
+    }
+  }
+  return null;
+}
+function parseEpicsPath(parts, epicSlug) {
+  if (parts.length === EPIC_FILE_PARTS && parts[3] === "epic.md") {
+    return {
+      epicSlug,
+      archived: false,
+      isEpicFile: true,
+      isStoryFile: false,
+      isMainStoryFile: false
+    };
+  }
+  if (parts.length >= STORY_FILE_PARTS && parts[3] === "stories") {
+    const storySlug = parts[4];
+    const fileName = parts[5];
+    if (isStoryMarkdownFile(fileName)) {
+      return {
+        epicSlug,
+        storySlug,
+        archived: false,
+        isEpicFile: false,
+        isStoryFile: true,
+        isMainStoryFile: fileName === "story.md"
+      };
+    }
+  }
+  return null;
+}
+function parseFilePath(filePath, sagaRoot) {
+  const relativePath = (0, import_node_path6.relative)(sagaRoot, filePath);
+  const parts = relativePath.split(import_node_path6.sep);
+  if (parts[0] !== ".saga" || parts.length < MIN_PATH_PARTS) {
+    return null;
+  }
+  const epicSlug = parts[2];
+  const isArchive = parts[1] === "archive";
+  const isEpics = parts[1] === "epics";
+  if (isArchive) {
+    return parseArchivePath(parts, epicSlug);
+  }
+  if (isEpics) {
+    return parseEpicsPath(parts, epicSlug);
+  }
+  return null;
+}
+function createDebouncer(delayMs) {
+  const pending = /* @__PURE__ */ new Map();
+  return {
+    schedule(key, data, callback) {
+      const existing = pending.get(key);
+      if (existing) {
+        clearTimeout(existing.timer);
+      }
+      const timer = setTimeout(() => {
+        pending.delete(key);
+        callback(data);
+      }, delayMs);
+      pending.set(key, { timer, data });
+    },
+    clear() {
+      for (const { timer } of pending.values()) {
+        clearTimeout(timer);
+      }
+      pending.clear();
+    }
+  };
+}
+function getEpicEventType(eventType) {
+  if (eventType === "add") {
+    return "epic:added";
+  }
+  if (eventType === "unlink") {
+    return "epic:removed";
+  }
+  return "epic:changed";
+}
+function getStoryEventType(eventType, isMainStoryFile) {
+  if (!isMainStoryFile) {
+    return "story:changed";
+  }
+  if (eventType === "add") {
+    return "story:added";
+  }
+  if (eventType === "unlink") {
+    return "story:removed";
+  }
+  return "story:changed";
+}
+function determineEventType(eventType, parsed) {
+  if (parsed.isEpicFile) {
+    return getEpicEventType(eventType);
+  }
+  if (parsed.isStoryFile) {
+    return getStoryEventType(eventType, parsed.isMainStoryFile);
+  }
+  return null;
+}
+function createDebounceKey(parsed) {
+  const { epicSlug, storySlug, archived } = parsed;
+  return storySlug ? `story:${epicSlug}:${storySlug}:${archived}` : `epic:${epicSlug}`;
+}
+function createChokidarWatcher(sagaRoot) {
+  const epicsDir = (0, import_node_path6.join)(sagaRoot, ".saga", "epics");
+  const archiveDir = (0, import_node_path6.join)(sagaRoot, ".saga", "archive");
+  const usePolling = shouldUsePolling();
+  return import_chokidar2.default.watch([epicsDir, archiveDir], {
+    persistent: true,
+    ignoreInitial: true,
+    // Use polling for tests (reliable) or native watching for production (fast)
+    usePolling,
+    interval: usePolling ? DEBOUNCE_DELAY_MS : void 0,
+    // Wait for writes to finish when polling
+    awaitWriteFinish: usePolling ? {
+      stabilityThreshold: 50,
+      pollInterval: 50
+    } : false
+  });
+}
+function createFileEventHandler(sagaRoot, debouncer, emitter, state) {
+  return (eventType, filePath) => {
+    if (state.closed || !state.ready) {
+      return;
+    }
+    const parsed = parseFilePath(filePath, sagaRoot);
+    if (!parsed) {
+      return;
+    }
+    const watcherEventType = determineEventType(eventType, parsed);
+    if (!watcherEventType) {
+      return;
+    }
+    const event = {
+      type: watcherEventType,
+      epicSlug: parsed.epicSlug,
+      storySlug: parsed.storySlug,
+      archived: parsed.archived,
+      path: (0, import_node_path6.relative)(sagaRoot, filePath)
+    };
+    debouncer.schedule(createDebounceKey(parsed), event, (e) => {
+      if (!state.closed) {
+        emitter.emit(e.type, e);
+      }
+    });
+  };
+}
+async function createSagaWatcher(sagaRoot) {
+  const emitter = new import_node_events.EventEmitter();
+  const debouncer = createDebouncer(DEBOUNCE_DELAY_MS);
+  const watcher = createChokidarWatcher(sagaRoot);
+  const state = { closed: false, ready: false };
+  const handleFileEvent = createFileEventHandler(sagaRoot, debouncer, emitter, state);
+  watcher.on("add", (path) => handleFileEvent("add", path));
+  watcher.on("change", (path) => handleFileEvent("change", path));
+  watcher.on("unlink", (path) => handleFileEvent("unlink", path));
+  watcher.on("error", (error) => {
+    if (!state.closed) {
+      emitter.emit("error", error);
+    }
+  });
+  await new Promise((resolve) => {
+    watcher.on("ready", () => {
+      state.ready = true;
+      resolve();
+    });
+  });
+  return {
+    on(event, listener) {
+      emitter.on(event, listener);
+      return this;
+    },
+    async close() {
+      state.closed = true;
+      debouncer.clear();
+      await watcher.close();
+    }
+  };
+}
+
+// src/server/websocket.ts
+var HEARTBEAT_INTERVAL_MS = 3e4;
+function makeStoryKey(epicSlug, storySlug) {
+  return `${epicSlug}:${storySlug}`;
+}
+function toEpicSummary2(epic) {
+  return {
+    slug: epic.slug,
+    title: epic.title,
+    storyCounts: epic.storyCounts,
+    path: epic.path
+  };
+}
+function sendToClient(ws, message) {
+  if (ws.readyState === import_ws.WebSocket.OPEN) {
+    ws.send(JSON.stringify(message));
+  }
+}
+function sendLogMessage(ws, message) {
+  if (ws.readyState === import_ws.WebSocket.OPEN) {
+    ws.send(JSON.stringify({ event: message.type, data: message }));
+  }
+}
+function handleStorySubscription(state, data, subscribe) {
+  const { epicSlug, storySlug } = data || {};
+  if (epicSlug && storySlug) {
+    const key = makeStoryKey(epicSlug, storySlug);
+    if (subscribe) {
+      state.subscribedStories.add(key);
+    } else {
+      state.subscribedStories.delete(key);
+    }
+  }
+}
+function handleLogsSubscription(logStreamManager, ws, data, subscribe) {
+  const { sessionName } = data || {};
+  if (sessionName) {
+    if (subscribe) {
+      logStreamManager.subscribe(sessionName, ws);
+    } else {
+      logStreamManager.unsubscribe(sessionName, ws);
+    }
+  }
+}
+function processClientMessage(message, state, logStreamManager) {
+  switch (message.event) {
+    case "subscribe:story":
+      handleStorySubscription(state, message.data, true);
+      break;
+    case "unsubscribe:story":
+      handleStorySubscription(state, message.data, false);
+      break;
+    case "subscribe:logs":
+      handleLogsSubscription(logStreamManager, state.ws, message.data, true);
+      break;
+    case "unsubscribe:logs":
+      handleLogsSubscription(logStreamManager, state.ws, message.data, false);
+      break;
+    default:
+      break;
+  }
+}
+function hasSubscribers(clients, storyKey) {
+  for (const [, state] of clients) {
+    if (state.subscribedStories.has(storyKey)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getStoryPath(sagaRoot, epicSlug, storySlug, archived) {
+  return archived ? (0, import_node_path7.join)(sagaRoot, ".saga", "archive", epicSlug, storySlug, "story.md") : (0, import_node_path7.join)(sagaRoot, ".saga", "epics", epicSlug, "stories", storySlug, "story.md");
+}
+async function parseAndEnrichStory(sagaRoot, storyPath, epicSlug, archived) {
+  const story = await parseStory(storyPath, epicSlug);
+  if (!story) {
+    return null;
+  }
+  story.paths.storyMd = (0, import_node_path7.relative)(sagaRoot, story.paths.storyMd);
+  if (story.paths.journalMd) {
+    story.paths.journalMd = (0, import_node_path7.relative)(sagaRoot, story.paths.journalMd);
+  }
+  story.archived = archived;
+  if (story.paths.journalMd) {
+    const journalPath = (0, import_node_path7.join)(sagaRoot, story.paths.journalMd);
+    const journal = await parseJournal(journalPath);
+    if (journal.length > 0) {
+      story.journal = journal;
+    }
+  }
+  return story;
+}
+async function handleStoryChangeEvent(event, sagaRoot, clients, broadcastToSubscribers, handleEpicChange) {
+  const { epicSlug, storySlug, archived } = event;
+  if (!storySlug) {
+    return;
+  }
+  const storyKey = makeStoryKey(epicSlug, storySlug);
+  if (!hasSubscribers(clients, storyKey)) {
+    await handleEpicChange();
+    return;
+  }
+  try {
+    const storyPath = getStoryPath(sagaRoot, epicSlug, storySlug, archived);
+    const story = await parseAndEnrichStory(sagaRoot, storyPath, epicSlug, archived);
+    if (story) {
+      broadcastToSubscribers(storyKey, { event: "story:updated", data: story });
+    }
+    await handleEpicChange();
+  } catch {
+  }
+}
+function handleClientMessage(data, state, logStreamManager) {
+  try {
+    const message = JSON.parse(data.toString());
+    if (message.type === "ping") {
+      sendToClient(state.ws, { event: "pong", data: null });
+      return;
+    }
+    if (message.event) {
+      processClientMessage(message, state, logStreamManager);
+    }
+  } catch {
+  }
+}
+function setupClientHandlers(ws, state, clients, logStreamManager) {
+  ws.on("pong", () => {
+    state.isAlive = true;
+  });
+  ws.on("message", (data) => {
+    handleClientMessage(data, state, logStreamManager);
+  });
+  ws.on("close", () => {
+    clients.delete(ws);
+    logStreamManager.handleClientDisconnect(ws);
+  });
+  ws.on("error", () => {
+    clients.delete(ws);
+    logStreamManager.handleClientDisconnect(ws);
+  });
+}
+function handleNewConnection(ws, clients, logStreamManager) {
+  const state = {
+    ws,
+    subscribedStories: /* @__PURE__ */ new Set(),
+    isAlive: true
+  };
+  clients.set(ws, state);
+  setupClientHandlers(ws, state, clients, logStreamManager);
+}
+function setupWatcherHandlers(watcher, sagaRoot, clients, broadcast, broadcastToSubscribers) {
+  const handleEpicChange = async () => {
+    try {
+      const epics = await scanSagaDirectory(sagaRoot);
+      const summaries = epics.map(toEpicSummary2);
+      broadcast({ event: "epics:updated", data: summaries });
+    } catch {
+    }
+  };
+  watcher.on("epic:added", handleEpicChange);
+  watcher.on("epic:changed", handleEpicChange);
+  watcher.on("epic:removed", handleEpicChange);
+  const handleStoryChange = (event) => {
+    handleStoryChangeEvent(event, sagaRoot, clients, broadcastToSubscribers, handleEpicChange);
+  };
+  watcher.on("story:added", handleStoryChange);
+  watcher.on("story:changed", handleStoryChange);
+  watcher.on("story:removed", handleStoryChange);
+  watcher.on("error", () => {
+  });
+}
+function setupSessionPolling(broadcast, logStreamManager) {
+  let previousSessionStates = /* @__PURE__ */ new Map();
+  startSessionPolling((msg) => {
+    broadcast({ event: msg.type, data: msg.data });
+    const currentStates = /* @__PURE__ */ new Map();
+    for (const session of msg.data) {
+      currentStates.set(session.name, session.status);
+      const previousStatus = previousSessionStates.get(session.name);
+      if (previousStatus === "running" && session.status === "completed") {
+        logStreamManager.notifySessionCompleted(session.name);
+      }
+    }
+    previousSessionStates = currentStates;
+  });
+}
+function setupHeartbeat(clients) {
+  return setInterval(() => {
+    for (const [ws, state] of clients) {
+      if (!state.isAlive) {
+        clients.delete(ws);
+        ws.terminate();
+        continue;
+      }
+      state.isAlive = false;
+      ws.ping();
+    }
+  }, HEARTBEAT_INTERVAL_MS);
+}
+function createWebSocketInstance(state) {
+  const {
+    wss,
+    clients,
+    watcher,
+    logStreamManager,
+    heartbeatInterval,
+    broadcast,
+    broadcastToSubscribers
+  } = state;
+  return {
+    broadcastEpicsUpdated(epics) {
+      broadcast({ event: "epics:updated", data: epics });
+    },
+    broadcastStoryUpdated(story) {
+      const key = makeStoryKey(story.epicSlug, story.slug);
+      broadcastToSubscribers(key, { event: "story:updated", data: story });
+    },
+    async close() {
+      clearInterval(heartbeatInterval);
+      stopSessionPolling();
+      await logStreamManager.dispose();
+      for (const [ws] of clients) {
+        ws.close();
+      }
+      clients.clear();
+      if (watcher) {
+        await watcher.close();
+      }
+      return new Promise((resolve, reject) => {
+        wss.close((err) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
+        });
+      });
+    }
+  };
+}
+async function createWebSocketServer(httpServer, sagaRoot) {
+  const wss = new import_ws.WebSocketServer({ server: httpServer });
+  const clients = /* @__PURE__ */ new Map();
+  let watcher = null;
+  try {
+    watcher = await createSagaWatcher(sagaRoot);
+  } catch {
+  }
+  const logStreamManager = new LogStreamManager(sendLogMessage);
+  const broadcast = (message) => {
+    for (const [ws] of clients) {
+      sendToClient(ws, message);
+    }
+  };
+  const broadcastToSubscribers = (storyKey, message) => {
+    for (const [ws, state] of clients) {
+      if (state.subscribedStories.has(storyKey)) {
+        sendToClient(ws, message);
+      }
+    }
+  };
+  const heartbeatInterval = setupHeartbeat(clients);
+  setupSessionPolling(broadcast, logStreamManager);
+  wss.on("connection", (ws) => {
+    handleNewConnection(ws, clients, logStreamManager);
+  });
+  if (watcher) {
+    setupWatcherHandlers(watcher, sagaRoot, clients, broadcast, broadcastToSubscribers);
+  }
+  return createWebSocketInstance({
+    wss,
+    clients,
+    watcher,
+    logStreamManager,
+    heartbeatInterval,
+    broadcast,
+    broadcastToSubscribers
+  });
+}
+
+// src/server/index.ts
+var DEFAULT_PORT = 3847;
+function createApp(sagaRoot) {
+  const app = (0, import_express3.default)();
+  app.use(import_express3.default.json());
+  app.use((_req, res, next) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
+    next();
+  });
+  app.get("/api/health", (_req, res) => {
+    res.json({ status: "ok" });
+  });
+  app.use("/api", createApiRouter(sagaRoot));
+  const clientDistPath = (0, import_node_path8.join)(__dirname, "client");
+  const _indexHtmlPath = (0, import_node_path8.join)(clientDistPath, "index.html");
+  app.use(import_express3.default.static(clientDistPath));
+  app.get("/{*splat}", (_req, res) => {
+    res.sendFile("index.html", { root: clientDistPath });
+  });
+  return app;
+}
+async function startServer(config) {
+  const port = config.port ?? DEFAULT_PORT;
+  const app = createApp(config.sagaRoot);
+  const httpServer = (0, import_node_http.createServer)(app);
+  const wsServer = await createWebSocketServer(httpServer, config.sagaRoot);
+  return new Promise((resolve, reject) => {
+    httpServer.on("error", reject);
+    httpServer.listen(port, () => {
+      resolve({
+        app,
+        httpServer,
+        wsServer,
+        port,
+        close: async () => {
+          await wsServer.close();
+          return new Promise((resolveClose, rejectClose) => {
+            httpServer.close((err) => {
+              if (err) {
+                rejectClose(err);
+              } else {
+                resolveClose();
+              }
+            });
+          });
+        }
+      });
+    });
+  });
+}
+
+// src/utils/project-discovery.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path9 = require("node:path");
+var import_node_process3 = __toESM(require("node:process"), 1);
+function findProjectRoot(startDir) {
+  let currentDir = startDir ?? import_node_process3.default.cwd();
+  while (true) {
+    const sagaDir = (0, import_node_path9.join)(currentDir, ".saga");
+    if ((0, import_node_fs3.existsSync)(sagaDir)) {
+      return currentDir;
+    }
+    const parentDir = (0, import_node_path9.dirname)(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function resolveProjectPath(explicitPath) {
+  if (explicitPath) {
+    const sagaDir = (0, import_node_path9.join)(explicitPath, ".saga");
+    if (!(0, import_node_fs3.existsSync)(sagaDir)) {
+      throw new Error(
+        `No .saga/ directory found at specified path: ${explicitPath}
+Make sure the path points to a SAGA project root.`
+      );
+    }
+    return explicitPath;
+  }
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    throw new Error(
+      'Could not find a SAGA project.\nNo .saga/ directory found in the current directory or any parent.\nRun "saga init" to initialize a new project, or use --path to specify the project location.'
+    );
+  }
+  return projectRoot;
+}
+
+// src/commands/dashboard.ts
+async function dashboardCommand(options) {
+  let projectPath;
+  try {
+    projectPath = resolveProjectPath(options.path);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : "Failed to resolve SAGA project path");
+    import_node_process4.default.exit(1);
+  }
+  try {
+    const server = await startServer({
+      sagaRoot: projectPath,
+      port: options.port
+    });
+    console.log(`SAGA Dashboard server running on http://localhost:${server.port}`);
+    console.log(`Project: ${projectPath}`);
+    import_node_process4.default.on("SIGINT", async () => {
+      await server.close();
+      import_node_process4.default.exit(0);
+    });
+    import_node_process4.default.on("SIGTERM", async () => {
+      await server.close();
+      import_node_process4.default.exit(0);
+    });
+  } catch (_error) {
+    import_node_process4.default.exit(1);
+  }
+}
+
+// src/commands/sessions/index.ts
+var import_node_process5 = __toESM(require("node:process"), 1);
+async function sessionsListCommand() {
+  const sessions = await listSessions();
+  console.log(JSON.stringify(sessions, null, 2));
+}
+async function sessionsStatusCommand(sessionName) {
+  const status = await getSessionStatus(sessionName);
+  console.log(JSON.stringify(status, null, 2));
+}
+async function sessionsLogsCommand(sessionName) {
+  try {
+    await streamLogs(sessionName);
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    import_node_process5.default.exit(1);
+  }
+}
+
+// src/cli.ts
+var packageJsonPath = (0, import_node_path10.join)(__dirname, "..", "package.json");
+var packageJson = JSON.parse((0, import_node_fs4.readFileSync)(packageJsonPath, "utf-8"));
+var program = new import_commander.Command();
+program.name("saga").description("Dashboard and session monitoring for SAGA - Structured Autonomous Goal Achievement").version(packageJson.version).addHelpCommand("help [command]", "Display help for a command");
+program.option("-p, --path <dir>", "Path to SAGA project directory (overrides auto-discovery)");
+program.command("dashboard").description("Start the dashboard server").option("--port <n>", "Port to run the server on (default: 3847)", Number.parseInt).action(async (options) => {
+  const globalOpts = program.opts();
+  await dashboardCommand({
+    path: globalOpts.path,
+    port: options.port
+  });
+});
+var sessionsCommand = program.command("sessions").description("Manage SAGA tmux sessions");
+sessionsCommand.command("list").description("List all SAGA sessions").action(async () => {
+  await sessionsListCommand();
+});
+sessionsCommand.command("status <name>").description("Show session status").action(async (name) => {
+  await sessionsStatusCommand(name);
+});
+sessionsCommand.command("logs <name>").description("Stream session output").action(async (name) => {
+  await sessionsLogsCommand(name);
+});
+program.on("command:*", (operands) => {
+  console.error(`error: unknown command '${operands[0]}'`);
+  import_node_process6.default.exit(1);
+});
+program.parse();