@saga-ai/cli 2.13.0 → 2.15.0

package/dist/cli.cjs

@@ -24,189 +24,35 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli.ts
+var import_node_fs9 = require("node:fs");
+var import_node_path15 = require("node:path");
+var import_node_process10 = __toESM(require("node:process"), 1);
 var import_commander = require("commander");
-var import_node_path8 = require("node:path");
-var import_node_fs7 = require("node:fs");
-
-// src/commands/init.ts
-var import_node_path2 = require("node:path");
-var import_node_fs2 = require("node:fs");
 
-// src/utils/project-discovery.ts
-var import_node_fs = require("node:fs");
-var import_node_path = require("node:path");
-function findProjectRoot(startDir) {
-  let currentDir = startDir ?? process.cwd();
-  while (true) {
-    const sagaDir = (0, import_node_path.join)(currentDir, ".saga");
-    if ((0, import_node_fs.existsSync)(sagaDir)) {
-      return currentDir;
-    }
-    const parentDir = (0, import_node_path.dirname)(currentDir);
-    if (parentDir === currentDir) {
-      return null;
-    }
-    currentDir = parentDir;
-  }
-}
-function resolveProjectPath(explicitPath) {
-  if (explicitPath) {
-    const sagaDir = (0, import_node_path.join)(explicitPath, ".saga");
-    if (!(0, import_node_fs.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
+var import_node_process3 = __toESM(require("node:process"), 1);
 
-// src/commands/init.ts
-var WORKTREES_PATTERN = ".saga/worktrees/";
-function runInitDryRun(targetPath) {
-  const sagaDir = (0, import_node_path2.join)(targetPath, ".saga");
-  const sagaExists = (0, import_node_fs2.existsSync)(sagaDir);
-  const directories = [
-    { name: "epics", path: (0, import_node_path2.join)(sagaDir, "epics") },
-    { name: "archive", path: (0, import_node_path2.join)(sagaDir, "archive") },
-    { name: "worktrees", path: (0, import_node_path2.join)(sagaDir, "worktrees") }
-  ].map((dir) => ({
-    path: dir.path,
-    exists: (0, import_node_fs2.existsSync)(dir.path),
-    action: (0, import_node_fs2.existsSync)(dir.path) ? "exists (skip)" : "will create"
-  }));
-  const gitignorePath = (0, import_node_path2.join)(targetPath, ".gitignore");
-  const gitignoreExists = (0, import_node_fs2.existsSync)(gitignorePath);
-  let hasPattern = false;
-  if (gitignoreExists) {
-    const content = (0, import_node_fs2.readFileSync)(gitignorePath, "utf-8");
-    hasPattern = content.includes(WORKTREES_PATTERN);
-  }
-  let gitignoreAction;
-  if (!gitignoreExists) {
-    gitignoreAction = "will create with worktrees pattern";
-  } else if (hasPattern) {
-    gitignoreAction = "already has pattern (skip)";
-  } else {
-    gitignoreAction = "will append worktrees pattern";
-  }
-  return {
-    targetPath,
-    sagaExists,
-    directories,
-    gitignore: {
-      path: gitignorePath,
-      exists: gitignoreExists,
-      hasPattern,
-      action: gitignoreAction
-    }
-  };
-}
-function printInitDryRunResults(result) {
-  console.log("Dry Run - Init Command");
-  console.log("======================\n");
-  console.log(`Target directory: ${result.targetPath}`);
-  console.log(`SAGA project exists: ${result.sagaExists ? "yes" : "no"}
-`);
-  console.log("Directories:");
-  for (const dir of result.directories) {
-    const icon = dir.exists ? "-" : "+";
-    console.log(`  ${icon} ${dir.path}`);
-    console.log(`    Action: ${dir.action}`);
-  }
-  console.log("\nGitignore:");
-  console.log(`  Path: ${result.gitignore.path}`);
-  console.log(`  Action: ${result.gitignore.action}`);
-  console.log("\nDry run complete. No changes made.");
-}
-function resolveTargetPath(explicitPath) {
-  if (explicitPath) {
-    return explicitPath;
-  }
-  const existingRoot = findProjectRoot();
-  if (existingRoot) {
-    return existingRoot;
-  }
-  return process.cwd();
-}
-function createDirectoryStructure(projectRoot) {
-  const sagaDir = (0, import_node_path2.join)(projectRoot, ".saga");
-  (0, import_node_fs2.mkdirSync)((0, import_node_path2.join)(sagaDir, "epics"), { recursive: true });
-  (0, import_node_fs2.mkdirSync)((0, import_node_path2.join)(sagaDir, "archive"), { recursive: true });
-  (0, import_node_fs2.mkdirSync)((0, import_node_path2.join)(sagaDir, "worktrees"), { recursive: true });
-  console.log("Created .saga/ directory structure");
-}
-function updateGitignore(projectRoot) {
-  const gitignorePath = (0, import_node_path2.join)(projectRoot, ".gitignore");
-  if ((0, import_node_fs2.existsSync)(gitignorePath)) {
-    const content = (0, import_node_fs2.readFileSync)(gitignorePath, "utf-8");
-    if (content.includes(WORKTREES_PATTERN)) {
-      console.log(".gitignore already contains worktrees pattern");
-    } else {
-      (0, import_node_fs2.appendFileSync)(
-        gitignorePath,
-        `
-# Claude Tasks - Worktrees (git worktree isolation for stories)
-${WORKTREES_PATTERN}
-`
-      );
-      console.log("Updated .gitignore with worktrees pattern");
-    }
-  } else {
-    (0, import_node_fs2.writeFileSync)(
-      gitignorePath,
-      `# Claude Tasks - Worktrees (git worktree isolation for stories)
-${WORKTREES_PATTERN}
-`
-    );
-    console.log("Created .gitignore with worktrees pattern");
-  }
-}
-async function initCommand(options) {
-  if (options.path) {
-    if (!(0, import_node_fs2.existsSync)(options.path)) {
-      console.error(`Error: Specified path '${options.path}' does not exist`);
-      process.exit(1);
-    }
-    if (!(0, import_node_fs2.statSync)(options.path).isDirectory()) {
-      console.error(`Error: Specified path '${options.path}' is not a directory`);
-      process.exit(1);
-    }
-  }
-  const targetPath = resolveTargetPath(options.path);
-  if (options.dryRun) {
-    const dryRunResult = runInitDryRun(targetPath);
-    printInitDryRunResults(dryRunResult);
-    return;
-  }
-  createDirectoryStructure(targetPath);
-  updateGitignore(targetPath);
-  console.log(`Initialized .saga/ at ${targetPath}`);
-}
+// 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/commands/implement.ts
-var import_node_child_process2 = require("node:child_process");
-var import_node_path5 = require("node:path");
-var import_node_fs5 = require("node:fs");
+// src/server/routes.ts
+var import_node_path4 = require("node:path");
+var import_express2 = require("express");
 
-// src/utils/finder.ts
-var import_node_fs3 = require("node:fs");
-var import_node_path3 = require("node:path");
-var import_fuse = __toESM(require("fuse.js"), 1);
+// 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("fs/promises");
-var import_fs = require("fs");
-var import_path = require("path");
+var import_node_fs = require("node:fs");
+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);
@@ -224,18 +70,18 @@ async function fileExists(path) {
   }
 }
 function extractEpicTitle(content) {
-  const match = content.match(/^#\s+(.+)$/m);
+  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$/, "");
+    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_path.join)(storyDir, "journal.md");
+    const journalPath = (0, import_node_path.join)(storyDir, "journal.md");
     const hasJournal = await fileExists(journalPath);
     return {
       slug: frontmatter.id || frontmatter.slug || dirName,
@@ -254,24 +100,23 @@ async function parseStoryFile(storyPath, epicSlug, options = {}) {
   }
 }
 async function scanWorktrees(sagaRoot) {
-  const worktreesDir = (0, import_path.join)(sagaRoot, ".saga", "worktrees");
-  const stories = [];
+  const worktreesDir = (0, import_node_path.join)(sagaRoot, ".saga", "worktrees");
   if (!await isDirectory(worktreesDir)) {
-    return stories;
+    return [];
   }
   const epicEntries = await (0, import_promises.readdir)(worktreesDir);
-  for (const epicSlug of epicEntries) {
-    const epicWorktreesDir = (0, import_path.join)(worktreesDir, epicSlug);
+  const epicPromises = epicEntries.map(async (epicSlug) => {
+    const epicWorktreesDir = (0, import_node_path.join)(worktreesDir, epicSlug);
     if (!await isDirectory(epicWorktreesDir)) {
-      continue;
+      return [];
     }
     const storyEntries = await (0, import_promises.readdir)(epicWorktreesDir);
-    for (const storySlug of storyEntries) {
-      const worktreePath = (0, import_path.join)(epicWorktreesDir, storySlug);
+    const storyPromises = storyEntries.map(async (storySlug) => {
+      const worktreePath = (0, import_node_path.join)(epicWorktreesDir, storySlug);
       if (!await isDirectory(worktreePath)) {
-        continue;
+        return null;
       }
-      const storyPath = (0, import_path.join)(
+      const storyPath = (0, import_node_path.join)(
         worktreePath,
         ".saga",
         "epics",
@@ -280,67 +125,65 @@ async function scanWorktrees(sagaRoot) {
         storySlug,
         "story.md"
       );
-      const story = await parseStoryFile(storyPath, epicSlug, { worktreePath });
-      if (story) {
-        stories.push(story);
-      }
-    }
-  }
-  return stories;
+      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_path.join)(sagaRoot, ".saga", "epics");
-  const stories = [];
+  const epicsDir = (0, import_node_path.join)(sagaRoot, ".saga", "epics");
   if (!await isDirectory(epicsDir)) {
-    return stories;
+    return [];
   }
   const epicEntries = await (0, import_promises.readdir)(epicsDir);
-  for (const epicSlug of epicEntries) {
-    const storiesDir = (0, import_path.join)(epicsDir, epicSlug, "stories");
+  const epicPromises = epicEntries.map(async (epicSlug) => {
+    const storiesDir = (0, import_node_path.join)(epicsDir, epicSlug, "stories");
     if (!await isDirectory(storiesDir)) {
-      continue;
+      return [];
     }
     const storyEntries = await (0, import_promises.readdir)(storiesDir);
-    for (const storySlug of storyEntries) {
-      const storyDir = (0, import_path.join)(storiesDir, storySlug);
+    const storyPromises = storyEntries.map(async (storySlug) => {
+      const storyDir = (0, import_node_path.join)(storiesDir, storySlug);
       if (!await isDirectory(storyDir)) {
-        continue;
-      }
-      const storyPath = (0, import_path.join)(storyDir, "story.md");
-      const story = await parseStoryFile(storyPath, epicSlug);
-      if (story) {
-        stories.push(story);
+        return null;
       }
-    }
-  }
-  return stories;
+      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_path.join)(sagaRoot, ".saga", "archive");
-  const stories = [];
+  const archiveDir = (0, import_node_path.join)(sagaRoot, ".saga", "archive");
   if (!await isDirectory(archiveDir)) {
-    return stories;
+    return [];
   }
   const epicEntries = await (0, import_promises.readdir)(archiveDir);
-  for (const epicSlug of epicEntries) {
-    const epicArchiveDir = (0, import_path.join)(archiveDir, epicSlug);
+  const epicPromises = epicEntries.map(async (epicSlug) => {
+    const epicArchiveDir = (0, import_node_path.join)(archiveDir, epicSlug);
     if (!await isDirectory(epicArchiveDir)) {
-      continue;
+      return [];
     }
     const storyEntries = await (0, import_promises.readdir)(epicArchiveDir);
-    for (const storySlug of storyEntries) {
-      const storyDir = (0, import_path.join)(epicArchiveDir, storySlug);
+    const storyPromises = storyEntries.map(async (storySlug) => {
+      const storyDir = (0, import_node_path.join)(epicArchiveDir, storySlug);
       if (!await isDirectory(storyDir)) {
-        continue;
-      }
-      const storyPath = (0, import_path.join)(storyDir, "story.md");
-      const story = await parseStoryFile(storyPath, epicSlug, { archived: true });
-      if (story) {
-        stories.push(story);
+        return null;
       }
-    }
-  }
-  return stories;
+      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([
@@ -374,18 +217,17 @@ async function scanAllStories(sagaRoot) {
   return result;
 }
 async function scanEpics(sagaRoot) {
-  const epicsDir = (0, import_path.join)(sagaRoot, ".saga", "epics");
-  const epics = [];
+  const epicsDir = (0, import_node_path.join)(sagaRoot, ".saga", "epics");
   if (!await isDirectory(epicsDir)) {
-    return epics;
+    return [];
   }
   const epicEntries = await (0, import_promises.readdir)(epicsDir);
-  for (const epicSlug of epicEntries) {
-    const epicPath = (0, import_path.join)(epicsDir, epicSlug);
+  const epicPromises = epicEntries.map(async (epicSlug) => {
+    const epicPath = (0, import_node_path.join)(epicsDir, epicSlug);
     if (!await isDirectory(epicPath)) {
-      continue;
+      return null;
     }
-    const epicMdPath = (0, import_path.join)(epicPath, "epic.md");
+    const epicMdPath = (0, import_node_path.join)(epicPath, "epic.md");
     let content = "";
     let title = epicSlug;
     try {
@@ -393,241 +235,222 @@ async function scanEpics(sagaRoot) {
       title = extractEpicTitle(content) || epicSlug;
     } catch {
     }
-    epics.push({
+    return {
       slug: epicSlug,
       title,
       epicPath,
       epicMdPath,
       content
-    });
-  }
-  return epics;
+    };
+  });
+  const epics = await Promise.all(epicPromises);
+  return epics.filter((epic) => epic !== null);
 }
 function worktreesDirectoryExists(projectPath) {
-  return (0, import_fs.existsSync)((0, import_path.join)(projectPath, ".saga", "worktrees"));
+  return (0, import_node_fs.existsSync)((0, import_node_path.join)(projectPath, ".saga", "worktrees"));
 }
 function epicsDirectoryExists(projectPath) {
-  return (0, import_fs.existsSync)((0, import_path.join)(projectPath, ".saga", "epics"));
+  return (0, import_node_fs.existsSync)((0, import_node_path.join)(projectPath, ".saga", "epics"));
 }
 
-// src/utils/finder.ts
-var FUZZY_THRESHOLD = 0.3;
-var MATCH_THRESHOLD = 0.6;
-var SCORE_SIMILARITY_THRESHOLD = 0.1;
-function extractContext(body, maxLength = 300) {
-  const contextMatch = body.match(/##\s*Context\s*\n+([\s\S]*?)(?=\n##|\Z|$)/i);
-  if (!contextMatch) {
-    return "";
+// 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;
   }
-  let context = contextMatch[1].trim();
-  if (context.length > maxLength) {
-    return context.slice(0, maxLength - 3) + "...";
+  return "ready";
+}
+function validateTaskStatus(status) {
+  const validStatuses = ["pending", "in_progress", "completed"];
+  if (typeof status === "string" && validStatuses.includes(status)) {
+    return status;
   }
-  return context;
+  return "pending";
 }
-function normalize(str) {
-  return str.toLowerCase().replace(/[-_]/g, " ");
+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))
+  }));
 }
-function toStoryInfo(story) {
+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,
-    title: story.title,
-    status: story.status,
-    context: extractContext(story.body),
     epicSlug: story.epicSlug,
-    storyPath: story.storyPath,
-    worktreePath: story.worktreePath || ""
+    title: story.title,
+    status: toApiStoryStatus(validateStatus(story.status)),
+    tasks,
+    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) } : {}
+    }
   };
 }
-function findEpic(projectPath, query) {
-  const epicsDir = (0, import_node_path3.join)(projectPath, ".saga", "epics");
-  if (!epicsDirectoryExists(projectPath)) {
-    return {
-      found: false,
-      error: "No .saga/epics/ directory found"
-    };
+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: join14 } = 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 epicSlugs = (0, import_node_fs3.readdirSync)(epicsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
-  if (epicSlugs.length === 0) {
-    return {
-      found: false,
-      error: `No epic found matching '${query}'`
-    };
+  const storyDir = storyPath.replace(STORY_MD_SUFFIX_PATTERN2, "");
+  const dirName = storyDir.split("/").pop() || "unknown";
+  let frontmatter = {};
+  try {
+    const parsed = (0, import_gray_matter2.default)(content);
+    frontmatter = parsed.data;
+  } catch {
   }
-  const queryNormalized = query.toLowerCase().replace(/_/g, "-");
-  for (const slug of epicSlugs) {
-    if (slug.toLowerCase() === queryNormalized) {
-      return {
-        found: true,
-        data: { slug }
-      };
-    }
-  }
-  const epics = epicSlugs.map((slug) => ({ slug }));
-  const fuse = new import_fuse.default(epics, {
-    keys: ["slug"],
-    threshold: MATCH_THRESHOLD,
-    includeScore: true
-  });
-  const results = fuse.search(query);
-  if (results.length === 0) {
-    return {
-      found: false,
-      error: `No epic found matching '${query}'`
-    };
-  }
-  if (results.length === 1) {
-    return {
-      found: true,
-      data: results[0].item
-    };
-  }
-  const bestScore = results[0].score ?? 0;
-  const similarMatches = results.filter(
-    (r) => (r.score ?? 0) - bestScore <= SCORE_SIMILARITY_THRESHOLD
-  );
-  if (similarMatches.length > 1) {
-    return {
-      found: false,
-      matches: similarMatches.map((r) => r.item)
-    };
-  }
-  if (bestScore <= FUZZY_THRESHOLD) {
-    return {
-      found: true,
-      data: results[0].item
-    };
+  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 = join14(storyDir, "journal.md");
+  let hasJournal = false;
+  try {
+    await stat4(journalPath);
+    hasJournal = true;
+  } catch {
   }
   return {
-    found: false,
-    matches: results.map((r) => r.item)
+    slug,
+    epicSlug,
+    title,
+    status,
+    tasks,
+    paths: {
+      storyMd: storyPath,
+      ...hasJournal ? { journalMd: journalPath } : {}
+    }
   };
 }
-async function findStory(projectPath, query, options = {}) {
-  if (!worktreesDirectoryExists(projectPath) && !epicsDirectoryExists(projectPath)) {
-    return {
-      found: false,
-      error: "No .saga/worktrees/ or .saga/epics/ directory found. Run /generate-stories first."
-    };
-  }
-  const scannedStories = await scanAllStories(projectPath);
-  if (scannedStories.length === 0) {
-    return {
-      found: false,
-      error: `No story found matching '${query}'`
-    };
-  }
-  let allStories = scannedStories.map(toStoryInfo);
-  if (options.status) {
-    allStories = allStories.filter((story) => story.status === options.status);
-    if (allStories.length === 0) {
-      return {
-        found: false,
-        error: `No story found matching '${query}' with status '${options.status}'`
-      };
+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",
+          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",
+          content: `${title}
+
+${sectionContent}`.trim()
+        });
+      } else if (headerLine.toLowerCase().startsWith("resolution:")) {
+        const title = headerLine.substring("resolution:".length).trim();
+        entries.push({
+          timestamp: "",
+          // Resolutions may not have timestamps
+          type: "resolution",
+          content: `${title}
+
+${sectionContent}`.trim()
+        });
+      }
     }
+    return entries;
+  } catch {
+    return [];
   }
-  const queryNormalized = normalize(query);
-  for (const story of allStories) {
-    if (normalize(story.slug) === queryNormalized) {
-      return {
-        found: true,
-        data: story
-      };
-    }
+}
+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 fuse = new import_fuse.default(allStories, {
-    keys: [
-      { name: "slug", weight: 2 },
-      // Prioritize slug matches
-      { name: "title", weight: 1 }
-    ],
-    threshold: MATCH_THRESHOLD,
-    includeScore: true
+  const epicPromises = scannedEpics.map((scannedEpic) => {
+    const epicStories = storiesByEpic.get(scannedEpic.slug) || [];
+    return buildEpic(scannedEpic, epicStories, sagaRoot);
   });
-  const results = fuse.search(query);
-  if (results.length === 0) {
-    return {
-      found: false,
-      error: `No story found matching '${query}'`
-    };
-  }
-  if (results.length === 1) {
-    return {
-      found: true,
-      data: results[0].item
-    };
-  }
-  const bestScore = results[0].score ?? 0;
-  const similarMatches = results.filter(
-    (r) => (r.score ?? 0) - bestScore <= SCORE_SIMILARITY_THRESHOLD
-  );
-  if (similarMatches.length > 1) {
-    return {
-      found: false,
-      matches: similarMatches.map((r) => r.item)
-    };
-  }
-  if (bestScore <= FUZZY_THRESHOLD) {
-    return {
-      found: true,
-      data: results[0].item
-    };
-  }
-  return {
-    found: false,
-    matches: results.map((r) => r.item)
-  };
+  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_fs4 = require("node:fs");
-var import_promises2 = require("node:fs/promises");
-var import_node_path4 = require("node:path");
+var import_node_fs2 = 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 SLUG_PATTERN = /^[a-z0-9-]+$/;
+var SESSION_NAME_PATTERN = /^(saga[-_][-_]?[a-z0-9_-]+):/;
 var OUTPUT_DIR = "/tmp/saga-sessions";
-function shellEscape(str) {
-  return "'" + str.replace(/'/g, "'\\''") + "'";
-}
-function shellEscapeArgs(args) {
-  return args.map(shellEscape).join(" ");
-}
-function validateSlug(slug) {
-  if (!slug || slug.length === 0) {
-    return false;
-  }
-  if (!/^[a-z0-9-]+$/.test(slug)) {
-    return false;
-  }
-  if (slug.startsWith("-") || slug.endsWith("-")) {
-    return false;
-  }
-  return true;
-}
 function checkTmuxAvailable() {
   const result = (0, import_node_child_process.spawnSync)("which", ["tmux"], { encoding: "utf-8" });
   if (result.status !== 0) {
     throw new Error("tmux is not installed or not found in PATH");
   }
 }
-async function createSession(epicSlug, storySlug, command) {
-  if (!validateSlug(epicSlug)) {
-    throw new Error(`Invalid epic slug: '${epicSlug}'. Must contain only [a-z0-9-] and not start/end with hyphen.`);
-  }
-  if (!validateSlug(storySlug)) {
-    throw new Error(`Invalid story slug: '${storySlug}'. Must contain only [a-z0-9-] and not start/end with hyphen.`);
-  }
-  checkTmuxAvailable();
-  if (!(0, import_node_fs4.existsSync)(OUTPUT_DIR)) {
-    (0, import_node_fs4.mkdirSync)(OUTPUT_DIR, { recursive: true });
-  }
-  const timestamp = Date.now();
-  const sessionName = `saga-${epicSlug}-${storySlug}-${timestamp}`;
-  const outputFile = (0, import_node_path4.join)(OUTPUT_DIR, `${sessionName}.out`);
-  const commandFilePath = (0, import_node_path4.join)(OUTPUT_DIR, `${sessionName}.cmd`);
-  const wrapperScriptPath = (0, import_node_path4.join)(OUTPUT_DIR, `${sessionName}.sh`);
-  (0, import_node_fs4.writeFileSync)(commandFilePath, command, { mode: 384 });
-  const wrapperScriptContent = `#!/bin/bash
+function generateWrapperScript(commandFilePath, outputFile, wrapperScriptPath) {
+  return `#!/bin/bash
 # Auto-generated wrapper script for SAGA session
 set -e
 
@@ -658,26 +481,100 @@ else
   exec script -q -c "$COMMAND" "$OUTPUT_FILE"
 fi
 `;
-  (0, import_node_fs4.writeFileSync)(wrapperScriptPath, wrapperScriptContent, { mode: 448 });
-  const createResult = (0, import_node_child_process.spawnSync)("tmux", [
-    "new-session",
-    "-d",
-    // detached
-    "-s",
-    sessionName,
-    // session name
+}
+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 validateSessionSlugs(epicSlug, storySlug) {
+  if (!validateSlug(epicSlug)) {
+    throw new Error(
+      `Invalid epic slug: '${epicSlug}'. Must contain only [a-z0-9-] and not start/end with hyphen.`
+    );
+  }
+  if (!validateSlug(storySlug)) {
+    throw new Error(
+      `Invalid story slug: '${storySlug}'. Must contain only [a-z0-9-] and not start/end with hyphen.`
+    );
+  }
+}
+function createSessionFiles(sessionName, command) {
+  const outputFile = (0, import_node_path3.join)(OUTPUT_DIR, `${sessionName}.out`);
+  const commandFilePath = (0, import_node_path3.join)(OUTPUT_DIR, `${sessionName}.cmd`);
+  const wrapperScriptPath = (0, import_node_path3.join)(OUTPUT_DIR, `${sessionName}.sh`);
+  (0, import_node_fs2.writeFileSync)(commandFilePath, command, { mode: 384 });
+  const wrapperScriptContent = generateWrapperScript(
+    commandFilePath,
+    outputFile,
     wrapperScriptPath
-    // run the wrapper script
-  ], { encoding: "utf-8" });
+  );
+  (0, import_node_fs2.writeFileSync)(wrapperScriptPath, wrapperScriptContent, { mode: 448 });
+  return { wrapperScriptPath, outputFile };
+}
+function shellEscape(str) {
+  return `'${str.replace(/'/g, "'\\''")}'`;
+}
+function shellEscapeArgs(args) {
+  return args.map(shellEscape).join(" ");
+}
+function validateSlug(slug) {
+  if (typeof slug !== "string" || slug.length === 0) {
+    return false;
+  }
+  if (!SLUG_PATTERN.test(slug)) {
+    return false;
+  }
+  if (slug.startsWith("-") || slug.endsWith("-")) {
+    return false;
+  }
+  return true;
+}
+function createSession(epicSlug, storySlug, command) {
+  validateSessionSlugs(epicSlug, storySlug);
+  checkTmuxAvailable();
+  if (!(0, import_node_fs2.existsSync)(OUTPUT_DIR)) {
+    (0, import_node_fs2.mkdirSync)(OUTPUT_DIR, { recursive: true });
+  }
+  const timestamp = Date.now();
+  const sessionName = `saga-${epicSlug}-${storySlug}-${timestamp}`;
+  const { wrapperScriptPath, outputFile } = createSessionFiles(sessionName, command);
+  const createResult = (0, import_node_child_process.spawnSync)(
+    "tmux",
+    ["new-session", "-d", "-s", sessionName, wrapperScriptPath],
+    { encoding: "utf-8" }
+  );
   if (createResult.status !== 0) {
     throw new Error(`Failed to create tmux session: ${createResult.stderr || "unknown error"}`);
   }
-  return {
-    sessionName,
-    outputFile
-  };
+  return { sessionName, outputFile };
 }
-async function listSessions() {
+function listSessions() {
   const result = (0, import_node_child_process.spawnSync)("tmux", ["ls"], { encoding: "utf-8" });
   if (result.status !== 0) {
     return [];
@@ -685,20 +582,20 @@ async function listSessions() {
   const sessions = [];
   const lines = result.stdout.trim().split("\n");
   for (const line of lines) {
-    const match = line.match(/^(saga-[a-z0-9]+(?:-[a-z0-9]+)*-\d+):/);
+    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_path4.join)(OUTPUT_DIR, `${name}.out`)
+        outputFile: (0, import_node_path3.join)(OUTPUT_DIR, `${name}.out`)
       });
     }
   }
   return sessions;
 }
-async function getSessionStatus(sessionName) {
+function getSessionStatus(sessionName) {
   const result = (0, import_node_child_process.spawnSync)("tmux", ["has-session", "-t", sessionName], {
     encoding: "utf-8"
   });
@@ -706,9 +603,9 @@ async function getSessionStatus(sessionName) {
     running: result.status === 0
   };
 }
-async function streamLogs(sessionName) {
-  const outputFile = (0, import_node_path4.join)(OUTPUT_DIR, `${sessionName}.out`);
-  if (!(0, import_node_fs4.existsSync)(outputFile)) {
+function streamLogs(sessionName) {
+  const outputFile = (0, import_node_path3.join)(OUTPUT_DIR, `${sessionName}.out`);
+  if (!(0, import_node_fs2.existsSync)(outputFile)) {
     throw new Error(`Output file not found: ${outputFile}`);
   }
   return new Promise((resolve2, reject) => {
@@ -716,25 +613,25 @@ async function streamLogs(sessionName) {
       stdio: ["ignore", "pipe", "pipe"]
     });
     child.stdout?.on("data", (chunk) => {
-      process.stdout.write(chunk);
+      import_node_process.default.stdout.write(chunk);
     });
     child.stderr?.on("data", (chunk) => {
-      process.stderr.write(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) => {
+    child.on("close", (_code) => {
       resolve2();
     });
     const sigintHandler = () => {
       child.kill("SIGTERM");
-      process.removeListener("SIGINT", sigintHandler);
+      import_node_process.default.removeListener("SIGINT", sigintHandler);
     };
-    process.on("SIGINT", sigintHandler);
+    import_node_process.default.on("SIGINT", sigintHandler);
   });
 }
-async function killSession(sessionName) {
+function killSession(sessionName) {
   const result = (0, import_node_child_process.spawnSync)("tmux", ["kill-session", "-t", sessionName], {
     encoding: "utf-8"
   });
@@ -743,15 +640,15 @@ async function killSession(sessionName) {
   };
 }
 function parseSessionName(name) {
-  if (!name || !name.startsWith("saga__")) {
+  if (!name?.startsWith("saga__")) {
     return null;
   }
   const parts = name.split("__");
-  if (parts.length !== 4) {
+  if (parts.length !== SESSION_NAME_PARTS_COUNT) {
     return null;
   }
   const [, epicSlug, storySlug, pid] = parts;
-  if (!epicSlug || !storySlug || !pid) {
+  if (!(epicSlug && storySlug && pid)) {
     return null;
   }
   return {
@@ -764,35 +661,16 @@ async function buildSessionInfo(name, status) {
   if (!parsed) {
     return null;
   }
-  const outputFile = (0, import_node_path4.join)(OUTPUT_DIR, `${name}.out`);
-  const outputAvailable = (0, import_node_fs4.existsSync)(outputFile);
+  const outputFile = (0, import_node_path3.join)(OUTPUT_DIR, `${name}.out`);
+  const outputAvailable = (0, import_node_fs2.existsSync)(outputFile);
   let startTime = /* @__PURE__ */ new Date();
   let endTime;
   let outputPreview;
   if (outputAvailable) {
-    try {
-      const stats = await (0, import_promises2.stat)(outputFile);
-      startTime = stats.birthtime;
-      if (status === "completed") {
-        endTime = stats.mtime;
-      }
-    } catch {
-    }
-    try {
-      const content = await (0, import_promises2.readFile)(outputFile, "utf-8");
-      const lines = content.split("\n").filter((line) => line.length > 0);
-      if (lines.length > 0) {
-        const lastLines = lines.slice(-5);
-        let preview = lastLines.join("\n");
-        if (preview.length > 500) {
-          const truncated = preview.slice(0, 500);
-          const lastNewline = truncated.lastIndexOf("\n");
-          preview = lastNewline > 0 ? truncated.slice(0, lastNewline) : truncated;
-        }
-        outputPreview = preview;
-      }
-    } catch {
-    }
+    const timestamps = await extractFileTimestamps(outputFile, status);
+    startTime = timestamps.startTime;
+    endTime = timestamps.endTime;
+    outputPreview = await generateOutputPreview(outputFile);
   }
   return {
     name,
@@ -807,1359 +685,2003 @@ async function buildSessionInfo(name, status) {
   };
 }
 
-// src/commands/implement.ts
-var DEFAULT_MAX_CYCLES = 10;
-var DEFAULT_MAX_TIME = 60;
-var DEFAULT_MODEL = "opus";
-var VALID_STATUSES = /* @__PURE__ */ new Set(["ONGOING", "FINISH", "BLOCKED"]);
-var WORKER_PROMPT_RELATIVE = "worker-prompt.md";
-var WORKER_OUTPUT_SCHEMA = {
-  type: "object",
-  properties: {
-    status: {
-      type: "string",
-      enum: ["ONGOING", "FINISH", "BLOCKED"]
-    },
-    summary: {
-      type: "string",
-      description: "What was accomplished this session"
-    },
-    blocker: {
-      type: ["string", "null"],
-      description: "Brief description if BLOCKED, null otherwise"
-    }
-  },
-  required: ["status", "summary"]
-};
-async function findStory2(projectPath, storySlug) {
-  const result = await findStory(projectPath, storySlug);
-  if (!result.found) {
-    return null;
+// 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;
+    }
   }
-  return {
-    epicSlug: result.data.epicSlug,
-    storySlug: result.data.slug,
-    storyPath: result.data.storyPath,
-    worktreePath: result.data.worktreePath
-  };
+  for (const name of currentMap.keys()) {
+    if (!newMap.has(name)) {
+      return true;
+    }
+  }
+  return false;
 }
-function computeStoryPath(worktree, epicSlug, storySlug) {
-  return (0, import_node_path5.join)(worktree, ".saga", "epics", epicSlug, "stories", storySlug, "story.md");
+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 validateStoryFiles(worktree, epicSlug, storySlug) {
-  if (!(0, import_node_fs5.existsSync)(worktree)) {
-    return {
-      valid: false,
-      error: `Worktree not found at ${worktree}
-
-The story worktree has not been created yet. This can happen if:
-1. The story was generated but the worktree wasn't set up
-2. The worktree was deleted or moved
-
-To create the worktree, use: /task-resume ${storySlug}`
-    };
+function detectChanges(newSessions) {
+  if (isFirstPoll) {
+    return true;
   }
-  const storyPath = computeStoryPath(worktree, epicSlug, storySlug);
-  if (!(0, import_node_fs5.existsSync)(storyPath)) {
-    return {
-      valid: false,
-      error: `story.md not found in worktree.
-
-Expected location: ${storyPath}
-
-The worktree exists but the story definition file is missing.
-This may indicate an incomplete story setup.`
-    };
+  if (newSessions.length !== currentSessions.length) {
+    return true;
   }
-  return { valid: true };
-}
-function getSkillRoot(pluginRoot) {
-  return (0, import_node_path5.join)(pluginRoot, "skills", "execute-story");
+  const newSessionMap = createSessionMap(newSessions);
+  const currentSessionMap = createSessionMap(currentSessions);
+  if (hasSessionSetChanged(newSessionMap, currentSessionMap)) {
+    return true;
+  }
+  return hasSessionPropertiesChanged(newSessionMap, currentSessionMap);
 }
-function checkCommandExists(command) {
+async function buildSessionInfoSafe(sessionName, status) {
   try {
-    const result = (0, import_node_child_process2.spawnSync)("which", [command], { encoding: "utf-8" });
-    if (result.status === 0 && result.stdout.trim()) {
-      return { exists: true, path: result.stdout.trim() };
-    }
-    return { exists: false };
+    return await buildSessionInfo(sessionName, status);
   } catch {
-    return { exists: false };
+    return null;
   }
 }
-function runDryRun(storyInfo, projectPath, pluginRoot) {
-  const checks = [];
-  let allPassed = true;
-  if (pluginRoot) {
-    checks.push({
-      name: "SAGA_PLUGIN_ROOT",
-      path: pluginRoot,
-      passed: true
-    });
-  } else {
-    checks.push({
-      name: "SAGA_PLUGIN_ROOT",
-      passed: false,
-      error: "Environment variable not set"
-    });
-    allPassed = false;
-  }
-  const claudeCheck = checkCommandExists("claude");
-  checks.push({
-    name: "claude CLI",
-    path: claudeCheck.path,
-    passed: claudeCheck.exists,
-    error: claudeCheck.exists ? void 0 : "Command not found in PATH"
+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);
   });
-  if (!claudeCheck.exists) allPassed = false;
-  if (pluginRoot) {
-    const skillRoot = getSkillRoot(pluginRoot);
-    const workerPromptPath = (0, import_node_path5.join)(skillRoot, WORKER_PROMPT_RELATIVE);
-    if ((0, import_node_fs5.existsSync)(workerPromptPath)) {
-      checks.push({
-        name: "Worker prompt",
-        path: workerPromptPath,
-        passed: true
-      });
-    } else {
-      checks.push({
-        name: "Worker prompt",
-        path: workerPromptPath,
-        passed: false,
-        error: "File not found"
+  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
       });
-      allPassed = false;
     }
+  } catch {
   }
-  checks.push({
-    name: "Story found",
-    path: `${storyInfo.storySlug} (epic: ${storyInfo.epicSlug})`,
-    passed: true
-  });
-  if ((0, import_node_fs5.existsSync)(storyInfo.worktreePath)) {
-    checks.push({
-      name: "Worktree exists",
-      path: storyInfo.worktreePath,
-      passed: true
-    });
-  } else {
-    checks.push({
-      name: "Worktree exists",
-      path: storyInfo.worktreePath,
-      passed: false,
-      error: "Directory not found"
-    });
-    allPassed = false;
-  }
-  if ((0, import_node_fs5.existsSync)(storyInfo.worktreePath)) {
-    const storyMdPath = computeStoryPath(
-      storyInfo.worktreePath,
-      storyInfo.epicSlug,
-      storyInfo.storySlug
-    );
-    if ((0, import_node_fs5.existsSync)(storyMdPath)) {
-      checks.push({
-        name: "story.md in worktree",
-        path: storyMdPath,
-        passed: true
-      });
-    } else {
-      checks.push({
-        name: "story.md in worktree",
-        path: storyMdPath,
-        passed: false,
-        error: "File not found"
-      });
-      allPassed = false;
-    }
+}
+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;
   }
-  return {
-    success: allPassed,
-    checks,
-    story: {
-      epicSlug: storyInfo.epicSlug,
-      storySlug: storyInfo.storySlug,
-      worktreePath: storyInfo.worktreePath
-    }
-  };
+  currentSessions = [];
+  isFirstPoll = true;
 }
-function printDryRunResults(result) {
-  console.log("Dry Run Validation");
-  console.log("==================\n");
-  for (const check of result.checks) {
-    const icon = check.passed ? "\u2713" : "\u2717";
-    const status = check.passed ? "OK" : "FAILED";
-    if (check.passed) {
-      console.log(`${icon} ${check.name}: ${check.path || status}`);
-    } else {
-      console.log(`${icon} ${check.name}: ${check.error}`);
-      if (check.path) {
-        console.log(`  Expected: ${check.path}`);
+
+// 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" });
     }
-  }
-  console.log("");
-  if (result.success) {
-    console.log("Dry run complete. All checks passed. Ready to implement.");
-  } else {
-    console.log("Dry run failed. Please fix the issues above before running implement.");
-  }
+  });
+  return router;
 }
-function loadWorkerPrompt(pluginRoot) {
-  const skillRoot = getSkillRoot(pluginRoot);
-  const promptPath = (0, import_node_path5.join)(skillRoot, WORKER_PROMPT_RELATIVE);
-  if (!(0, import_node_fs5.existsSync)(promptPath)) {
-    throw new Error(`Worker prompt not found at ${promptPath}`);
-  }
-  return (0, import_node_fs5.readFileSync)(promptPath, "utf-8");
+
+// src/server/routes.ts
+var HTTP_NOT_FOUND2 = 404;
+var HTTP_INTERNAL_ERROR2 = 500;
+function getEpics(sagaRoot) {
+  return scanSagaDirectory(sagaRoot);
 }
-function buildScopeSettings() {
-  const hookCommand = "npx @saga-ai/cli scope-validator";
+function toEpicSummary(epic) {
   return {
-    hooks: {
-      PreToolUse: [
-        {
-          matcher: "Read|Write|Edit|Glob|Grep",
-          hooks: [hookCommand]
-        }
-      ]
-    }
+    slug: epic.slug,
+    title: epic.title,
+    storyCounts: epic.storyCounts,
+    path: epic.path
   };
 }
-function formatStreamLine(line) {
-  try {
-    const data = JSON.parse(line);
-    if (data.type === "assistant" && data.message?.content) {
-      for (const block of data.message.content) {
-        if (block.type === "text" && block.text) {
-          return block.text;
-        }
-        if (block.type === "tool_use") {
-          return `[Tool: ${block.name}]`;
-        }
-      }
-    }
-    if (data.type === "system" && data.subtype === "init") {
-      return `[Session started: ${data.session_id}]`;
+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" });
     }
-    if (data.type === "result") {
-      const status = data.subtype === "success" ? "completed" : "failed";
-      return `
-[Worker ${status} in ${Math.round(data.duration_ms / 1e3)}s]`;
+  });
+  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" });
     }
-    return null;
-  } catch {
-    return null;
-  }
+  });
 }
-function extractStructuredOutputFromToolCall(lines) {
-  for (let i = lines.length - 1; i >= 0; i--) {
+function registerStoriesRoutes(router, sagaRoot) {
+  router.get("/stories/:epicSlug/:storySlug", async (req, res) => {
     try {
-      const data = JSON.parse(lines[i]);
-      if (data.type === "assistant" && data.message?.content) {
-        for (const block of data.message.content) {
-          if (block.type === "tool_use" && block.name === "StructuredOutput") {
-            return block.input;
-          }
+      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;
         }
       }
-    } catch {
+      res.json(story);
+    } catch (_error) {
+      res.status(HTTP_INTERNAL_ERROR2).json({ error: "Failed to fetch story" });
     }
-  }
-  return null;
+  });
 }
-function parseStreamingResult(buffer) {
-  const lines = buffer.split("\n").filter((line) => line.trim());
-  for (let i = lines.length - 1; i >= 0; i--) {
-    try {
-      const data = JSON.parse(lines[i]);
-      if (data.type === "result") {
-        if (data.is_error) {
-          throw new Error(`Worker failed: ${data.result || "Unknown error"}`);
-        }
-        let output = data.structured_output;
-        if (!output) {
-          output = extractStructuredOutputFromToolCall(lines);
-        }
-        if (!output) {
-          throw new Error("Worker result missing structured_output");
-        }
-        if (!VALID_STATUSES.has(output.status)) {
-          throw new Error(`Invalid status: ${output.status}`);
-        }
-        return {
-          status: output.status,
-          summary: output.summary || "",
-          blocker: output.blocker ?? null
-        };
-      }
-    } catch (e) {
-      if (e instanceof Error && e.message.startsWith("Worker")) {
-        throw e;
-      }
-    }
-  }
-  throw new Error("No result found in worker output");
+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;
 }
-function spawnWorkerAsync(prompt, model, settings, workingDir) {
-  return new Promise((resolve2, reject) => {
-    let buffer = "";
-    const args = [
-      "-p",
-      prompt,
-      "--model",
-      model,
-      "--output-format",
-      "stream-json",
-      "--verbose",
-      "--json-schema",
-      JSON.stringify(WORKER_OUTPUT_SCHEMA),
-      "--settings",
-      JSON.stringify(settings),
-      "--dangerously-skip-permissions"
-    ];
-    const child = (0, import_node_child_process2.spawn)("claude", args, {
-      cwd: workingDir,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    child.stdout.on("data", (chunk) => {
-      const text = chunk.toString();
-      buffer += text;
-      const lines = text.split("\n");
-      for (const line of lines) {
-        if (line.trim()) {
-          const formatted = formatStreamLine(line);
-          if (formatted) {
-            process.stdout.write(formatted);
-          }
-        }
-      }
+
+// 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_fs3 = 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_fs3.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
     });
-    child.stderr.on("data", (chunk) => {
-      process.stderr.write(chunk);
+    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
     });
-    child.on("error", (err) => {
-      reject(new Error(`Failed to spawn worker: ${err.message}`));
+    watcher.on("change", async () => {
+      await this.sendIncrementalContent(sessionName, outputFile);
     });
-    child.on("close", (code) => {
-      process.stdout.write("\n");
-      try {
-        const result = parseStreamingResult(buffer);
-        resolve2(result);
-      } catch (e) {
-        reject(e);
+    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((resolve2, reject) => {
+      let content = "";
+      const stream = (0, import_node_fs3.createReadStream)(filePath, {
+        start,
+        end: end - 1,
+        // createReadStream end is inclusive
+        encoding: "utf-8"
+      });
+      stream.on("data", (chunk) => {
+        content += chunk;
+      });
+      stream.on("end", () => {
+        resolve2(content);
+      });
+      stream.on("error", reject);
     });
-  });
-}
-async function runLoop(epicSlug, storySlug, maxCycles, maxTime, model, projectDir, pluginRoot) {
-  const worktree = (0, import_node_path5.join)(projectDir, ".saga", "worktrees", epicSlug, storySlug);
-  const validation = validateStoryFiles(worktree, epicSlug, storySlug);
-  if (!validation.valid) {
-    return {
-      status: "ERROR",
-      summary: validation.error || "Story validation failed",
-      cycles: 0,
-      elapsedMinutes: 0,
-      blocker: null,
-      epicSlug,
-      storySlug
+  }
+  /**
+   * 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_fs3.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();
   }
-  let workerPrompt;
-  try {
-    workerPrompt = loadWorkerPrompt(pluginRoot);
-  } catch (e) {
+};
+
+// src/server/watcher.ts
+var import_node_events = require("node:events");
+var import_node_path6 = require("node:path");
+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 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 {
-      status: "ERROR",
-      summary: e.message,
-      cycles: 0,
-      elapsedMinutes: 0,
-      blocker: null,
       epicSlug,
-      storySlug
+      archived: false,
+      isEpicFile: true,
+      isStoryFile: false,
+      isMainStoryFile: false
     };
   }
-  const settings = buildScopeSettings();
-  const startTime = Date.now();
-  let cycles = 0;
-  const summaries = [];
-  let lastBlocker = null;
-  let finalStatus = null;
-  const maxTimeMs = maxTime * 60 * 1e3;
-  while (cycles < maxCycles) {
-    const elapsedMs = Date.now() - startTime;
-    if (elapsedMs >= maxTimeMs) {
-      finalStatus = "TIMEOUT";
-      break;
-    }
-    cycles += 1;
-    let parsed;
-    console.log(`
---- Worker ${cycles} started ---
-`);
-    try {
-      parsed = await spawnWorkerAsync(workerPrompt, model, settings, worktree);
-    } catch (e) {
+  if (parts.length >= STORY_FILE_PARTS && parts[3] === "stories") {
+    const storySlug = parts[4];
+    const fileName = parts[5];
+    if (isStoryMarkdownFile(fileName)) {
       return {
-        status: "ERROR",
-        summary: e.message,
-        cycles,
-        elapsedMinutes: (Date.now() - startTime) / 6e4,
-        blocker: null,
         epicSlug,
-        storySlug
+        storySlug,
+        archived: false,
+        isEpicFile: false,
+        isStoryFile: true,
+        isMainStoryFile: fileName === "story.md"
       };
     }
-    console.log(`
---- Worker ${cycles} result: ${parsed.status} ---
-`);
-    summaries.push(parsed.summary);
-    if (parsed.status === "FINISH") {
-      finalStatus = "FINISH";
-      break;
-    } else if (parsed.status === "BLOCKED") {
-      finalStatus = "BLOCKED";
-      lastBlocker = parsed.blocker || null;
-      break;
-    }
   }
-  if (finalStatus === null) {
-    finalStatus = "MAX_CYCLES";
+  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 elapsedMinutes = (Date.now() - startTime) / 6e4;
-  const combinedSummary = summaries.length === 1 ? summaries[0] : summaries.join(" | ");
+  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 {
-    status: finalStatus,
-    summary: combinedSummary,
-    cycles,
-    elapsedMinutes: Math.round(elapsedMinutes * 100) / 100,
-    blocker: lastBlocker,
-    epicSlug,
-    storySlug
+    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 buildDetachedCommand(storySlug, projectPath, options) {
-  const parts = ["saga", "implement", storySlug];
-  parts.push("--path", projectPath);
-  if (options.maxCycles !== void 0) {
-    parts.push("--max-cycles", String(options.maxCycles));
+function getEpicEventType(eventType) {
+  if (eventType === "add") {
+    return "epic:added";
   }
-  if (options.maxTime !== void 0) {
-    parts.push("--max-time", String(options.maxTime));
-  }
-  if (options.model !== void 0) {
-    parts.push("--model", options.model);
+  if (eventType === "unlink") {
+    return "epic:removed";
   }
-  return shellEscapeArgs(parts);
+  return "epic:changed";
 }
-async function implementCommand(storySlug, options) {
-  let projectPath;
-  try {
-    projectPath = resolveProjectPath(options.path);
-  } catch (error) {
-    console.error(`Error: ${error.message}`);
-    process.exit(1);
-  }
-  const storyInfo = await findStory2(projectPath, storySlug);
-  if (!storyInfo) {
-    console.error(`Error: Story '${storySlug}' not found in SAGA project.`);
-    console.error(`
-Searched in: ${(0, import_node_path5.join)(projectPath, ".saga", "worktrees")}`);
-    console.error("\nMake sure the story worktree exists and has a story.md file.");
-    console.error("Run /generate-stories to create story worktrees.");
-    process.exit(1);
-  }
-  const pluginRoot = process.env.SAGA_PLUGIN_ROOT;
-  if (options.dryRun) {
-    const dryRunResult = runDryRun(storyInfo, projectPath, pluginRoot);
-    printDryRunResults(dryRunResult);
-    process.exit(dryRunResult.success ? 0 : 1);
+function getStoryEventType(eventType, isMainStoryFile) {
+  if (!isMainStoryFile) {
+    return "story:changed";
   }
-  if (!(0, import_node_fs5.existsSync)(storyInfo.worktreePath)) {
-    console.error(`Error: Worktree not found at ${storyInfo.worktreePath}`);
-    console.error("\nThe story worktree has not been created yet.");
-    console.error("Make sure the story was properly generated with /generate-stories.");
-    process.exit(1);
+  if (eventType === "add") {
+    return "story:added";
   }
-  if (!pluginRoot) {
-    console.error("Error: SAGA_PLUGIN_ROOT environment variable is not set.");
-    console.error("\nThis variable is required for the implementation script.");
-    console.error("When running via the /implement skill, this is set automatically.");
-    console.error("\nIf running manually, set it to the plugin root directory:");
-    console.error("  export SAGA_PLUGIN_ROOT=/path/to/plugin");
-    process.exit(1);
+  if (eventType === "unlink") {
+    return "story:removed";
   }
-  const maxCycles = options.maxCycles ?? DEFAULT_MAX_CYCLES;
-  const maxTime = options.maxTime ?? DEFAULT_MAX_TIME;
-  const model = options.model ?? DEFAULT_MODEL;
-  const isInternalSession = process.env.SAGA_INTERNAL_SESSION === "1";
-  if (!isInternalSession) {
-    const detachedCommand = buildDetachedCommand(storySlug, projectPath, {
-      maxCycles: options.maxCycles,
-      maxTime: options.maxTime,
-      model: options.model
-    });
-    try {
-      const sessionResult = await createSession(
-        storyInfo.epicSlug,
-        storyInfo.storySlug,
-        detachedCommand
-      );
-      console.log(JSON.stringify({
-        mode: "detached",
-        sessionName: sessionResult.sessionName,
-        outputFile: sessionResult.outputFile,
-        epicSlug: storyInfo.epicSlug,
-        storySlug: storyInfo.storySlug,
-        worktreePath: storyInfo.worktreePath
-      }, null, 2));
-      return;
-    } catch (error) {
-      console.error(`Error: Failed to create detached session: ${error.message}`);
-      process.exit(1);
-    }
+  return "story:changed";
+}
+function determineEventType(eventType, parsed) {
+  if (parsed.isEpicFile) {
+    return getEpicEventType(eventType);
   }
-  console.log("Starting story implementation...");
-  console.log(`  Epic: ${storyInfo.epicSlug}`);
-  console.log(`  Story: ${storyInfo.storySlug}`);
-  console.log(`  Worktree: ${storyInfo.worktreePath}`);
-  console.log("");
-  const result = await runLoop(
-    storyInfo.epicSlug,
-    storyInfo.storySlug,
-    maxCycles,
-    maxTime,
-    model,
-    projectPath,
-    pluginRoot
-  );
-  console.log(JSON.stringify(result, null, 2));
-  if (result.status === "ERROR") {
-    process.exit(1);
+  if (parsed.isStoryFile) {
+    return getStoryEventType(eventType, parsed.isMainStoryFile);
   }
+  return null;
 }
-
-// src/server/index.ts
-var import_express3 = __toESM(require("express"), 1);
-var import_http = require("http");
-var import_path6 = require("path");
-
-// src/server/routes.ts
-var import_express2 = require("express");
-
-// src/server/parser.ts
-var import_promises3 = require("fs/promises");
-var import_path2 = require("path");
-var import_gray_matter2 = __toESM(require("gray-matter"), 1);
-async function toStoryDetail(story, sagaRoot) {
-  let tasks = [];
-  try {
-    const content = await (0, import_promises3.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: validateStatus(story.status),
-    tasks,
-    archived: story.archived,
-    paths: {
-      storyMd: (0, import_path2.relative)(sagaRoot, story.storyPath),
-      ...story.journalPath ? { journalMd: (0, import_path2.relative)(sagaRoot, story.journalPath) } : {},
-      ...story.worktreePath ? { worktree: (0, import_path2.relative)(sagaRoot, story.worktreePath) } : {}
-    }
-  };
-}
-function validateStatus(status) {
-  const validStatuses = ["ready", "in_progress", "blocked", "completed"];
-  if (typeof status === "string" && validStatuses.includes(status)) {
-    return status;
-  }
-  return "ready";
-}
-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: validateTaskStatus(t.status)
-  }));
+function createDebounceKey(parsed) {
+  const { epicSlug, storySlug, archived } = parsed;
+  return storySlug ? `story:${epicSlug}:${storySlug}:${archived}` : `epic:${epicSlug}`;
 }
-function validateTaskStatus(status) {
-  const validStatuses = ["pending", "in_progress", "completed"];
-  if (typeof status === "string" && validStatuses.includes(status)) {
-    return status;
-  }
-  return "pending";
+function createChokidarWatcher(sagaRoot) {
+  const epicsDir = (0, import_node_path6.join)(sagaRoot, ".saga", "epics");
+  const archiveDir = (0, import_node_path6.join)(sagaRoot, ".saga", "archive");
+  return import_chokidar2.default.watch([epicsDir, archiveDir], {
+    persistent: true,
+    ignoreInitial: true,
+    usePolling: true,
+    interval: DEBOUNCE_DELAY_MS
+  });
 }
-async function parseStory(storyPath, epicSlug) {
-  const { join: join13 } = await import("path");
-  const { stat: stat3 } = await import("fs/promises");
-  let content;
-  try {
-    content = await (0, import_promises3.readFile)(storyPath, "utf-8");
-  } catch {
-    return null;
-  }
-  const storyDir = storyPath.replace(/\/story\.md$/, "");
-  const dirName = storyDir.split("/").pop() || "unknown";
-  let frontmatter = {};
-  try {
-    const parsed = (0, import_gray_matter2.default)(content);
-    frontmatter = parsed.data;
-  } catch {
-  }
-  const slug = frontmatter.id || frontmatter.slug || dirName;
-  const title = frontmatter.title || dirName;
-  const status = validateStatus(frontmatter.status);
-  const tasks = parseTasks(frontmatter.tasks);
-  const journalPath = join13(storyDir, "journal.md");
-  let hasJournal = false;
-  try {
-    await stat3(journalPath);
-    hasJournal = true;
-  } catch {
-  }
-  return {
-    slug,
-    epicSlug,
-    title,
-    status,
-    tasks,
-    paths: {
-      storyMd: storyPath,
-      ...hasJournal ? { journalMd: journalPath } : {}
+async function createSagaWatcher(sagaRoot) {
+  const emitter = new import_node_events.EventEmitter();
+  const debouncer = createDebouncer(DEBOUNCE_DELAY_MS);
+  const watcher = createChokidarWatcher(sagaRoot);
+  let closed = false;
+  let ready = false;
+  const handleFileEvent = (eventType, filePath) => {
+    if (closed || !ready) {
+      return;
     }
-  };
-}
-async function parseJournal(journalPath) {
-  try {
-    const content = await (0, import_promises3.readFile)(journalPath, "utf-8");
-    const entries = [];
-    const sections = content.split(/^##\s+/m).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",
-          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",
-          content: `${title}
-
-${sectionContent}`.trim()
-        });
-      } else if (headerLine.toLowerCase().startsWith("resolution:")) {
-        const title = headerLine.substring("resolution:".length).trim();
-        entries.push({
-          timestamp: "",
-          // Resolutions may not have timestamps
-          type: "resolution",
-          content: `${title}
-
-${sectionContent}`.trim()
-        });
-      }
+    const parsed = parseFilePath(filePath, sagaRoot);
+    if (!parsed) {
+      return;
     }
-    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 epics = [];
-  for (const scannedEpic of scannedEpics) {
-    const epicStories = storiesByEpic.get(scannedEpic.slug) || [];
-    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 === "in_progress").length,
-      blocked: stories.filter((s) => s.status === "blocked").length,
-      completed: stories.filter((s) => s.status === "completed").length
+    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)
     };
-    epics.push({
-      slug: scannedEpic.slug,
-      title: scannedEpic.title,
-      content: scannedEpic.content,
-      storyCounts,
-      stories,
-      path: (0, import_path2.relative)(sagaRoot, scannedEpic.epicPath)
+    debouncer.schedule(createDebounceKey(parsed), event, (e) => {
+      if (!closed) {
+        emitter.emit(e.type, e);
+      }
     });
-  }
-  return epics;
+  };
+  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 (!closed) {
+      emitter.emit("error", error);
+    }
+  });
+  await new Promise((resolve2) => {
+    watcher.on("ready", () => {
+      ready = true;
+      resolve2();
+    });
+  });
+  return {
+    on(event, listener) {
+      emitter.on(event, listener);
+      return this;
+    },
+    async close() {
+      closed = true;
+      debouncer.clear();
+      await watcher.close();
+    }
+  };
 }
 
-// src/server/routes.ts
-var import_path3 = require("path");
-
-// src/server/session-routes.ts
-var import_express = require("express");
-
-// src/lib/session-polling.ts
-var POLLING_INTERVAL_MS = 3e3;
-var pollingInterval = null;
-var currentSessions = [];
-var isFirstPoll = true;
-function getCurrentSessions() {
-  return [...currentSessions];
+// src/server/websocket.ts
+var HEARTBEAT_INTERVAL_MS = 3e4;
+function makeStoryKey(epicSlug, storySlug) {
+  return `${epicSlug}:${storySlug}`;
 }
-function startSessionPolling(broadcast) {
-  stopSessionPolling();
-  pollSessions(broadcast);
-  pollingInterval = setInterval(() => {
-    pollSessions(broadcast);
-  }, POLLING_INTERVAL_MS);
+function toEpicSummary2(epic) {
+  return {
+    slug: epic.slug,
+    title: epic.title,
+    storyCounts: epic.storyCounts,
+    path: epic.path
+  };
 }
-function stopSessionPolling() {
-  if (pollingInterval) {
-    clearInterval(pollingInterval);
-    pollingInterval = null;
+function sendToClient(ws, message) {
+  if (ws.readyState === import_ws.WebSocket.OPEN) {
+    ws.send(JSON.stringify(message));
   }
-  currentSessions = [];
-  isFirstPoll = true;
 }
-async function pollSessions(broadcast) {
-  try {
-    const sessions = await discoverSessions();
-    const hasChanges = detectChanges(sessions);
-    if (hasChanges) {
-      currentSessions = sessions;
-      isFirstPoll = false;
-      broadcast({
-        type: "sessions:updated",
-        sessions
-      });
+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);
     }
-  } catch (error) {
-    console.error("Error polling sessions:", error);
   }
 }
-async function discoverSessions() {
-  const rawSessions = await listSessions();
-  const detailedSessions = [];
-  for (const session of rawSessions) {
-    try {
-      const statusResult = await getSessionStatus(session.name);
-      const status = statusResult.running ? "running" : "completed";
-      const detailed = await buildSessionInfo(session.name, status);
-      if (detailed) {
-        detailedSessions.push(detailed);
-      }
-    } catch (error) {
-      console.error(`Error building session info for ${session.name}:`, error);
+function handleLogsSubscription(logStreamManager, ws, data, subscribe) {
+  const { sessionName } = data || {};
+  if (sessionName) {
+    if (subscribe) {
+      logStreamManager.subscribe(sessionName, ws);
+    } else {
+      logStreamManager.unsubscribe(sessionName, ws);
     }
   }
-  detailedSessions.sort((a, b) => b.startTime.getTime() - a.startTime.getTime());
-  return detailedSessions;
 }
-function detectChanges(newSessions) {
-  if (isFirstPoll) {
-    return true;
+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;
   }
-  if (newSessions.length !== currentSessions.length) {
-    return true;
+}
+function hasSubscribers(clients, storyKey) {
+  for (const [, state] of clients) {
+    if (state.subscribedStories.has(storyKey)) {
+      return true;
+    }
   }
-  const newSessionMap = /* @__PURE__ */ new Map();
-  for (const session of newSessions) {
-    newSessionMap.set(session.name, session);
+  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;
   }
-  const currentSessionMap = /* @__PURE__ */ new Map();
-  for (const session of currentSessions) {
-    currentSessionMap.set(session.name, session);
+  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);
   }
-  for (const name of newSessionMap.keys()) {
-    if (!currentSessionMap.has(name)) {
-      return true;
+  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;
     }
   }
-  for (const name of currentSessionMap.keys()) {
-    if (!newSessionMap.has(name)) {
-      return true;
+  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 {
   }
-  for (const [name, newSession] of newSessionMap) {
-    const currentSession = currentSessionMap.get(name);
-    if (currentSession && currentSession.status !== newSession.status) {
-      return true;
+}
+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 {
   }
-  return false;
 }
-
-// src/server/session-routes.ts
-function createSessionApiRouter() {
-  const router = (0, import_express.Router)();
-  router.get("/sessions", (_req, res) => {
+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 {
-      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) {
-      console.error("Error fetching sessions:", error);
-      res.status(500).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(404).json({ error: "Session not found" });
-        return;
-      }
-      res.json(session);
-    } catch (error) {
-      console.error("Error fetching session:", error);
-      res.status(500).json({ error: "Failed to fetch session" });
+      const epics = await scanSagaDirectory(sagaRoot);
+      const summaries = epics.map(toEpicSummary2);
+      broadcast({ event: "epics:updated", data: summaries });
+    } catch {
     }
-  });
-  return router;
-}
-
-// src/server/routes.ts
-async function getEpics(sagaRoot) {
-  return scanSagaDirectory(sagaRoot);
-}
-function toEpicSummary(epic) {
-  return {
-    slug: epic.slug,
-    title: epic.title,
-    storyCounts: epic.storyCounts,
-    path: epic.path
   };
-}
-function createApiRouter(sagaRoot) {
-  const router = (0, import_express2.Router)();
-  router.get("/epics", async (_req, res) => {
-    try {
-      const epics = await getEpics(sagaRoot);
-      const summaries = epics.map(toEpicSummary);
-      res.json(summaries);
-    } catch (error) {
-      console.error("Error fetching epics:", error);
-      res.status(500).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(404).json({ error: `Epic not found: ${slug}` });
-        return;
-      }
-      res.json(epic);
-    } catch (error) {
-      console.error("Error fetching epic:", error);
-      res.status(500).json({ error: "Failed to fetch epic" });
-    }
+  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", () => {
   });
-  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(404).json({ error: `Epic not found: ${epicSlug}` });
-        return;
-      }
-      const story = epic.stories.find((s) => s.slug === storySlug);
-      if (!story) {
-        res.status(404).json({ error: `Story not found: ${storySlug}` });
-        return;
-      }
-      if (story.paths.journalMd) {
-        const journalPath = (0, import_path3.join)(sagaRoot, story.paths.journalMd);
-        const journal = await parseJournal(journalPath);
-        if (journal.length > 0) {
-          story.journal = journal;
-        }
+}
+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);
       }
-      res.json(story);
-    } catch (error) {
-      console.error("Error fetching story:", error);
-      res.status(500).json({ error: "Failed to fetch story" });
     }
+    previousSessionStates = currentStates;
   });
-  router.use(createSessionApiRouter());
-  router.use((_req, res) => {
-    res.status(404).json({ error: "API endpoint not found" });
-  });
-  return router;
 }
-
-// src/server/websocket.ts
-var import_ws = require("ws");
-
-// src/server/watcher.ts
-var import_chokidar = __toESM(require("chokidar"), 1);
-var import_events = require("events");
-var import_path4 = require("path");
-function parseFilePath(filePath, sagaRoot) {
-  const relativePath = (0, import_path4.relative)(sagaRoot, filePath);
-  const parts = relativePath.split(import_path4.sep);
-  if (parts[0] !== ".saga" || parts.length < 4) {
-    return null;
-  }
-  const isArchive = parts[1] === "archive";
-  const isEpics = parts[1] === "epics";
-  if (!isArchive && !isEpics) {
-    return null;
-  }
-  const epicSlug = parts[2];
-  if (isArchive) {
-    if (parts.length >= 5) {
-      const storySlug = parts[3];
-      const fileName = parts[4];
-      if (fileName === "story.md" || fileName === "journal.md") {
-        return {
-          epicSlug,
-          storySlug,
-          archived: true,
-          isEpicFile: false,
-          isStoryFile: true,
-          isMainStoryFile: fileName === "story.md"
-        };
+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();
     }
-    return null;
-  }
-  if (parts.length === 4 && parts[3] === "epic.md") {
-    return {
-      epicSlug,
-      archived: false,
-      isEpicFile: true,
-      isStoryFile: false,
-      isMainStoryFile: false
-    };
-  }
-  if (parts.length >= 6 && parts[3] === "stories") {
-    const storySlug = parts[4];
-    const fileName = parts[5];
-    if (fileName === "story.md" || fileName === "journal.md") {
-      return {
-        epicSlug,
-        storySlug,
-        archived: false,
-        isEpicFile: false,
-        isStoryFile: true,
-        isMainStoryFile: fileName === "story.md"
-      };
-    }
-  }
-  return null;
-}
-function createDebouncer(delayMs) {
-  const pending = /* @__PURE__ */ new Map();
+  }, HEARTBEAT_INTERVAL_MS);
+}
+function createWebSocketInstance(state) {
+  const {
+    wss,
+    clients,
+    watcher,
+    logStreamManager,
+    heartbeatInterval,
+    broadcast,
+    broadcastToSubscribers
+  } = state;
   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 });
+    broadcastEpicsUpdated(epics) {
+      broadcast({ event: "epics:updated", data: epics });
     },
-    clear() {
-      for (const { timer } of pending.values()) {
-        clearTimeout(timer);
-      }
-      pending.clear();
-    }
-  };
-}
-async function createSagaWatcher(sagaRoot) {
-  const emitter = new import_events.EventEmitter();
-  const debouncer = createDebouncer(100);
-  const epicsDir = (0, import_path4.join)(sagaRoot, ".saga", "epics");
-  const archiveDir = (0, import_path4.join)(sagaRoot, ".saga", "archive");
-  const watcher = import_chokidar.default.watch([epicsDir, archiveDir], {
-    persistent: true,
-    ignoreInitial: true,
-    // Don't emit events for existing files
-    // Use polling for reliable cross-platform behavior in tests
-    // This is fine since we only watch epics/archive (~20 files), not entire .saga/ (79K+ files)
-    usePolling: true,
-    interval: 100
-  });
-  let closed = false;
-  let ready = false;
-  const handleFileEvent = (eventType, filePath) => {
-    if (closed || !ready) return;
-    const parsed = parseFilePath(filePath, sagaRoot);
-    if (!parsed) return;
-    const { epicSlug, storySlug, archived, isEpicFile, isStoryFile, isMainStoryFile } = parsed;
-    const key = storySlug ? `story:${epicSlug}:${storySlug}:${archived}` : `epic:${epicSlug}`;
-    let watcherEventType;
-    if (isEpicFile) {
-      watcherEventType = eventType === "add" ? "epic:added" : eventType === "unlink" ? "epic:removed" : "epic:changed";
-    } else if (isStoryFile) {
-      if (isMainStoryFile) {
-        watcherEventType = eventType === "add" ? "story:added" : eventType === "unlink" ? "story:removed" : "story:changed";
-      } else {
-        watcherEventType = "story:changed";
-      }
-    } else {
-      return;
-    }
-    const event = {
-      type: watcherEventType,
-      epicSlug,
-      storySlug,
-      archived,
-      path: (0, import_path4.relative)(sagaRoot, filePath)
-    };
-    debouncer.schedule(key, event, (debouncedEvent) => {
-      if (!closed) {
-        emitter.emit(debouncedEvent.type, debouncedEvent);
-      }
-    });
-  };
-  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 (!closed) {
-      emitter.emit("error", error);
-    }
-  });
-  await new Promise((resolve2) => {
-    watcher.on("ready", () => {
-      ready = true;
-      resolve2();
-    });
-  });
-  return {
-    on(event, listener) {
-      emitter.on(event, listener);
-      return this;
+    broadcastStoryUpdated(story) {
+      const key = makeStoryKey(story.epicSlug, story.slug);
+      broadcastToSubscribers(key, { event: "story:updated", data: story });
     },
     async close() {
-      closed = true;
-      debouncer.clear();
-      await watcher.close();
+      clearInterval(heartbeatInterval);
+      stopSessionPolling();
+      await logStreamManager.dispose();
+      for (const [ws] of clients) {
+        ws.close();
+      }
+      clients.clear();
+      if (watcher) {
+        await watcher.close();
+      }
+      return new Promise((resolve2, reject) => {
+        wss.close((err) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve2();
+          }
+        });
+      });
     }
   };
 }
-
-// src/server/websocket.ts
-var import_path5 = require("path");
-function makeStoryKey(epicSlug, storySlug) {
-  return `${epicSlug}:${storySlug}`;
-}
-function toEpicSummary2(epic) {
-  return {
-    slug: epic.slug,
-    title: epic.title,
-    storyCounts: epic.storyCounts,
-    path: epic.path
-  };
-}
 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 (err) {
-    console.warn("Failed to create file watcher:", err);
-  }
-  const heartbeatInterval = setInterval(() => {
-    for (const [ws, state] of clients) {
-      if (!state.isAlive) {
-        clients.delete(ws);
-        ws.terminate();
-        continue;
-      }
-      state.isAlive = false;
-      ws.ping();
-    }
-  }, 3e4);
-  function sendToClient(ws, message) {
-    if (ws.readyState === import_ws.WebSocket.OPEN) {
-      ws.send(JSON.stringify(message));
-    }
+  } catch {
   }
-  function broadcast(message) {
+  const logStreamManager = new LogStreamManager(sendLogMessage);
+  const broadcast = (message) => {
     for (const [ws] of clients) {
       sendToClient(ws, message);
     }
-  }
-  startSessionPolling((msg) => {
-    broadcast({ event: msg.type, data: msg.sessions });
-  });
-  function broadcastToSubscribers(storyKey, 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) => {
-    const state = {
-      ws,
-      subscribedStories: /* @__PURE__ */ new Set(),
-      isAlive: true
-    };
-    clients.set(ws, state);
-    ws.on("pong", () => {
-      state.isAlive = true;
-    });
-    ws.on("message", (data) => {
-      try {
-        const message = JSON.parse(data.toString());
-        if (!message.event) {
-          return;
-        }
-        switch (message.event) {
-          case "subscribe:story": {
-            const { epicSlug, storySlug } = message.data || {};
-            if (epicSlug && storySlug) {
-              const key = makeStoryKey(epicSlug, storySlug);
-              state.subscribedStories.add(key);
-            }
-            break;
-          }
-          case "unsubscribe:story": {
-            const { epicSlug, storySlug } = message.data || {};
-            if (epicSlug && storySlug) {
-              const key = makeStoryKey(epicSlug, storySlug);
-              state.subscribedStories.delete(key);
-            }
-            break;
-          }
-          default:
-            break;
-        }
-      } catch {
-      }
-    });
-    ws.on("close", () => {
-      clients.delete(ws);
-    });
-    ws.on("error", (err) => {
-      console.error("WebSocket error:", err);
-      clients.delete(ws);
-    });
+    handleNewConnection(ws, clients, logStreamManager);
   });
   if (watcher) {
-    const handleEpicChange = async () => {
-      try {
-        const epics = await scanSagaDirectory(sagaRoot);
-        const summaries = epics.map(toEpicSummary2);
-        broadcast({ event: "epics:updated", data: summaries });
-      } catch (err) {
-        console.error("Error broadcasting epic update:", err);
-      }
-    };
-    watcher.on("epic:added", handleEpicChange);
-    watcher.on("epic:changed", handleEpicChange);
-    watcher.on("epic:removed", handleEpicChange);
-    const handleStoryChange = async (event) => {
-      const { epicSlug, storySlug, archived } = event;
-      if (!storySlug) return;
-      const storyKey = makeStoryKey(epicSlug, storySlug);
-      let hasSubscribers = false;
-      for (const [, state] of clients) {
-        if (state.subscribedStories.has(storyKey)) {
-          hasSubscribers = true;
-          break;
-        }
-      }
-      if (!hasSubscribers) {
-        await handleEpicChange();
-        return;
-      }
-      try {
-        const storyPath = archived ? (0, import_path5.join)(sagaRoot, ".saga", "archive", epicSlug, storySlug, "story.md") : (0, import_path5.join)(sagaRoot, ".saga", "epics", epicSlug, "stories", storySlug, "story.md");
-        const story = await parseStory(storyPath, epicSlug);
-        if (story) {
-          story.paths.storyMd = (0, import_path5.relative)(sagaRoot, story.paths.storyMd);
-          if (story.paths.journalMd) {
-            story.paths.journalMd = (0, import_path5.relative)(sagaRoot, story.paths.journalMd);
+    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((resolve2, reject) => {
+    httpServer.on("error", reject);
+    httpServer.listen(port, () => {
+      resolve2({
+        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_fs4 = require("node:fs");
+var import_node_path9 = require("node:path");
+var import_node_process2 = __toESM(require("node:process"), 1);
+function findProjectRoot(startDir) {
+  let currentDir = startDir ?? import_node_process2.default.cwd();
+  while (true) {
+    const sagaDir = (0, import_node_path9.join)(currentDir, ".saga");
+    if ((0, import_node_fs4.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_fs4.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_process3.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_process3.default.on("SIGINT", async () => {
+      await server.close();
+      import_node_process3.default.exit(0);
+    });
+    import_node_process3.default.on("SIGTERM", async () => {
+      await server.close();
+      import_node_process3.default.exit(0);
+    });
+  } catch (_error) {
+    import_node_process3.default.exit(1);
+  }
+}
+
+// src/commands/find.ts
+var import_node_process4 = __toESM(require("node:process"), 1);
+
+// src/utils/finder.ts
+var import_node_fs5 = require("node:fs");
+var import_node_path10 = require("node:path");
+var import_fuse = __toESM(require("fuse.js"), 1);
+var FUZZY_THRESHOLD = 0.3;
+var MATCH_THRESHOLD = 0.6;
+var SCORE_SIMILARITY_THRESHOLD = 0.1;
+var DEFAULT_CONTEXT_MAX_LENGTH = 300;
+var ELLIPSIS_LENGTH = 3;
+var CONTEXT_SECTION_REGEX = /##\s*Context\s*\n+([\s\S]*?)(?=\n##|Z|$)/i;
+function extractContext(body, maxLength = DEFAULT_CONTEXT_MAX_LENGTH) {
+  const contextMatch = body.match(CONTEXT_SECTION_REGEX);
+  if (!contextMatch) {
+    return "";
+  }
+  const context = contextMatch[1].trim();
+  if (context.length > maxLength) {
+    return `${context.slice(0, maxLength - ELLIPSIS_LENGTH)}...`;
+  }
+  return context;
+}
+function normalize(str) {
+  return str.toLowerCase().replace(/[-_]/g, " ");
+}
+function toStoryInfo(story) {
+  return {
+    slug: story.slug,
+    title: story.title,
+    status: story.status,
+    context: extractContext(story.body),
+    epicSlug: story.epicSlug,
+    storyPath: story.storyPath,
+    worktreePath: story.worktreePath || ""
+  };
+}
+function processFuzzyResults(results) {
+  if (results.length === 1) {
+    return { found: true, data: results[0].item };
+  }
+  const bestScore = results[0].score ?? 0;
+  const similarMatches = results.filter(
+    (r) => (r.score ?? 0) - bestScore <= SCORE_SIMILARITY_THRESHOLD
+  );
+  if (similarMatches.length > 1) {
+    return { found: false, matches: similarMatches.map((r) => r.item) };
+  }
+  if (bestScore <= FUZZY_THRESHOLD) {
+    return { found: true, data: results[0].item };
+  }
+  return { found: false, matches: results.map((r) => r.item) };
+}
+function getEpicSlugs(projectPath) {
+  const epicsDir = (0, import_node_path10.join)(projectPath, ".saga", "epics");
+  return (0, import_node_fs5.readdirSync)(epicsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+}
+function findExactEpicMatch(epicSlugs, queryNormalized) {
+  for (const slug of epicSlugs) {
+    if (slug.toLowerCase() === queryNormalized) {
+      return { slug };
+    }
+  }
+  return null;
+}
+function fuzzySearchEpics(epicSlugs, query) {
+  const epics = epicSlugs.map((slug) => ({ slug }));
+  const fuse = new import_fuse.default(epics, {
+    keys: ["slug"],
+    threshold: MATCH_THRESHOLD,
+    includeScore: true
+  });
+  const results = fuse.search(query);
+  if (results.length === 0) {
+    return { found: false, error: `No epic found matching '${query}'` };
+  }
+  return processFuzzyResults(results);
+}
+function findEpic(projectPath, query) {
+  if (!epicsDirectoryExists(projectPath)) {
+    return { found: false, error: "No .saga/epics/ directory found" };
+  }
+  const epicSlugs = getEpicSlugs(projectPath);
+  if (epicSlugs.length === 0) {
+    return { found: false, error: `No epic found matching '${query}'` };
+  }
+  const queryNormalized = query.toLowerCase().replace(/_/g, "-");
+  const exactMatch = findExactEpicMatch(epicSlugs, queryNormalized);
+  if (exactMatch) {
+    return { found: true, data: exactMatch };
+  }
+  return fuzzySearchEpics(epicSlugs, query);
+}
+function findExactStoryMatch(allStories, queryNormalized) {
+  for (const story of allStories) {
+    if (normalize(story.slug) === queryNormalized) {
+      return story;
+    }
+  }
+  return null;
+}
+function fuzzySearchStories(allStories, query) {
+  const fuse = new import_fuse.default(allStories, {
+    keys: [
+      { name: "slug", weight: 2 },
+      // Prioritize slug matches
+      { name: "title", weight: 1 }
+    ],
+    threshold: MATCH_THRESHOLD,
+    includeScore: true
+  });
+  const results = fuse.search(query);
+  if (results.length === 0) {
+    return { found: false, error: `No story found matching '${query}'` };
+  }
+  return processFuzzyResults(results);
+}
+async function loadAndFilterStories(projectPath, query, options) {
+  const scannedStories = await scanAllStories(projectPath);
+  if (scannedStories.length === 0) {
+    return { found: false, error: `No story found matching '${query}'` };
+  }
+  let allStories = scannedStories.map(toStoryInfo);
+  if (options.status) {
+    allStories = allStories.filter((story) => story.status === options.status);
+    if (allStories.length === 0) {
+      return {
+        found: false,
+        error: `No story found matching '${query}' with status '${options.status}'`
+      };
+    }
+  }
+  return allStories;
+}
+async function findStory(projectPath, query, options = {}) {
+  if (!(worktreesDirectoryExists(projectPath) || epicsDirectoryExists(projectPath))) {
+    return {
+      found: false,
+      error: "No .saga/worktrees/ or .saga/epics/ directory found. Run /generate-stories first."
+    };
+  }
+  const storiesOrError = await loadAndFilterStories(projectPath, query, options);
+  if (!Array.isArray(storiesOrError)) {
+    return storiesOrError;
+  }
+  const allStories = storiesOrError;
+  const queryNormalized = normalize(query);
+  const exactMatch = findExactStoryMatch(allStories, queryNormalized);
+  if (exactMatch) {
+    return { found: true, data: exactMatch };
+  }
+  return fuzzySearchStories(allStories, query);
+}
+
+// src/commands/find.ts
+async function findCommand(query, options) {
+  let projectPath;
+  try {
+    projectPath = resolveProjectPath(options.path);
+  } catch (_error) {
+    import_node_process4.default.exit(1);
+  }
+  const type = options.type ?? "story";
+  let result;
+  if (type === "epic") {
+    result = findEpic(projectPath, query);
+  } else {
+    result = await findStory(projectPath, query, { status: options.status });
+  }
+  console.log(JSON.stringify(result, null, 2));
+  if (!result.found) {
+    import_node_process4.default.exit(1);
+  }
+}
+
+// src/commands/implement.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs6 = require("node:fs");
+var import_node_path11 = require("node:path");
+var import_node_process5 = __toESM(require("node:process"), 1);
+var DEFAULT_MAX_CYCLES = 10;
+var DEFAULT_MAX_TIME = 60;
+var DEFAULT_MODEL = "opus";
+var VALID_STATUSES = /* @__PURE__ */ new Set(["ONGOING", "FINISH", "BLOCKED"]);
+var WORKER_PROMPT_RELATIVE = "worker-prompt.md";
+var MS_PER_SECOND = 1e3;
+var MS_PER_MINUTE = 6e4;
+var SECONDS_PER_MINUTE = 60;
+var ROUNDING_PRECISION = 100;
+var WORKER_OUTPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    status: {
+      type: "string",
+      enum: ["ONGOING", "FINISH", "BLOCKED"]
+    },
+    summary: {
+      type: "string",
+      description: "What was accomplished this session"
+    },
+    blocker: {
+      type: ["string", "null"],
+      description: "Brief description if BLOCKED, null otherwise"
+    }
+  },
+  required: ["status", "summary"]
+};
+async function findStory2(projectPath, storySlug) {
+  const result = await findStory(projectPath, storySlug);
+  if (!result.found) {
+    return null;
+  }
+  return {
+    epicSlug: result.data.epicSlug,
+    storySlug: result.data.slug,
+    storyPath: result.data.storyPath,
+    worktreePath: result.data.worktreePath
+  };
+}
+function computeStoryPath(worktree, epicSlug, storySlug) {
+  return (0, import_node_path11.join)(worktree, ".saga", "epics", epicSlug, "stories", storySlug, "story.md");
+}
+function validateStoryFiles(worktree, epicSlug, storySlug) {
+  if (!(0, import_node_fs6.existsSync)(worktree)) {
+    return {
+      valid: false,
+      error: `Worktree not found at ${worktree}
+
+The story worktree has not been created yet. This can happen if:
+1. The story was generated but the worktree wasn't set up
+2. The worktree was deleted or moved
+
+To create the worktree, use: /task-resume ${storySlug}`
+    };
+  }
+  const storyPath = computeStoryPath(worktree, epicSlug, storySlug);
+  if (!(0, import_node_fs6.existsSync)(storyPath)) {
+    return {
+      valid: false,
+      error: `story.md not found in worktree.
+
+Expected location: ${storyPath}
+
+The worktree exists but the story definition file is missing.
+This may indicate an incomplete story setup.`
+    };
+  }
+  return { valid: true };
+}
+function getSkillRoot(pluginRoot) {
+  return (0, import_node_path11.join)(pluginRoot, "skills", "execute-story");
+}
+function checkCommandExists(command) {
+  try {
+    const result = (0, import_node_child_process2.spawnSync)("which", [command], { encoding: "utf-8" });
+    if (result.status === 0 && result.stdout.trim()) {
+      return { exists: true, path: result.stdout.trim() };
+    }
+    return { exists: false };
+  } catch {
+    return { exists: false };
+  }
+}
+function checkPluginRoot(pluginRoot) {
+  if (pluginRoot) {
+    return { name: "SAGA_PLUGIN_ROOT", path: pluginRoot, passed: true };
+  }
+  return { name: "SAGA_PLUGIN_ROOT", passed: false, error: "Environment variable not set" };
+}
+function checkClaudeCli() {
+  const claudeCheck = checkCommandExists("claude");
+  return {
+    name: "claude CLI",
+    path: claudeCheck.path,
+    passed: claudeCheck.exists,
+    error: claudeCheck.exists ? void 0 : "Command not found in PATH"
+  };
+}
+function checkWorkerPrompt(pluginRoot) {
+  const skillRoot = getSkillRoot(pluginRoot);
+  const workerPromptPath = (0, import_node_path11.join)(skillRoot, WORKER_PROMPT_RELATIVE);
+  const exists = (0, import_node_fs6.existsSync)(workerPromptPath);
+  return {
+    name: "Worker prompt",
+    path: workerPromptPath,
+    passed: exists,
+    error: exists ? void 0 : "File not found"
+  };
+}
+function checkWorktreeExists(worktreePath) {
+  const exists = (0, import_node_fs6.existsSync)(worktreePath);
+  return {
+    name: "Worktree exists",
+    path: worktreePath,
+    passed: exists,
+    error: exists ? void 0 : "Directory not found"
+  };
+}
+function checkStoryMdExists(storyInfo) {
+  if (!(0, import_node_fs6.existsSync)(storyInfo.worktreePath)) {
+    return null;
+  }
+  const storyMdPath = computeStoryPath(
+    storyInfo.worktreePath,
+    storyInfo.epicSlug,
+    storyInfo.storySlug
+  );
+  const exists = (0, import_node_fs6.existsSync)(storyMdPath);
+  return {
+    name: "story.md in worktree",
+    path: storyMdPath,
+    passed: exists,
+    error: exists ? void 0 : "File not found"
+  };
+}
+function runDryRun(storyInfo, _projectPath, pluginRoot) {
+  const checks = [];
+  checks.push(checkPluginRoot(pluginRoot));
+  checks.push(checkClaudeCli());
+  if (pluginRoot) {
+    checks.push(checkWorkerPrompt(pluginRoot));
+  }
+  checks.push({
+    name: "Story found",
+    path: `${storyInfo.storySlug} (epic: ${storyInfo.epicSlug})`,
+    passed: true
+  });
+  checks.push(checkWorktreeExists(storyInfo.worktreePath));
+  const storyMdCheck = checkStoryMdExists(storyInfo);
+  if (storyMdCheck) {
+    checks.push(storyMdCheck);
+  }
+  const allPassed = checks.every((check) => check.passed);
+  return {
+    success: allPassed,
+    checks,
+    story: {
+      epicSlug: storyInfo.epicSlug,
+      storySlug: storyInfo.storySlug,
+      worktreePath: storyInfo.worktreePath
+    }
+  };
+}
+function formatCheckResult(check) {
+  const icon = check.passed ? "\u2713" : "\u2717";
+  const status = check.passed ? "OK" : "FAILED";
+  const lines = [];
+  if (check.passed) {
+    const pathSuffix = check.path ? ` (${check.path})` : "";
+    lines.push(`  ${icon} ${check.name}: ${status}${pathSuffix}`);
+  } else {
+    const errorSuffix = check.error ? ` - ${check.error}` : "";
+    lines.push(`  ${icon} ${check.name}: ${status}${errorSuffix}`);
+    if (check.path) {
+      lines.push(`      Path: ${check.path}`);
+    }
+  }
+  return lines;
+}
+function printDryRunResults(result) {
+  console.log("Dry Run: Implement Story Validation");
+  console.log("");
+  console.log("Checks:");
+  for (const check of result.checks) {
+    for (const line of formatCheckResult(check)) {
+      console.log(line);
+    }
+  }
+  console.log("");
+  const summary = result.success ? "All checks passed. Ready to implement." : "Some checks failed. Please resolve the issues above.";
+  console.log(summary);
+}
+function loadWorkerPrompt(pluginRoot) {
+  const skillRoot = getSkillRoot(pluginRoot);
+  const promptPath = (0, import_node_path11.join)(skillRoot, WORKER_PROMPT_RELATIVE);
+  if (!(0, import_node_fs6.existsSync)(promptPath)) {
+    throw new Error(`Worker prompt not found at ${promptPath}`);
+  }
+  return (0, import_node_fs6.readFileSync)(promptPath, "utf-8");
+}
+var SCOPE_VALIDATED_TOOLS = ["Read", "Write", "Edit", "Glob", "Grep"];
+var HOOK_PRE_TOOL_USE = "PreToolUse";
+function buildScopeSettings() {
+  const hookCommand = "npx @saga-ai/cli scope-validator";
+  return {
+    hooks: {
+      [HOOK_PRE_TOOL_USE]: [
+        {
+          matcher: SCOPE_VALIDATED_TOOLS.join("|"),
+          hooks: [hookCommand]
+        }
+      ]
+    }
+  };
+}
+function formatAssistantContent(content) {
+  for (const block of content) {
+    const blockData = block;
+    if (blockData.type === "text" && blockData.text) {
+      return blockData.text;
+    }
+    if (blockData.type === "tool_use") {
+      return `[Tool: ${blockData.name}]`;
+    }
+  }
+  return null;
+}
+function formatStreamLine(line) {
+  try {
+    const data = JSON.parse(line);
+    if (data.type === "assistant" && data.message?.content) {
+      return formatAssistantContent(data.message.content);
+    }
+    if (data.type === "system" && data.subtype === "init") {
+      return `[Session started: ${data.session_id}]`;
+    }
+    if (data.type === "result") {
+      const status = data.subtype === "success" ? "completed" : "failed";
+      return `
+[Worker ${status} in ${Math.round(data.duration_ms / MS_PER_SECOND)}s]`;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function extractStructuredOutputFromToolCall(lines) {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try {
+      const data = JSON.parse(lines[i]);
+      if (data.type === "assistant" && data.message?.content) {
+        for (const block of data.message.content) {
+          if (block.type === "tool_use" && block.name === "StructuredOutput") {
+            return block.input;
           }
-          story.archived = archived;
-          if (story.paths.journalMd) {
-            const journalPath = (0, import_path5.join)(sagaRoot, story.paths.journalMd);
-            const journal = await parseJournal(journalPath);
-            if (journal.length > 0) {
-              story.journal = journal;
-            }
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function validateAndExtractOutput(output) {
+  if (!VALID_STATUSES.has(output.status)) {
+    throw new Error(`Invalid status: ${output.status}`);
+  }
+  return {
+    status: output.status,
+    summary: output.summary || "",
+    blocker: output.blocker ?? null
+  };
+}
+function processResultLine(data, lines) {
+  if (data.is_error) {
+    throw new Error(`Worker failed: ${data.result || "Unknown error"}`);
+  }
+  let output = data.structured_output;
+  if (!output) {
+    output = extractStructuredOutputFromToolCall(lines) ?? void 0;
+  }
+  if (!output) {
+    throw new Error("Worker result missing structured_output");
+  }
+  return validateAndExtractOutput(output);
+}
+function parseStreamingResult(buffer) {
+  const lines = buffer.split("\n").filter((line) => line.trim());
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try {
+      const data = JSON.parse(lines[i]);
+      if (data.type === "result") {
+        return processResultLine(data, lines);
+      }
+    } catch (e) {
+      if (e instanceof Error && e.message.startsWith("Worker")) {
+        throw e;
+      }
+    }
+  }
+  throw new Error("No result found in worker output");
+}
+function spawnWorkerAsync(prompt, model, settings, workingDir) {
+  return new Promise((resolve2, reject) => {
+    let buffer = "";
+    const args = [
+      "-p",
+      prompt,
+      "--model",
+      model,
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--json-schema",
+      JSON.stringify(WORKER_OUTPUT_SCHEMA),
+      "--settings",
+      JSON.stringify(settings),
+      "--dangerously-skip-permissions"
+    ];
+    const child = (0, import_node_child_process2.spawn)("claude", args, {
+      cwd: workingDir,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    child.stdout.on("data", (chunk) => {
+      const text = chunk.toString();
+      buffer += text;
+      const lines = text.split("\n");
+      for (const line of lines) {
+        if (line.trim()) {
+          const formatted = formatStreamLine(line);
+          if (formatted) {
+            import_node_process5.default.stdout.write(formatted);
           }
-          broadcastToSubscribers(storyKey, { event: "story:updated", data: story });
         }
-        await handleEpicChange();
-      } catch (err) {
-        console.error("Error broadcasting story update:", err);
       }
-    };
-    watcher.on("story:added", handleStoryChange);
-    watcher.on("story:changed", handleStoryChange);
-    watcher.on("story:removed", handleStoryChange);
-    watcher.on("error", (err) => {
-      console.error("Watcher error:", err);
     });
+    child.stderr.on("data", (chunk) => {
+      import_node_process5.default.stderr.write(chunk);
+    });
+    child.on("error", (err) => {
+      reject(new Error(`Failed to spawn worker: ${err.message}`));
+    });
+    child.on("close", (_code) => {
+      import_node_process5.default.stdout.write("\n");
+      try {
+        const result = parseStreamingResult(buffer);
+        resolve2(result);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+}
+function createErrorResult(epicSlug, storySlug, summary, cycles, elapsedMinutes) {
+  return {
+    status: "ERROR",
+    summary,
+    cycles,
+    elapsedMinutes,
+    blocker: null,
+    epicSlug,
+    storySlug
+  };
+}
+function validateLoopResources(worktree, epicSlug, storySlug, pluginRoot) {
+  const validation = validateStoryFiles(worktree, epicSlug, storySlug);
+  if (!validation.valid) {
+    return { valid: false, error: validation.error || "Story validation failed" };
+  }
+  try {
+    const workerPrompt = loadWorkerPrompt(pluginRoot);
+    return { valid: true, workerPrompt };
+  } catch (e) {
+    return { valid: false, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+function buildLoopResult(epicSlug, storySlug, finalStatus, summaries, cycles, elapsedMinutes, lastBlocker) {
+  const combinedSummary = summaries.length === 1 ? summaries[0] : summaries.join(" | ");
+  return {
+    status: finalStatus,
+    summary: combinedSummary,
+    cycles,
+    elapsedMinutes: Math.round(elapsedMinutes * ROUNDING_PRECISION) / ROUNDING_PRECISION,
+    blocker: lastBlocker,
+    epicSlug,
+    storySlug
+  };
+}
+async function executeWorkerCycle(config, state) {
+  if (Date.now() - config.startTime >= config.maxTimeMs) {
+    state.finalStatus = "TIMEOUT";
+    return { continue: false };
+  }
+  if (state.cycles >= config.maxCycles) {
+    return { continue: false };
+  }
+  state.cycles += 1;
+  try {
+    const parsed = await spawnWorkerAsync(
+      config.workerPrompt,
+      config.model,
+      config.settings,
+      config.worktree
+    );
+    state.summaries.push(parsed.summary);
+    if (parsed.status === "FINISH") {
+      state.finalStatus = "FINISH";
+      return { continue: false };
+    }
+    if (parsed.status === "BLOCKED") {
+      state.finalStatus = "BLOCKED";
+      state.lastBlocker = parsed.blocker || null;
+      return { continue: false };
+    }
+    return { continue: true };
+  } catch (e) {
+    const elapsed = (Date.now() - config.startTime) / MS_PER_MINUTE;
+    return {
+      continue: false,
+      result: createErrorResult(
+        config.epicSlug,
+        config.storySlug,
+        e instanceof Error ? e.message : String(e),
+        state.cycles,
+        elapsed
+      )
+    };
+  }
+}
+function executeWorkerLoop(workerPrompt, model, settings, worktree, maxCycles, maxTimeMs, startTime, epicSlug, storySlug) {
+  const config = {
+    workerPrompt,
+    model,
+    settings,
+    worktree,
+    maxCycles,
+    maxTimeMs,
+    startTime,
+    epicSlug,
+    storySlug
+  };
+  const state = { summaries: [], cycles: 0, lastBlocker: null, finalStatus: null };
+  const runNextCycle = async () => {
+    const cycleResult = await executeWorkerCycle(config, state);
+    if (cycleResult.result) {
+      return cycleResult.result;
+    }
+    if (cycleResult.continue) {
+      return runNextCycle();
+    }
+    return state;
+  };
+  return runNextCycle();
+}
+async function runLoop(epicSlug, storySlug, maxCycles, maxTime, model, projectDir, pluginRoot) {
+  const worktree = (0, import_node_path11.join)(projectDir, ".saga", "worktrees", epicSlug, storySlug);
+  const resources = validateLoopResources(worktree, epicSlug, storySlug, pluginRoot);
+  if (!resources.valid) {
+    return createErrorResult(epicSlug, storySlug, resources.error, 0, 0);
+  }
+  const settings = buildScopeSettings();
+  const startTime = Date.now();
+  const maxTimeMs = maxTime * SECONDS_PER_MINUTE * MS_PER_SECOND;
+  const result = await executeWorkerLoop(
+    resources.workerPrompt,
+    model,
+    settings,
+    worktree,
+    maxCycles,
+    maxTimeMs,
+    startTime,
+    epicSlug,
+    storySlug
+  );
+  if ("status" in result && result.status === "ERROR") {
+    return result;
+  }
+  const state = result;
+  const finalStatus = state.finalStatus ?? "MAX_CYCLES";
+  const elapsedMinutes = (Date.now() - startTime) / MS_PER_MINUTE;
+  return buildLoopResult(
+    epicSlug,
+    storySlug,
+    finalStatus,
+    state.summaries,
+    state.cycles,
+    elapsedMinutes,
+    state.lastBlocker
+  );
+}
+function buildDetachedCommand(storySlug, projectPath, options) {
+  const parts = ["saga", "implement", storySlug];
+  parts.push("--path", projectPath);
+  if (options.maxCycles !== void 0) {
+    parts.push("--max-cycles", String(options.maxCycles));
+  }
+  if (options.maxTime !== void 0) {
+    parts.push("--max-time", String(options.maxTime));
+  }
+  if (options.model !== void 0) {
+    parts.push("--model", options.model);
+  }
+  return shellEscapeArgs(parts);
+}
+function handleDryRun(storyInfo, projectPath, pluginRoot) {
+  const dryRunResult = runDryRun(storyInfo, projectPath, pluginRoot);
+  printDryRunResults(dryRunResult);
+  import_node_process5.default.exit(dryRunResult.success ? 0 : 1);
+}
+async function handleDetachedMode(storySlug, storyInfo, projectPath, options) {
+  const detachedCommand = buildDetachedCommand(storySlug, projectPath, {
+    maxCycles: options.maxCycles,
+    maxTime: options.maxTime,
+    model: options.model
+  });
+  try {
+    const sessionInfo = await createSession(
+      storyInfo.epicSlug,
+      storyInfo.storySlug,
+      detachedCommand
+    );
+    console.log(JSON.stringify(sessionInfo, null, 2));
+  } catch (error) {
+    console.error(
+      `Error creating session: ${error instanceof Error ? error.message : String(error)}`
+    );
+    import_node_process5.default.exit(1);
+  }
+}
+async function handleInternalSession(storyInfo, projectPath, pluginRoot, options) {
+  const maxCycles = options.maxCycles ?? DEFAULT_MAX_CYCLES;
+  const maxTime = options.maxTime ?? DEFAULT_MAX_TIME;
+  const model = options.model ?? DEFAULT_MODEL;
+  console.log("Starting story implementation...");
+  console.log(`Story: ${storyInfo.storySlug} (epic: ${storyInfo.epicSlug})`);
+  console.log(`Max cycles: ${maxCycles}, Max time: ${maxTime}min, Model: ${model}`);
+  console.log("");
+  const result = await runLoop(
+    storyInfo.epicSlug,
+    storyInfo.storySlug,
+    maxCycles,
+    maxTime,
+    model,
+    projectPath,
+    pluginRoot
+  );
+  if (result.status === "ERROR") {
+    console.error(`Error: ${result.summary}`);
+    import_node_process5.default.exit(1);
+  }
+  console.log(`
+Implementation ${result.status}: ${result.summary}`);
+}
+async function implementCommand(storySlug, options) {
+  let projectPath;
+  try {
+    projectPath = resolveProjectPath(options.path);
+  } catch (_error) {
+    console.error("Error: SAGA project not found. Run saga init first or use --path option.");
+    import_node_process5.default.exit(1);
+  }
+  const storyInfo = await findStory2(projectPath, storySlug);
+  if (!storyInfo) {
+    console.error(`Error: Story '${storySlug}' not found in project.`);
+    console.error("Use /generate-stories to create stories for an epic first.");
+    import_node_process5.default.exit(1);
+  }
+  const pluginRoot = import_node_process5.default.env.SAGA_PLUGIN_ROOT;
+  if (options.dryRun) {
+    handleDryRun(storyInfo, projectPath, pluginRoot);
+  }
+  if (!pluginRoot) {
+    console.error("Error: SAGA_PLUGIN_ROOT environment variable is not set.");
+    console.error("This is required to find the worker prompt template.");
+    import_node_process5.default.exit(1);
+  }
+  if (!(0, import_node_fs6.existsSync)(storyInfo.worktreePath)) {
+    console.error(`Error: Worktree not found at ${storyInfo.worktreePath}`);
+    import_node_process5.default.exit(1);
+  }
+  const isInternalSession = import_node_process5.default.env.SAGA_INTERNAL_SESSION === "1";
+  if (isInternalSession) {
+    await handleInternalSession(storyInfo, projectPath, pluginRoot, options);
+  } else {
+    await handleDetachedMode(storySlug, storyInfo, projectPath, options);
+  }
+}
+
+// src/commands/init.ts
+var import_node_fs7 = require("node:fs");
+var import_node_path12 = require("node:path");
+var import_node_process6 = __toESM(require("node:process"), 1);
+var WORKTREES_PATTERN = ".saga/worktrees/";
+function runInitDryRun(targetPath) {
+  const sagaDir = (0, import_node_path12.join)(targetPath, ".saga");
+  const sagaExists = (0, import_node_fs7.existsSync)(sagaDir);
+  const directories = [
+    { name: "epics", path: (0, import_node_path12.join)(sagaDir, "epics") },
+    { name: "archive", path: (0, import_node_path12.join)(sagaDir, "archive") },
+    { name: "worktrees", path: (0, import_node_path12.join)(sagaDir, "worktrees") }
+  ].map((dir) => ({
+    path: dir.path,
+    exists: (0, import_node_fs7.existsSync)(dir.path),
+    action: (0, import_node_fs7.existsSync)(dir.path) ? "exists (skip)" : "will create"
+  }));
+  const gitignorePath = (0, import_node_path12.join)(targetPath, ".gitignore");
+  const gitignoreExists = (0, import_node_fs7.existsSync)(gitignorePath);
+  let hasPattern = false;
+  if (gitignoreExists) {
+    const content = (0, import_node_fs7.readFileSync)(gitignorePath, "utf-8");
+    hasPattern = content.includes(WORKTREES_PATTERN);
+  }
+  let gitignoreAction;
+  if (!gitignoreExists) {
+    gitignoreAction = "will create with worktrees pattern";
+  } else if (hasPattern) {
+    gitignoreAction = "already has pattern (skip)";
+  } else {
+    gitignoreAction = "will append worktrees pattern";
   }
   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();
-      for (const [ws] of clients) {
-        ws.close();
-      }
-      clients.clear();
-      if (watcher) {
-        await watcher.close();
-      }
-      return new Promise((resolve2, reject) => {
-        wss.close((err) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve2();
-          }
-        });
-      });
+    targetPath,
+    sagaExists,
+    directories,
+    gitignore: {
+      path: gitignorePath,
+      exists: gitignoreExists,
+      hasPattern,
+      action: gitignoreAction
     }
   };
 }
-
-// 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_path6.join)(__dirname, "client");
-  const indexHtmlPath = (0, import_path6.join)(clientDistPath, "index.html");
-  app.use(import_express3.default.static(clientDistPath));
-  app.get("/{*splat}", (_req, res) => {
-    res.sendFile("index.html", { root: clientDistPath });
-  });
-  return app;
+function printInitDryRunResults(result) {
+  console.log("Dry Run: SAGA Initialization");
+  console.log(`Target: ${result.targetPath}`);
+  console.log("");
+  console.log("Directories:");
+  for (const dir of result.directories) {
+    const icon = dir.exists ? "-" : "+";
+    console.log(`  ${icon} ${dir.path}: ${dir.action}`);
+  }
+  console.log("");
+  console.log(".gitignore:");
+  console.log(`  ${result.gitignore.action}`);
+  console.log("");
+  console.log("No changes made.");
 }
-async function startServer(config) {
-  const port = config.port ?? DEFAULT_PORT;
-  const app = createApp(config.sagaRoot);
-  const httpServer = (0, import_http.createServer)(app);
-  const wsServer = await createWebSocketServer(httpServer, config.sagaRoot);
-  return new Promise((resolve2, reject) => {
-    httpServer.on("error", reject);
-    httpServer.listen(port, () => {
-      console.log(`SAGA Dashboard server running on http://localhost:${port}`);
-      resolve2({
-        app,
-        httpServer,
-        wsServer,
-        port,
-        close: async () => {
-          await wsServer.close();
-          return new Promise((resolveClose, rejectClose) => {
-            httpServer.close((err) => {
-              if (err) {
-                rejectClose(err);
-              } else {
-                resolveClose();
-              }
-            });
-          });
-        }
-      });
-    });
-  });
+function resolveTargetPath(explicitPath) {
+  if (explicitPath) {
+    return explicitPath;
+  }
+  const existingRoot = findProjectRoot();
+  if (existingRoot) {
+    return existingRoot;
+  }
+  return import_node_process6.default.cwd();
 }
-
-// src/commands/dashboard.ts
-async function dashboardCommand(options) {
-  let projectPath;
-  try {
-    projectPath = resolveProjectPath(options.path);
-  } catch (error) {
-    console.error(`Error: ${error.message}`);
-    process.exit(1);
+function createDirectoryStructure(projectRoot) {
+  const sagaDir = (0, import_node_path12.join)(projectRoot, ".saga");
+  (0, import_node_fs7.mkdirSync)((0, import_node_path12.join)(sagaDir, "epics"), { recursive: true });
+  (0, import_node_fs7.mkdirSync)((0, import_node_path12.join)(sagaDir, "archive"), { recursive: true });
+  (0, import_node_fs7.mkdirSync)((0, import_node_path12.join)(sagaDir, "worktrees"), { recursive: true });
+}
+function updateGitignore(projectRoot) {
+  const gitignorePath = (0, import_node_path12.join)(projectRoot, ".gitignore");
+  if ((0, import_node_fs7.existsSync)(gitignorePath)) {
+    const content = (0, import_node_fs7.readFileSync)(gitignorePath, "utf-8");
+    if (content.includes(WORKTREES_PATTERN)) {
+    } else {
+      (0, import_node_fs7.appendFileSync)(
+        gitignorePath,
+        `
+# Claude Tasks - Worktrees (git worktree isolation for stories)
+${WORKTREES_PATTERN}
+`
+      );
+    }
+  } else {
+    (0, import_node_fs7.writeFileSync)(
+      gitignorePath,
+      `# Claude Tasks - Worktrees (git worktree isolation for stories)
+${WORKTREES_PATTERN}
+`
+    );
   }
-  try {
-    const server = await startServer({
-      sagaRoot: projectPath,
-      port: options.port
-    });
-    console.log(`Project: ${projectPath}`);
-    process.on("SIGINT", async () => {
-      console.log("\nShutting down dashboard server...");
-      await server.close();
-      process.exit(0);
-    });
-    process.on("SIGTERM", async () => {
-      await server.close();
-      process.exit(0);
-    });
-  } catch (error) {
-    console.error(`Error starting server: ${error.message}`);
-    process.exit(1);
+}
+function initCommand(options) {
+  if (options.path) {
+    if (!(0, import_node_fs7.existsSync)(options.path)) {
+      console.error(`Error: Path does not exist: ${options.path}`);
+      import_node_process6.default.exit(1);
+    }
+    if (!(0, import_node_fs7.statSync)(options.path).isDirectory()) {
+      console.error(`Error: Path is not a directory: ${options.path}`);
+      import_node_process6.default.exit(1);
+    }
+  }
+  const targetPath = resolveTargetPath(options.path);
+  if (options.dryRun) {
+    const dryRunResult = runInitDryRun(targetPath);
+    printInitDryRunResults(dryRunResult);
+    return;
   }
+  createDirectoryStructure(targetPath);
+  updateGitignore(targetPath);
+  console.log(`Created .saga/ at ${targetPath}`);
 }
 
 // src/commands/scope-validator.ts
-var import_node_path6 = require("node:path");
+var import_node_path13 = require("node:path");
+var import_node_process7 = __toESM(require("node:process"), 1);
+var FILE_PATH_WIDTH = 50;
+var EPIC_STORY_WIDTH = 43;
+var REASON_WIDTH = 56;
 function getFilePathFromInput(hookInput) {
   try {
     const data = JSON.parse(hookInput);
@@ -2179,10 +2701,10 @@ function isArchiveAccess(path) {
   return path.includes(".saga/archive");
 }
 function isWithinWorktree(filePath, worktreePath) {
-  const absoluteFilePath = (0, import_node_path6.resolve)(filePath);
-  const absoluteWorktree = (0, import_node_path6.resolve)(worktreePath);
-  const relativePath = (0, import_node_path6.relative)(absoluteWorktree, absoluteFilePath);
-  if (relativePath.startsWith("..") || (0, import_node_path6.resolve)(relativePath) === relativePath) {
+  const absoluteFilePath = (0, import_node_path13.resolve)(filePath);
+  const absoluteWorktree = (0, import_node_path13.resolve)(worktreePath);
+  const relativePath = (0, import_node_path13.relative)(absoluteWorktree, absoluteFilePath);
+  if (relativePath.startsWith("..") || (0, import_node_path13.resolve)(relativePath) === relativePath) {
     return false;
   }
   return true;
@@ -2200,106 +2722,108 @@ function checkStoryAccess(path, allowedEpic, allowedStory) {
     return true;
   }
   const pathEpic = parts[epicsIdx + 1];
-  if (parts.length > epicsIdx + 3 && parts[epicsIdx + 2] === "stories") {
-    const pathStory = parts[epicsIdx + 3];
+  const storiesFolderIndex = 2;
+  const storySlugIndex = 3;
+  if (parts.length > epicsIdx + storySlugIndex && parts[epicsIdx + storiesFolderIndex] === "stories") {
+    const pathStory = parts[epicsIdx + storySlugIndex];
     return pathEpic === allowedEpic && pathStory === allowedStory;
-  } else {
-    return pathEpic === allowedEpic;
   }
+  return pathEpic === allowedEpic;
 }
 function printScopeViolation(filePath, epicSlug, storySlug, worktreePath, reason) {
-  console.error(`SCOPE VIOLATION: ${reason}
-
-Attempted path: ${filePath}
-
-Your scope is limited to:
-  Worktree: ${worktreePath}
-  Epic: ${epicSlug}
-  Story: ${storySlug}
-  Allowed story files: .saga/epics/${epicSlug}/stories/${storySlug}/
-
-Workers cannot access files outside the worktree directory.
-To access other stories, start a new /implement session for that story.`);
-}
-async function scopeValidatorCommand() {
-  const worktreePath = process.env.SAGA_PROJECT_DIR || "";
-  const epicSlug = process.env.SAGA_EPIC_SLUG || "";
-  const storySlug = process.env.SAGA_STORY_SLUG || "";
-  if (!worktreePath || !epicSlug || !storySlug) {
-    console.error(
-      "ERROR: scope-validator requires SAGA_PROJECT_DIR, SAGA_EPIC_SLUG, and SAGA_STORY_SLUG environment variables"
-    );
-    process.exit(2);
-  }
+  const message = [
+    "",
+    "\u256D\u2500 Scope Violation \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E",
+    "\u2502                                                           \u2502",
+    `\u2502  File: ${filePath.slice(0, FILE_PATH_WIDTH).padEnd(FILE_PATH_WIDTH)}\u2502`,
+    "\u2502                                                           \u2502",
+    `\u2502  ${reason.split("\n")[0].padEnd(REASON_WIDTH)}\u2502`,
+    "\u2502                                                           \u2502",
+    "\u2502  Current scope:                                           \u2502",
+    `\u2502    Epic:     ${epicSlug.slice(0, EPIC_STORY_WIDTH).padEnd(EPIC_STORY_WIDTH)}\u2502`,
+    `\u2502    Story:    ${storySlug.slice(0, EPIC_STORY_WIDTH).padEnd(EPIC_STORY_WIDTH)}\u2502`,
+    `\u2502    Worktree: ${worktreePath.slice(0, EPIC_STORY_WIDTH).padEnd(EPIC_STORY_WIDTH)}\u2502`,
+    "\u2502                                                           \u2502",
+    "\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F",
+    ""
+  ].join("\n");
+  import_node_process7.default.stderr.write(message);
+}
+async function readStdinInput() {
   const chunks = [];
-  for await (const chunk of process.stdin) {
+  for await (const chunk of import_node_process7.default.stdin) {
     chunks.push(chunk);
   }
-  const toolInput = Buffer.concat(chunks).toString("utf-8");
-  const filePath = getFilePathFromInput(toolInput);
-  if (!filePath) {
-    process.exit(0);
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function getScopeEnvironment() {
+  const worktreePath = import_node_process7.default.env.SAGA_PROJECT_DIR || "";
+  const epicSlug = import_node_process7.default.env.SAGA_EPIC_SLUG || "";
+  const storySlug = import_node_process7.default.env.SAGA_STORY_SLUG || "";
+  if (!(worktreePath && epicSlug && storySlug)) {
+    return null;
   }
+  return { worktreePath, epicSlug, storySlug };
+}
+function validatePath(filePath, worktreePath, epicSlug, storySlug) {
   const normPath = normalizePath(filePath);
   if (!isWithinWorktree(normPath, worktreePath)) {
-    printScopeViolation(
-      filePath,
-      epicSlug,
-      storySlug,
-      worktreePath,
-      "Access outside worktree blocked\nReason: Workers can only access files within their assigned worktree directory."
-    );
-    process.exit(2);
+    return "Access outside worktree blocked\nReason: Workers can only access files within their assigned worktree directory.";
   }
   if (isArchiveAccess(normPath)) {
-    printScopeViolation(
-      filePath,
-      epicSlug,
-      storySlug,
-      worktreePath,
-      "Access to archive folder blocked\nReason: The archive folder contains completed stories and is read-only during execution."
-    );
-    process.exit(2);
+    return "Access to archive folder blocked\nReason: The archive folder contains completed stories and is read-only during execution.";
   }
   if (!checkStoryAccess(normPath, epicSlug, storySlug)) {
-    printScopeViolation(
-      filePath,
-      epicSlug,
-      storySlug,
-      worktreePath,
-      "Access to other story blocked\nReason: Workers can only access their assigned story's files."
-    );
-    process.exit(2);
+    return "Access to other story blocked\nReason: Workers can only access their assigned story's files.";
+  }
+  return null;
+}
+async function scopeValidatorCommand() {
+  const env = getScopeEnvironment();
+  if (!env) {
+    import_node_process7.default.exit(2);
+  }
+  const toolInput = await readStdinInput();
+  const filePath = getFilePathFromInput(toolInput);
+  if (!filePath) {
+    import_node_process7.default.exit(0);
   }
-  process.exit(0);
+  const violation = validatePath(filePath, env.worktreePath, env.epicSlug, env.storySlug);
+  if (violation) {
+    printScopeViolation(filePath, env.epicSlug, env.storySlug, env.worktreePath, violation);
+    import_node_process7.default.exit(2);
+  }
+  import_node_process7.default.exit(0);
 }
 
-// src/commands/find.ts
-async function findCommand(query, options) {
-  let projectPath;
+// src/commands/sessions/index.ts
+var import_node_process8 = __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 {
-    projectPath = resolveProjectPath(options.path);
+    await streamLogs(sessionName);
   } catch (error) {
-    console.log(JSON.stringify({ found: false, error: error.message }));
-    process.exit(1);
-  }
-  const type = options.type ?? "story";
-  let result;
-  if (type === "epic") {
-    result = findEpic(projectPath, query);
-  } else {
-    result = await findStory(projectPath, query, { status: options.status });
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    import_node_process8.default.exit(1);
   }
+}
+async function sessionsKillCommand(sessionName) {
+  const result = await killSession(sessionName);
   console.log(JSON.stringify(result, null, 2));
-  if (!result.found) {
-    process.exit(1);
-  }
 }
 
 // src/commands/worktree.ts
-var import_node_path7 = require("node:path");
-var import_node_fs6 = require("node:fs");
 var import_node_child_process3 = require("node:child_process");
+var import_node_fs8 = require("node:fs");
+var import_node_path14 = require("node:path");
+var import_node_process9 = __toESM(require("node:process"), 1);
 function runGitCommand(args, cwd) {
   try {
     const output = (0, import_node_child_process3.execSync)(`git ${args.join(" ")}`, {
@@ -2309,7 +2833,8 @@ function runGitCommand(args, cwd) {
     });
     return { success: true, output: output.trim() };
   } catch (error) {
-    const stderr = error.stderr?.toString().trim() || error.message;
+    const execError = error;
+    const stderr = execError.stderr?.toString().trim() || execError.message || String(error);
     return { success: false, output: stderr };
   }
 }
@@ -2318,10 +2843,7 @@ function branchExists(branchName, cwd) {
   return result.success;
 }
 function getMainBranch(cwd) {
-  const result = runGitCommand(
-    ["symbolic-ref", "refs/remotes/origin/HEAD"],
-    cwd
-  );
+  const result = runGitCommand(["symbolic-ref", "refs/remotes/origin/HEAD"], cwd);
   if (result.success) {
     return result.output.replace("refs/remotes/origin/", "");
   }
@@ -2329,20 +2851,14 @@ function getMainBranch(cwd) {
 }
 function createWorktree(projectPath, epicSlug, storySlug) {
   const branchName = `story-${storySlug}-epic-${epicSlug}`;
-  const worktreePath = (0, import_node_path7.join)(
-    projectPath,
-    ".saga",
-    "worktrees",
-    epicSlug,
-    storySlug
-  );
+  const worktreePath = (0, import_node_path14.join)(projectPath, ".saga", "worktrees", epicSlug, storySlug);
   if (branchExists(branchName, projectPath)) {
     return {
       success: false,
       error: `Branch already exists: ${branchName}`
     };
   }
-  if ((0, import_node_fs6.existsSync)(worktreePath)) {
+  if ((0, import_node_fs8.existsSync)(worktreePath)) {
     return {
       success: false,
       error: `Worktree directory already exists: ${worktreePath}`
@@ -2360,8 +2876,8 @@ function createWorktree(projectPath, epicSlug, storySlug) {
       error: `Failed to create branch: ${createBranchResult.output}`
     };
   }
-  const worktreeParent = (0, import_node_path7.join)(projectPath, ".saga", "worktrees", epicSlug);
-  (0, import_node_fs6.mkdirSync)(worktreeParent, { recursive: true });
+  const worktreeParent = (0, import_node_path14.join)(projectPath, ".saga", "worktrees", epicSlug);
+  (0, import_node_fs8.mkdirSync)(worktreeParent, { recursive: true });
   const createWorktreeResult = runGitCommand(
     ["worktree", "add", worktreePath, branchName],
     projectPath
@@ -2378,47 +2894,28 @@ function createWorktree(projectPath, epicSlug, storySlug) {
     branch: branchName
   };
 }
-async function worktreeCommand(epicSlug, storySlug, options) {
+function worktreeCommand(epicSlug, storySlug, options) {
   let projectPath;
   try {
     projectPath = resolveProjectPath(options.path);
   } catch (error) {
-    const result2 = { success: false, error: error.message };
-    console.log(JSON.stringify(result2));
-    process.exit(1);
+    const result2 = {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+    console.log(JSON.stringify(result2, null, 2));
+    import_node_process9.default.exit(1);
   }
   const result = createWorktree(projectPath, epicSlug, storySlug);
-  console.log(JSON.stringify(result));
+  console.log(JSON.stringify(result, null, 2));
   if (!result.success) {
-    process.exit(1);
-  }
-}
-
-// src/commands/sessions/index.ts
-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)}`);
-    process.exit(1);
+    import_node_process9.default.exit(1);
   }
 }
-async function sessionsKillCommand(sessionName) {
-  const result = await killSession(sessionName);
-  console.log(JSON.stringify(result, null, 2));
-}
 
 // src/cli.ts
-var packageJsonPath = (0, import_node_path8.join)(__dirname, "..", "package.json");
-var packageJson = JSON.parse((0, import_node_fs7.readFileSync)(packageJsonPath, "utf-8"));
+var packageJsonPath = (0, import_node_path15.join)(__dirname, "..", "package.json");
+var packageJson = JSON.parse((0, import_node_fs9.readFileSync)(packageJsonPath, "utf-8"));
 var program = new import_commander.Command();
 program.name("saga").description("CLI 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)");
@@ -2426,16 +2923,18 @@ program.command("init").description("Initialize .saga/ directory structure").opt
   const globalOpts = program.opts();
   await initCommand({ path: globalOpts.path, dryRun: options.dryRun });
 });
-program.command("implement <story-slug>").description("Run story implementation").option("--max-cycles <n>", "Maximum number of implementation cycles", parseInt).option("--max-time <n>", "Maximum time in minutes", parseInt).option("--model <name>", "Model to use for implementation").option("--dry-run", "Validate dependencies without running implementation").action(async (storySlug, options) => {
-  const globalOpts = program.opts();
-  await implementCommand(storySlug, {
-    path: globalOpts.path,
-    maxCycles: options.maxCycles,
-    maxTime: options.maxTime,
-    model: options.model,
-    dryRun: options.dryRun
-  });
-});
+program.command("implement <story-slug>").description("Run story implementation").option("--max-cycles <n>", "Maximum number of implementation cycles", Number.parseInt).option("--max-time <n>", "Maximum time in minutes", Number.parseInt).option("--model <name>", "Model to use for implementation").option("--dry-run", "Validate dependencies without running implementation").action(
+  async (storySlug, options) => {
+    const globalOpts = program.opts();
+    await implementCommand(storySlug, {
+      path: globalOpts.path,
+      maxCycles: options.maxCycles,
+      maxTime: options.maxTime,
+      model: options.model,
+      dryRun: options.dryRun
+    });
+  }
+);
 program.command("find <query>").description("Find an epic or story by slug/title").option("--type <type>", "Type to search for: epic or story (default: story)").option("--status <status>", "Filter stories by status (e.g., ready, in-progress, completed)").action(async (query, options) => {
   const globalOpts = program.opts();
   await findCommand(query, {
@@ -2448,7 +2947,7 @@ program.command("worktree <epic-slug> <story-slug>").description("Create git wor
   const globalOpts = program.opts();
   await worktreeCommand(epicSlug, storySlug, { path: globalOpts.path });
 });
-program.command("dashboard").description("Start the dashboard server").option("--port <n>", "Port to run the server on (default: 3847)", parseInt).action(async (options) => {
+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,
@@ -2473,6 +2972,6 @@ sessionsCommand.command("kill <name>").description("Terminate a session").action
 });
 program.on("command:*", (operands) => {
   console.error(`error: unknown command '${operands[0]}'`);
-  process.exit(1);
+  import_node_process10.default.exit(1);
 });
 program.parse();