@saga-ai/cli 2.12.1 → 2.14.0

package/dist/cli.cjs

@@ -25,8 +25,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/cli.ts
 var import_commander = require("commander");
-var import_node_path8 = require("node:path");
-var import_node_fs7 = require("node:fs");
+var import_node_path9 = require("node:path");
+var import_node_fs8 = require("node:fs");
 
 // src/commands/init.ts
 var import_node_path2 = require("node:path");
@@ -583,6 +583,7 @@ async function findStory(projectPath, query, options = {}) {
 // 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 OUTPUT_DIR = "/tmp/saga-sessions";
 function shellEscape(str) {
@@ -741,6 +742,70 @@ async function killSession(sessionName) {
     killed: result.status === 0
   };
 }
+function parseSessionName(name) {
+  if (!name || !name.startsWith("saga__")) {
+    return null;
+  }
+  const parts = name.split("__");
+  if (parts.length !== 4) {
+    return null;
+  }
+  const [, epicSlug, storySlug, pid] = parts;
+  if (!epicSlug || !storySlug || !pid) {
+    return null;
+  }
+  return {
+    epicSlug,
+    storySlug
+  };
+}
+async function buildSessionInfo(name, status) {
+  const parsed = parseSessionName(name);
+  if (!parsed) {
+    return null;
+  }
+  const outputFile = (0, import_node_path4.join)(OUTPUT_DIR, `${name}.out`);
+  const outputAvailable = (0, import_node_fs4.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 {
+    }
+  }
+  return {
+    name,
+    epicSlug: parsed.epicSlug,
+    storySlug: parsed.storySlug,
+    status,
+    outputFile,
+    outputAvailable,
+    startTime,
+    endTime,
+    outputPreview
+  };
+}
 
 // src/commands/implement.ts
 var DEFAULT_MAX_CYCLES = 10;
@@ -1276,21 +1341,21 @@ Searched in: ${(0, import_node_path5.join)(projectPath, ".saga", "worktrees")}`)
 }
 
 // src/server/index.ts
-var import_express2 = __toESM(require("express"), 1);
+var import_express3 = __toESM(require("express"), 1);
 var import_http = require("http");
 var import_path6 = require("path");
 
 // src/server/routes.ts
-var import_express = require("express");
+var import_express2 = require("express");
 
 // src/server/parser.ts
-var import_promises2 = require("fs/promises");
+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_promises2.readFile)(story.storyPath, "utf-8");
+    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 {
@@ -1335,11 +1400,11 @@ function validateTaskStatus(status) {
   return "pending";
 }
 async function parseStory(storyPath, epicSlug) {
-  const { join: join13 } = await import("path");
-  const { stat: stat2 } = await import("fs/promises");
+  const { join: join14 } = await import("path");
+  const { stat: stat4 } = await import("fs/promises");
   let content;
   try {
-    content = await (0, import_promises2.readFile)(storyPath, "utf-8");
+    content = await (0, import_promises3.readFile)(storyPath, "utf-8");
   } catch {
     return null;
   }
@@ -1355,10 +1420,10 @@ async function parseStory(storyPath, epicSlug) {
   const title = frontmatter.title || dirName;
   const status = validateStatus(frontmatter.status);
   const tasks = parseTasks(frontmatter.tasks);
-  const journalPath = join13(storyDir, "journal.md");
+  const journalPath = join14(storyDir, "journal.md");
   let hasJournal = false;
   try {
-    await stat2(journalPath);
+    await stat4(journalPath);
     hasJournal = true;
   } catch {
   }
@@ -1376,7 +1441,7 @@ async function parseStory(storyPath, epicSlug) {
 }
 async function parseJournal(journalPath) {
   try {
-    const content = await (0, import_promises2.readFile)(journalPath, "utf-8");
+    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) {
@@ -1455,6 +1520,142 @@ async function scanSagaDirectory(sagaRoot) {
 
 // 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];
+}
+function startSessionPolling(broadcast) {
+  stopSessionPolling();
+  pollSessions(broadcast);
+  pollingInterval = setInterval(() => {
+    pollSessions(broadcast);
+  }, POLLING_INTERVAL_MS);
+}
+function stopSessionPolling() {
+  if (pollingInterval) {
+    clearInterval(pollingInterval);
+    pollingInterval = null;
+  }
+  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
+      });
+    }
+  } 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);
+    }
+  }
+  detailedSessions.sort((a, b) => b.startTime.getTime() - a.startTime.getTime());
+  return detailedSessions;
+}
+function detectChanges(newSessions) {
+  if (isFirstPoll) {
+    return true;
+  }
+  if (newSessions.length !== currentSessions.length) {
+    return true;
+  }
+  const newSessionMap = /* @__PURE__ */ new Map();
+  for (const session of newSessions) {
+    newSessionMap.set(session.name, session);
+  }
+  const currentSessionMap = /* @__PURE__ */ new Map();
+  for (const session of currentSessions) {
+    currentSessionMap.set(session.name, session);
+  }
+  for (const name of newSessionMap.keys()) {
+    if (!currentSessionMap.has(name)) {
+      return true;
+    }
+  }
+  for (const name of currentSessionMap.keys()) {
+    if (!newSessionMap.has(name)) {
+      return true;
+    }
+  }
+  for (const [name, newSession] of newSessionMap) {
+    const currentSession = currentSessionMap.get(name);
+    if (currentSession && currentSession.status !== newSession.status) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/server/session-routes.ts
+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) {
+      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" });
+    }
+  });
+  return router;
+}
+
+// src/server/routes.ts
 async function getEpics(sagaRoot) {
   return scanSagaDirectory(sagaRoot);
 }
@@ -1467,7 +1668,7 @@ function toEpicSummary(epic) {
   };
 }
 function createApiRouter(sagaRoot) {
-  const router = (0, import_express.Router)();
+  const router = (0, import_express2.Router)();
   router.get("/epics", async (_req, res) => {
     try {
       const epics = await getEpics(sagaRoot);
@@ -1520,6 +1721,7 @@ function createApiRouter(sagaRoot) {
       res.status(500).json({ error: "Failed to fetch story" });
     }
   });
+  router.use(createSessionApiRouter());
   router.use((_req, res) => {
     res.status(404).json({ error: "API endpoint not found" });
   });
@@ -1685,6 +1887,290 @@ async function createSagaWatcher(sagaRoot) {
 
 // src/server/websocket.ts
 var import_path5 = require("path");
+
+// src/lib/log-stream-manager.ts
+var import_chokidar2 = __toESM(require("chokidar"), 1);
+var import_node_fs6 = require("node:fs");
+var import_promises4 = require("node:fs/promises");
+var import_node_path6 = require("node:path");
+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(sendToClient) {
+    this.sendToClient = sendToClient;
+  }
+  /**
+   * 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_path6.join)(OUTPUT_DIR, `${sessionName}.out`);
+    if (!(0, import_node_fs6.existsSync)(outputFile)) {
+      this.sendToClient(ws, {
+        type: "logs:error",
+        sessionName,
+        error: `Output file not found: ${outputFile}`
+      });
+      return;
+    }
+    const content = await (0, import_promises4.readFile)(outputFile, "utf-8");
+    this.sendToClient(ws, {
+      type: "logs:data",
+      sessionName,
+      data: content,
+      isInitial: true,
+      isComplete: false
+    });
+    this.filePositions.set(sessionName, content.length);
+    let subs = this.subscriptions.get(sessionName);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.subscriptions.set(sessionName, subs);
+    }
+    subs.add(ws);
+    if (!this.watchers.has(sessionName)) {
+      this.createWatcher(sessionName, outputFile);
+    }
+  }
+  /**
+   * Create a chokidar file watcher for a session's output file
+   *
+   * The watcher detects changes and triggers incremental content delivery
+   * to all subscribed clients.
+   *
+   * @param sessionName - The session name
+   * @param outputFile - Path to the session output file
+   */
+  createWatcher(sessionName, outputFile) {
+    const watcher = import_chokidar2.default.watch(outputFile, {
+      persistent: true,
+      awaitWriteFinish: false
+    });
+    watcher.on("change", async () => {
+      await this.sendIncrementalContent(sessionName, outputFile);
+    });
+    this.watchers.set(sessionName, watcher);
+  }
+  /**
+   * Clean up a watcher and associated state for a session
+   *
+   * Closes the file watcher and removes all tracking state for the session.
+   * Should be called when the last subscriber unsubscribes or disconnects.
+   *
+   * @param sessionName - The session to clean up
+   */
+  cleanupWatcher(sessionName) {
+    const watcher = this.watchers.get(sessionName);
+    if (watcher) {
+      watcher.close();
+      this.watchers.delete(sessionName);
+    }
+    this.filePositions.delete(sessionName);
+    this.subscriptions.delete(sessionName);
+  }
+  /**
+   * Send incremental content to all subscribed clients for a session
+   *
+   * Reads from the last known position to the end of the file and sends
+   * the new content to all subscribed clients.
+   *
+   * @param sessionName - The session name
+   * @param outputFile - Path to the session output file
+   */
+  async sendIncrementalContent(sessionName, outputFile) {
+    const lastPosition = this.filePositions.get(sessionName) ?? 0;
+    const fileStat = await (0, import_promises4.stat)(outputFile);
+    const currentSize = fileStat.size;
+    if (currentSize <= lastPosition) {
+      return;
+    }
+    const newContent = await this.readFromPosition(outputFile, lastPosition, currentSize);
+    this.filePositions.set(sessionName, currentSize);
+    const subs = this.subscriptions.get(sessionName);
+    if (subs) {
+      const message = {
+        type: "logs:data",
+        sessionName,
+        data: newContent,
+        isInitial: false,
+        isComplete: false
+      };
+      for (const ws of subs) {
+        this.sendToClient(ws, message);
+      }
+    }
+  }
+  /**
+   * Read file content from a specific position
+   *
+   * @param filePath - Path to the file
+   * @param start - Starting byte position
+   * @param end - Ending byte position
+   * @returns The content read from the file
+   */
+  readFromPosition(filePath, start, end) {
+    return new Promise((resolve2, reject) => {
+      let content = "";
+      const stream = (0, import_node_fs6.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);
+    });
+  }
+  /**
+   * 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_path6.join)(OUTPUT_DIR, `${sessionName}.out`);
+    let finalContent = "";
+    try {
+      if ((0, import_node_fs6.existsSync)(outputFile)) {
+        const lastPosition = this.filePositions.get(sessionName) ?? 0;
+        const fileStat = await (0, import_promises4.stat)(outputFile);
+        const currentSize = fileStat.size;
+        if (currentSize > lastPosition) {
+          finalContent = await this.readFromPosition(outputFile, lastPosition, currentSize);
+        }
+      }
+    } catch {
+    }
+    const message = {
+      type: "logs:data",
+      sessionName,
+      data: finalContent,
+      isInitial: false,
+      isComplete: true
+    };
+    for (const ws of subs) {
+      this.sendToClient(ws, message);
+    }
+    this.cleanupWatcher(sessionName);
+  }
+  /**
+   * Clean up all watchers and subscriptions
+   *
+   * Call this when shutting down the server.
+   */
+  async dispose() {
+    const closePromises = [];
+    for (const [, watcher] of this.watchers) {
+      closePromises.push(watcher.close());
+    }
+    await Promise.all(closePromises);
+    this.watchers.clear();
+    this.filePositions.clear();
+    this.subscriptions.clear();
+  }
+};
+
+// src/server/websocket.ts
 function makeStoryKey(epicSlug, storySlug) {
   return `${epicSlug}:${storySlug}`;
 }
@@ -1721,11 +2207,30 @@ async function createWebSocketServer(httpServer, sagaRoot) {
       ws.send(JSON.stringify(message));
     }
   }
+  function sendLogMessage(ws, message) {
+    if (ws.readyState === import_ws.WebSocket.OPEN) {
+      ws.send(JSON.stringify({ event: message.type, data: message }));
+    }
+  }
+  const logStreamManager = new LogStreamManager(sendLogMessage);
   function broadcast(message) {
     for (const [ws] of clients) {
       sendToClient(ws, message);
     }
   }
+  let previousSessionStates = /* @__PURE__ */ new Map();
+  startSessionPolling((msg) => {
+    broadcast({ event: msg.type, data: msg.sessions });
+    const currentStates = /* @__PURE__ */ new Map();
+    for (const session of msg.sessions) {
+      currentStates.set(session.name, session.status);
+      const previousStatus = previousSessionStates.get(session.name);
+      if (previousStatus === "running" && session.status === "completed") {
+        logStreamManager.notifySessionCompleted(session.name);
+      }
+    }
+    previousSessionStates = currentStates;
+  });
   function broadcastToSubscribers(storyKey, message) {
     for (const [ws, state] of clients) {
       if (state.subscribedStories.has(storyKey)) {
@@ -1766,6 +2271,20 @@ async function createWebSocketServer(httpServer, sagaRoot) {
             }
             break;
           }
+          case "subscribe:logs": {
+            const { sessionName } = message.data || {};
+            if (sessionName) {
+              logStreamManager.subscribe(sessionName, ws);
+            }
+            break;
+          }
+          case "unsubscribe:logs": {
+            const { sessionName } = message.data || {};
+            if (sessionName) {
+              logStreamManager.unsubscribe(sessionName, ws);
+            }
+            break;
+          }
           default:
             break;
         }
@@ -1774,10 +2293,12 @@ async function createWebSocketServer(httpServer, sagaRoot) {
     });
     ws.on("close", () => {
       clients.delete(ws);
+      logStreamManager.handleClientDisconnect(ws);
     });
     ws.on("error", (err) => {
       console.error("WebSocket error:", err);
       clients.delete(ws);
+      logStreamManager.handleClientDisconnect(ws);
     });
   });
   if (watcher) {
@@ -1848,6 +2369,8 @@ async function createWebSocketServer(httpServer, sagaRoot) {
     },
     async close() {
       clearInterval(heartbeatInterval);
+      stopSessionPolling();
+      await logStreamManager.dispose();
       for (const [ws] of clients) {
         ws.close();
       }
@@ -1871,8 +2394,8 @@ async function createWebSocketServer(httpServer, sagaRoot) {
 // src/server/index.ts
 var DEFAULT_PORT = 3847;
 function createApp(sagaRoot) {
-  const app = (0, import_express2.default)();
-  app.use(import_express2.default.json());
+  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");
@@ -1885,7 +2408,7 @@ function createApp(sagaRoot) {
   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_express2.default.static(clientDistPath));
+  app.use(import_express3.default.static(clientDistPath));
   app.get("/{*splat}", (_req, res) => {
     res.sendFile("index.html", { root: clientDistPath });
   });
@@ -1953,7 +2476,7 @@ async function dashboardCommand(options) {
 }
 
 // src/commands/scope-validator.ts
-var import_node_path6 = require("node:path");
+var import_node_path7 = require("node:path");
 function getFilePathFromInput(hookInput) {
   try {
     const data = JSON.parse(hookInput);
@@ -1973,10 +2496,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_path7.resolve)(filePath);
+  const absoluteWorktree = (0, import_node_path7.resolve)(worktreePath);
+  const relativePath = (0, import_node_path7.relative)(absoluteWorktree, absoluteFilePath);
+  if (relativePath.startsWith("..") || (0, import_node_path7.resolve)(relativePath) === relativePath) {
     return false;
   }
   return true;
@@ -2091,8 +2614,8 @@ async function findCommand(query, options) {
 }
 
 // src/commands/worktree.ts
-var import_node_path7 = require("node:path");
-var import_node_fs6 = require("node:fs");
+var import_node_path8 = require("node:path");
+var import_node_fs7 = require("node:fs");
 var import_node_child_process3 = require("node:child_process");
 function runGitCommand(args, cwd) {
   try {
@@ -2123,7 +2646,7 @@ function getMainBranch(cwd) {
 }
 function createWorktree(projectPath, epicSlug, storySlug) {
   const branchName = `story-${storySlug}-epic-${epicSlug}`;
-  const worktreePath = (0, import_node_path7.join)(
+  const worktreePath = (0, import_node_path8.join)(
     projectPath,
     ".saga",
     "worktrees",
@@ -2136,7 +2659,7 @@ function createWorktree(projectPath, epicSlug, storySlug) {
       error: `Branch already exists: ${branchName}`
     };
   }
-  if ((0, import_node_fs6.existsSync)(worktreePath)) {
+  if ((0, import_node_fs7.existsSync)(worktreePath)) {
     return {
       success: false,
       error: `Worktree directory already exists: ${worktreePath}`
@@ -2154,8 +2677,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_path8.join)(projectPath, ".saga", "worktrees", epicSlug);
+  (0, import_node_fs7.mkdirSync)(worktreeParent, { recursive: true });
   const createWorktreeResult = runGitCommand(
     ["worktree", "add", worktreePath, branchName],
     projectPath
@@ -2211,8 +2734,8 @@ async function sessionsKillCommand(sessionName) {
 }
 
 // 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_path9.join)(__dirname, "..", "package.json");
+var packageJson = JSON.parse((0, import_node_fs8.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)");