@herbcaudill/ralph 1.0.1 → 1.0.2

package/dist/index.js

@@ -1,10 +1,2405 @@
-import { program } from "./cli.js";
-/**  Parse and execute the CLI program with command-line arguments. */
-export const run = () => {
-    program.parse(process.argv);
+// src/cli.ts
+import { Command } from "commander";
+import { render } from "ink";
+import React12 from "react";
+
+// src/components/App.tsx
+import React10 from "react";
+
+// src/components/SessionRunner.tsx
+import React5, { useState as useState3, useEffect as useEffect3, useRef } from "react";
+import { Box as Box3, Text as Text5, useApp, Static, useInput as useInput2 } from "ink";
+import Spinner from "ink-spinner";
+
+// src/components/EnhancedTextInput.tsx
+import React, { useState, useEffect } from "react";
+import { Text, useInput } from "ink";
+import chalk from "chalk";
+
+// src/components/findPreviousWordBoundary.ts
+var findPreviousWordBoundary = (text, cursorOffset) => {
+  if (cursorOffset <= 0) return 0;
+  let pos = cursorOffset;
+  while (pos > 0 && /\s/.test(text[pos - 1])) {
+    pos--;
+  }
+  while (pos > 0 && !/\s/.test(text[pos - 1])) {
+    pos--;
+  }
+  return pos;
+};
+
+// src/components/findNextWordBoundary.ts
+var findNextWordBoundary = (text, cursorOffset) => {
+  if (cursorOffset >= text.length) return text.length;
+  let pos = cursorOffset;
+  while (pos < text.length && /\s/.test(text[pos])) {
+    pos++;
+  }
+  while (pos < text.length && !/\s/.test(text[pos])) {
+    pos++;
+  }
+  return pos;
+};
+
+// src/components/EnhancedTextInput.tsx
+var EnhancedTextInput = ({
+  value: originalValue,
+  placeholder = "",
+  focus = true,
+  showCursor = true,
+  onChange,
+  onSubmit
+}) => {
+  const [cursorOffset, setCursorOffset] = useState(originalValue.length);
+  useEffect(() => {
+    if (!focus || !showCursor) {
+      return;
+    }
+    if (cursorOffset > originalValue.length) {
+      setCursorOffset(originalValue.length);
+    }
+  }, [originalValue, focus, showCursor, cursorOffset]);
+  let renderedValue = originalValue;
+  let renderedPlaceholder = placeholder ? chalk.grey(placeholder) : void 0;
+  if (showCursor && focus) {
+    renderedPlaceholder = placeholder.length > 0 ? chalk.inverse(placeholder[0]) + chalk.grey(placeholder.slice(1)) : chalk.inverse(" ");
+    renderedValue = originalValue.length > 0 ? "" : chalk.inverse(" ");
+    for (let i = 0; i < originalValue.length; i++) {
+      const char = originalValue[i];
+      renderedValue += i === cursorOffset ? chalk.inverse(char) : char;
+    }
+    if (originalValue.length > 0 && cursorOffset === originalValue.length) {
+      renderedValue += chalk.inverse(" ");
+    }
+  }
+  useInput(
+    (input, key) => {
+      if (key.upArrow || key.downArrow || key.ctrl && input === "c" || key.tab) {
+        return;
+      }
+      if (key.return) {
+        onSubmit?.(originalValue);
+        return;
+      }
+      let nextCursorOffset = cursorOffset;
+      let nextValue = originalValue;
+      if (key.meta && key.leftArrow) {
+        nextCursorOffset = findPreviousWordBoundary(originalValue, cursorOffset);
+      } else if (key.meta && key.rightArrow) {
+        nextCursorOffset = findNextWordBoundary(originalValue, cursorOffset);
+      } else if (key.ctrl && input === "a") {
+        nextCursorOffset = 0;
+      } else if (key.ctrl && input === "e") {
+        nextCursorOffset = originalValue.length;
+      } else if (key.ctrl && input === "k") {
+        nextValue = originalValue.slice(0, cursorOffset);
+      } else if (key.ctrl && input === "u") {
+        nextValue = originalValue.slice(cursorOffset);
+        nextCursorOffset = 0;
+      } else if (key.ctrl && input === "w") {
+        const wordStart = findPreviousWordBoundary(originalValue, cursorOffset);
+        nextValue = originalValue.slice(0, wordStart) + originalValue.slice(cursorOffset);
+        nextCursorOffset = wordStart;
+      } else if (key.meta && key.backspace) {
+        const wordStart = findPreviousWordBoundary(originalValue, cursorOffset);
+        nextValue = originalValue.slice(0, wordStart) + originalValue.slice(cursorOffset);
+        nextCursorOffset = wordStart;
+      } else if (key.leftArrow) {
+        if (showCursor && cursorOffset > 0) {
+          nextCursorOffset = cursorOffset - 1;
+        }
+      } else if (key.rightArrow) {
+        if (showCursor && cursorOffset < originalValue.length) {
+          nextCursorOffset = cursorOffset + 1;
+        }
+      } else if (key.backspace || key.delete) {
+        if (cursorOffset > 0) {
+          nextValue = originalValue.slice(0, cursorOffset - 1) + originalValue.slice(cursorOffset);
+          nextCursorOffset = cursorOffset - 1;
+        }
+      } else if (input && !key.ctrl && !key.meta) {
+        nextValue = originalValue.slice(0, cursorOffset) + input + originalValue.slice(cursorOffset);
+        nextCursorOffset = cursorOffset + input.length;
+      }
+      nextCursorOffset = Math.max(0, Math.min(nextCursorOffset, nextValue.length));
+      setCursorOffset(nextCursorOffset);
+      if (nextValue !== originalValue) {
+        onChange(nextValue);
+      }
+    },
+    { isActive: focus }
+  );
+  return /* @__PURE__ */ React.createElement(Text, null, placeholder ? originalValue.length > 0 ? renderedValue : renderedPlaceholder : renderedValue);
+};
+
+// src/components/SessionRunner.tsx
+import { appendFileSync, writeFileSync as writeFileSync2, readFileSync as readFileSync5, existsSync as existsSync8 } from "fs";
+import { join as join10, basename } from "path";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+// src/lib/addTodo.ts
+import { execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+// src/lib/insertTodo.ts
+var insertTodo = (content, description) => {
+  const lines = content.split("\n");
+  const todoHeaderIndex = lines.findIndex((line) => /^###?\s*To\s*do/i.test(line));
+  if (todoHeaderIndex === -1) {
+    return `### To do
+
+- [ ] ${description}
+
+${content}`;
+  }
+  let insertIndex = todoHeaderIndex + 1;
+  while (insertIndex < lines.length && lines[insertIndex].trim() === "") {
+    insertIndex++;
+  }
+  lines.splice(insertIndex, 0, `- [ ] ${description}`);
+  return lines.join("\n");
+};
+
+// src/lib/addTodo.ts
+var addTodo = (description, cwd = process.cwd()) => {
+  const todoPath = join(cwd, ".ralph", "todo.md");
+  const content = existsSync(todoPath) ? readFileSync(todoPath, "utf-8") : "";
+  const newContent = insertTodo(content, description);
+  writeFileSync(todoPath, newContent);
+  let indexContent = "";
+  try {
+    indexContent = execSync(
+      "git show :0:.ralph/todo.md 2>/dev/null || git show HEAD:.ralph/todo.md 2>/dev/null || echo ''",
+      {
+        cwd,
+        encoding: "utf-8"
+      }
+    );
+  } catch {
+    indexContent = "";
+  }
+  const indexWithTodo = insertTodo(indexContent, description);
+  const blobHash = execSync("git hash-object -w --stdin", {
+    cwd,
+    encoding: "utf-8",
+    input: indexWithTodo
+  }).trim();
+  execSync(`git update-index --add --cacheinfo 100644,${blobHash},.ralph/todo.md`, {
+    cwd,
+    stdio: "pipe"
+  });
+  const escapedDescription = description.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  execSync(`git commit -m "todo: ${escapedDescription}"`, { cwd, stdio: "pipe" });
+  console.log(`\u2705 added`);
+};
+
+// src/lib/getProgress.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+
+// src/lib/getBeadsProgress.ts
+import { execSync as execSync2 } from "child_process";
+var getBeadsProgress = (initialCount, startupTimestamp) => {
+  try {
+    const createdSinceStartup = parseInt(
+      execSync2(`bd count --created-after="${startupTimestamp}"`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim(),
+      10
+    );
+    const currentOpen = parseInt(
+      execSync2("bd count --status=open", {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim(),
+      10
+    );
+    const currentInProgress = parseInt(
+      execSync2("bd count --status=in_progress", {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim(),
+      10
+    );
+    const currentRemaining = currentOpen + currentInProgress;
+    const total = initialCount + createdSinceStartup;
+    const completed = total - currentRemaining;
+    return { type: "beads", completed, total };
+  } catch {
+    return { type: "none", completed: 0, total: 0 };
+  }
+};
+
+// src/lib/getTodoProgress.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+var ralphDir = join2(process.cwd(), ".ralph");
+var todoFile = join2(ralphDir, "todo.md");
+var getTodoProgress = () => {
+  try {
+    const content = readFileSync2(todoFile, "utf-8");
+    const uncheckedMatches = content.match(/- \[ \]/g);
+    const unchecked = uncheckedMatches ? uncheckedMatches.length : 0;
+    const checkedMatches = content.match(/- \[[xX]\]/g);
+    const checked = checkedMatches ? checkedMatches.length : 0;
+    const total = unchecked + checked;
+    return { type: "todo", completed: checked, total };
+  } catch {
+    return { type: "none", completed: 0, total: 0 };
+  }
+};
+
+// src/lib/getProgress.ts
+var beadsDir = join3(process.cwd(), ".beads");
+var ralphDir2 = join3(process.cwd(), ".ralph");
+var todoFile2 = join3(ralphDir2, "todo.md");
+var getProgress = (initialCount, startupTimestamp) => {
+  if (existsSync2(beadsDir)) {
+    return getBeadsProgress(initialCount, startupTimestamp);
+  }
+  if (existsSync2(todoFile2)) {
+    return getTodoProgress();
+  }
+  return { type: "none", completed: 0, total: 0 };
+};
+
+// src/lib/captureStartupSnapshot.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
+
+// src/lib/captureBeadsSnapshot.ts
+import { execSync as execSync3 } from "child_process";
+var captureBeadsSnapshot = () => {
+  try {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const openCount = parseInt(
+      execSync3("bd count --status=open", {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim(),
+      10
+    );
+    const inProgressCount = parseInt(
+      execSync3("bd count --status=in_progress", {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim(),
+      10
+    );
+    return {
+      initialCount: openCount + inProgressCount,
+      timestamp,
+      type: "beads"
+    };
+  } catch {
+    return void 0;
+  }
+};
+
+// src/lib/captureTodoSnapshot.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join4 } from "path";
+var ralphDir3 = join4(process.cwd(), ".ralph");
+var todoFile3 = join4(ralphDir3, "todo.md");
+var captureTodoSnapshot = () => {
+  try {
+    const content = readFileSync3(todoFile3, "utf-8");
+    const uncheckedMatches = content.match(/- \[ \]/g);
+    const unchecked = uncheckedMatches ? uncheckedMatches.length : 0;
+    const checkedMatches = content.match(/- \[[xX]\]/g);
+    const checked = checkedMatches ? checkedMatches.length : 0;
+    return {
+      initialCount: unchecked + checked,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "todo"
+    };
+  } catch {
+    return void 0;
+  }
+};
+
+// src/lib/captureStartupSnapshot.ts
+var beadsDir2 = join5(process.cwd(), ".beads");
+var ralphDir4 = join5(process.cwd(), ".ralph");
+var todoFile4 = join5(ralphDir4, "todo.md");
+var captureStartupSnapshot = () => {
+  if (existsSync3(beadsDir2)) {
+    return captureBeadsSnapshot();
+  }
+  if (existsSync3(todoFile4)) {
+    return captureTodoSnapshot();
+  }
+  return void 0;
+};
+
+// src/components/ProgressBar.tsx
+import React2 from "react";
+import { Text as Text2 } from "ink";
+var ProgressBar = ({ completed, total, width = 12, repoName: repoName3 }) => {
+  if (total === 0) {
+    return null;
+  }
+  const progress = Math.min(1, Math.max(0, completed / total));
+  const filledWidth = Math.round(progress * width);
+  const emptyWidth = width - filledWidth;
+  const filled = "\u25B0".repeat(filledWidth);
+  const empty = "\u25B1".repeat(emptyWidth);
+  return /* @__PURE__ */ React2.createElement(Text2, null, repoName3 && /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(Text2, { color: "cyan" }, repoName3), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, " \u2502 ")), /* @__PURE__ */ React2.createElement(Text2, { color: "yellow" }, filled), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, empty), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, " ", completed, "/", total, " "));
+};
+
+// src/lib/beadsClient.ts
+import { createConnection } from "net";
+import { join as join6 } from "path";
+import { existsSync as existsSync4 } from "fs";
+var SOCKET_PATH = join6(process.cwd(), ".beads", "bd.sock");
+var BeadsClient = class _BeadsClient {
+  socket = null;
+  connected = false;
+  /**
+   * Check if the beads daemon socket exists.
+   */
+  static socketExists() {
+    return existsSync4(SOCKET_PATH);
+  }
+  /**
+   * Connect to the beads daemon.
+   */
+  async connect() {
+    if (!_BeadsClient.socketExists()) {
+      return false;
+    }
+    return new Promise((resolve) => {
+      this.socket = createConnection(SOCKET_PATH);
+      const timeout = setTimeout(() => {
+        this.socket?.destroy();
+        this.socket = null;
+        resolve(false);
+      }, 2e3);
+      this.socket.on("connect", () => {
+        clearTimeout(timeout);
+        this.connected = true;
+        resolve(true);
+      });
+      this.socket.on("error", () => {
+        clearTimeout(timeout);
+        this.socket = null;
+        resolve(false);
+      });
+    });
+  }
+  /**
+   * Send an RPC request and wait for response.
+   */
+  async execute(operation, args = {}) {
+    if (!this.socket || !this.connected) {
+      return null;
+    }
+    return new Promise((resolve) => {
+      const request = { operation, args };
+      const requestLine = JSON.stringify(request) + "\n";
+      let responseData = "";
+      const onData = (chunk) => {
+        responseData += chunk.toString();
+        if (responseData.includes("\n")) {
+          cleanup();
+          try {
+            const response = JSON.parse(responseData.trim());
+            if (response.success && response.data) {
+              resolve(response.data);
+            } else {
+              resolve(null);
+            }
+          } catch {
+            resolve(null);
+          }
+        }
+      };
+      const onError = () => {
+        cleanup();
+        resolve(null);
+      };
+      const timeout = setTimeout(() => {
+        cleanup();
+        resolve(null);
+      }, 5e3);
+      const cleanup = () => {
+        clearTimeout(timeout);
+        this.socket?.off("data", onData);
+        this.socket?.off("error", onError);
+      };
+      this.socket.on("data", onData);
+      this.socket.on("error", onError);
+      this.socket.write(requestLine);
+    });
+  }
+  /**
+   * Get mutations since a given timestamp.
+   */
+  async getMutations(since = 0) {
+    const result = await this.execute("get_mutations", { since });
+    return result ?? [];
+  }
+  /**
+   * Get ready issues (no blockers).
+   */
+  async getReady() {
+    const result = await this.execute("ready", {});
+    return result ?? [];
+  }
+  /**
+   * Close the connection.
+   */
+  close() {
+    if (this.socket) {
+      this.socket.destroy();
+      this.socket = null;
+      this.connected = false;
+    }
+  }
+};
+function watchForNewIssues(onNewIssue, interval = 5e3) {
+  let lastTimestamp = Date.now();
+  let client = null;
+  let timeoutId = null;
+  let stopped = false;
+  const poll = async () => {
+    if (stopped) return;
+    if (!client) {
+      client = new BeadsClient();
+      const connected = await client.connect();
+      if (!connected) {
+        timeoutId = setTimeout(poll, interval);
+        return;
+      }
+    }
+    try {
+      const mutations = await client.getMutations(lastTimestamp);
+      for (const mutation of mutations) {
+        if (mutation.Type === "create") {
+          onNewIssue(mutation);
+        }
+        const mutationTime = new Date(mutation.Timestamp).getTime();
+        if (mutationTime > lastTimestamp) {
+          lastTimestamp = mutationTime;
+        }
+      }
+    } catch {
+      client?.close();
+      client = null;
+    }
+    if (!stopped) {
+      timeoutId = setTimeout(poll, interval);
+    }
+  };
+  poll();
+  return () => {
+    stopped = true;
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    client?.close();
+  };
+}
+
+// src/lib/debug.ts
+var isDebugEnabled = (namespace) => {
+  const debugEnv = process.env.RALPH_DEBUG;
+  if (!debugEnv) return false;
+  const value = debugEnv.toLowerCase();
+  if (value === "1" || value === "true" || value === "all" || value === "*") {
+    return true;
+  }
+  if (namespace && value === namespace.toLowerCase()) {
+    return true;
+  }
+  if (namespace && value.includes(",")) {
+    return value.split(",").some((ns) => ns.trim().toLowerCase() === namespace.toLowerCase());
+  }
+  return false;
+};
+var debug = (namespace, message, ...args) => {
+  if (isDebugEnabled(namespace)) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = `[${timestamp}] [RALPH:${namespace.toUpperCase()}]`;
+    console.error(prefix, message, ...args);
+  }
+};
+var createDebugLogger = (namespace) => {
+  return (message, ...args) => debug(namespace, message, ...args);
+};
+
+// src/lib/createUserMessage.ts
+var createUserMessage = (text) => ({
+  type: "user",
+  session_id: "",
+  message: {
+    role: "user",
+    content: [{ type: "text", text }]
+  },
+  parent_tool_use_id: null
+});
+
+// src/lib/MessageQueue.ts
+var log = createDebugLogger("messagequeue");
+var MessageQueue = class {
+  queue = [];
+  resolvers = [];
+  closed = false;
+  nextCallCount = 0;
+  /**
+   * Push a message to the queue. If there are pending resolvers waiting for the next message,
+   * resolve immediately. Otherwise, add to queue.
+   */
+  push(message) {
+    const messagePreview = this.getMessagePreview(message);
+    log(`push() called with message: ${messagePreview}`);
+    if (this.closed) {
+      log(`push() ignored - queue is closed`);
+      return;
+    }
+    if (this.resolvers.length > 0) {
+      const resolve = this.resolvers.shift();
+      log(`push() resolving pending next() call (${this.resolvers.length} resolvers remaining)`);
+      resolve({ value: message, done: false });
+    } else {
+      this.queue.push(message);
+      log(`push() added to queue (queue length: ${this.queue.length})`);
+    }
+  }
+  /**
+   * Close the queue. Resolve any pending resolvers with done=true.
+   */
+  close() {
+    if (this.closed) {
+      log(`close() called but already closed - no-op`);
+      return;
+    }
+    log(`close() called - resolving ${this.resolvers.length} pending resolvers`);
+    this.closed = true;
+    for (const resolve of this.resolvers) {
+      log(`close() resolving pending resolver with done=true`);
+      resolve({ value: void 0, done: true });
+    }
+    this.resolvers = [];
+    log(`close() complete`);
+  }
+  /**
+   * Get a preview string of a message for debug logging.
+   */
+  getMessagePreview(message) {
+    const content = message.message?.content;
+    if (Array.isArray(content) && content.length > 0) {
+      const firstBlock = content[0];
+      if ("text" in firstBlock && typeof firstBlock.text === "string") {
+        const text = firstBlock.text.slice(0, 50);
+        return text.length < firstBlock.text.length ? `"${text}..."` : `"${text}"`;
+      }
+    }
+    return `[${message.type} message]`;
+  }
+  /**
+   * Implement the async iterable protocol to allow session with for-await-of.
+   */
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        this.nextCallCount++;
+        const callId = this.nextCallCount;
+        if (this.queue.length > 0) {
+          const message = this.queue.shift();
+          log(`next() #${callId}: returning queued message (${this.queue.length} remaining)`);
+          return Promise.resolve({ value: message, done: false });
+        }
+        if (this.closed) {
+          log(`next() #${callId}: queue closed, returning done=true`);
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        log(
+          `next() #${callId}: queue empty, creating pending resolver (${this.resolvers.length + 1} total)`
+        );
+        return new Promise((resolve) => {
+          this.resolvers.push(resolve);
+        });
+      }
+    };
+  }
+};
+
+// src/lib/useTerminalSize.ts
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import { useStdout } from "ink";
+
+// src/lib/getTerminalSize.ts
+function getTerminalSize(stdout) {
+  return {
+    columns: stdout?.columns ?? 80,
+    rows: stdout?.rows ?? 24
+  };
+}
+
+// src/lib/useTerminalSize.ts
+var useTerminalSize = () => {
+  const { stdout } = useStdout();
+  const [size, setSize] = useState2(() => getTerminalSize(stdout));
+  useEffect2(() => {
+    const handleResize = () => {
+      setSize(getTerminalSize(stdout));
+    };
+    stdout?.on("resize", handleResize);
+    return () => {
+      stdout?.off("resize", handleResize);
+    };
+  }, [stdout]);
+  return size;
+};
+
+// src/lib/getNextLogFile.ts
+import { existsSync as existsSync6, mkdirSync } from "fs";
+import { join as join8 } from "path";
+
+// src/lib/findMaxLogNumber.ts
+import { readdirSync, existsSync as existsSync5 } from "fs";
+import { join as join7 } from "path";
+var EVENT_LOG_PATTERN = /^events-(\d+)\.jsonl$/;
+var findMaxLogNumber = () => {
+  const ralphDir6 = join7(process.cwd(), ".ralph");
+  if (!existsSync5(ralphDir6)) {
+    return 0;
+  }
+  const files = readdirSync(ralphDir6);
+  let maxNumber = 0;
+  for (const file of files) {
+    const match = file.match(EVENT_LOG_PATTERN);
+    if (match) {
+      const num = parseInt(match[1], 10);
+      if (num > maxNumber) {
+        maxNumber = num;
+      }
+    }
+  }
+  return maxNumber;
+};
+
+// src/lib/getNextLogFile.ts
+var getNextLogFile = () => {
+  const ralphDir6 = join8(process.cwd(), ".ralph");
+  if (!existsSync6(ralphDir6)) {
+    mkdirSync(ralphDir6, { recursive: true });
+  }
+  const maxNumber = findMaxLogNumber();
+  return join8(ralphDir6, `events-${maxNumber + 1}.jsonl`);
+};
+
+// src/lib/parseTaskLifecycle.ts
+function parseTaskLifecycleEvent(text) {
+  const startingMatch = text.match(/<start_task>([a-z]+-[a-z0-9]+(?:\.[a-z0-9]+)*)<\/start_task>/i);
+  if (startingMatch) {
+    return {
+      action: "starting",
+      taskId: startingMatch[1]
+    };
+  }
+  const completedMatch = text.match(/<end_task>([a-z]+-[a-z0-9]+(?:\.[a-z0-9]+)*)<\/end_task>/i);
+  if (completedMatch) {
+    return {
+      action: "completed",
+      taskId: completedMatch[1]
+    };
+  }
+  return null;
+}
+
+// src/lib/getPromptContent.ts
+import { readFileSync as readFileSync4, existsSync as existsSync7 } from "fs";
+import { join as join9, dirname } from "path";
+import { fileURLToPath } from "url";
+var getPromptContent = () => {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const ralphDir6 = join9(process.cwd(), ".ralph");
+  const promptFile = join9(ralphDir6, "prompt.md");
+  const todoFile7 = join9(ralphDir6, "todo.md");
+  const beadsDir3 = join9(process.cwd(), ".beads");
+  const templatesDir = join9(__dirname, "..", "..", "templates");
+  if (existsSync7(promptFile)) {
+    return readFileSync4(promptFile, "utf-8");
+  }
+  const useBeadsTemplate = existsSync7(beadsDir3) || !existsSync7(todoFile7);
+  const templateFile = useBeadsTemplate ? "prompt-beads.md" : "prompt-todos.md";
+  const templatePath = join9(templatesDir, templateFile);
+  if (existsSync7(templatePath)) {
+    return readFileSync4(templatePath, "utf-8");
+  }
+  return "Work on the highest-priority task.";
+};
+
+// src/lib/sdkMessageToEvent.ts
+var sdkMessageToEvent = (message) => {
+  if (message.type === "assistant" || message.type === "user" || message.type === "result") {
+    return message;
+  }
+  return null;
+};
+
+// src/lib/rel.ts
+import { isAbsolute, relative } from "path";
+
+// src/lib/getBaseCwd.ts
+var getBaseCwd = () => process.env.RALPH_CWD ?? process.cwd();
+
+// src/lib/rel.ts
+var rel = (path) => {
+  if (!isAbsolute(path)) {
+    return path;
+  }
+  if (path.includes("/var/folders/") || path.includes("/tmp/")) {
+    return path.split("/").pop() || path;
+  }
+  return relative(getBaseCwd(), path) || path;
+};
+
+// src/lib/shortenTempPaths.ts
+var shortenTempPaths = (text) => {
+  return text.replace(/\/var\/folders\/[^\s]+/g, (match) => match.split("/").pop() || match).replace(/\/tmp\/[^\s]+/g, (match) => match.split("/").pop() || match);
+};
+
+// src/components/eventToBlocks.ts
+var eventToBlocks = (event) => {
+  if (event.type === "user") {
+    const message2 = event.message;
+    const content2 = message2?.content;
+    const messageId2 = message2?.id ?? `user-${Date.now()}`;
+    if (!content2) {
+      return [];
+    }
+    const textContent = content2.filter((block) => block.type === "text").map((block) => block.text).join("");
+    if (textContent) {
+      return [{ type: "user", content: textContent, id: messageId2 }];
+    }
+    return [];
+  }
+  if (event.type !== "assistant") {
+    return [];
+  }
+  const message = event.message;
+  const content = message?.content;
+  if (!content) {
+    return [];
+  }
+  const blocks = [];
+  const messageId = message?.id ?? "unknown";
+  let blockIndex = 0;
+  let textBuffer = "";
+  for (const block of content) {
+    if (block.type === "text") {
+      const text = block.text;
+      if (text) {
+        textBuffer += text;
+      }
+    } else if (block.type === "tool_use") {
+      if (textBuffer) {
+        blocks.push({ type: "text", content: textBuffer, id: `${messageId}-${blockIndex++}` });
+        textBuffer = "";
+      }
+      const input = block.input;
+      const name = block.name;
+      if (name === "Read") {
+        const filePath = input?.file_path;
+        if (filePath) {
+          blocks.push({
+            type: "tool",
+            name: "Read",
+            arg: rel(filePath),
+            id: `${messageId}-${blockIndex++}`
+          });
+        }
+      } else if (name === "Edit" || name === "Write") {
+        const filePath = input?.file_path;
+        if (filePath) {
+          blocks.push({
+            type: "tool",
+            name,
+            arg: rel(filePath),
+            id: `${messageId}-${blockIndex++}`
+          });
+        }
+      } else if (name === "Bash") {
+        const command = input?.command;
+        if (command) {
+          blocks.push({
+            type: "tool",
+            name: "$",
+            arg: shortenTempPaths(command),
+            id: `${messageId}-${blockIndex++}`
+          });
+        }
+      } else if (name === "Grep") {
+        const pattern = input?.pattern;
+        const path = input?.path;
+        blocks.push({
+          type: "tool",
+          name: "Grep",
+          arg: `${pattern}${path ? ` in ${rel(path)}` : ""}`,
+          id: `${messageId}-${blockIndex++}`
+        });
+      } else if (name === "Glob") {
+        const pattern = input?.pattern;
+        const path = input?.path;
+        blocks.push({
+          type: "tool",
+          name: "Glob",
+          arg: `${pattern}${path ? ` in ${rel(path)}` : ""}`,
+          id: `${messageId}-${blockIndex++}`
+        });
+      } else if (name === "TodoWrite") {
+        const todos = input?.todos;
+        if (todos?.length) {
+          const summary = todos.map(
+            (t) => `[${t.status === "completed" ? "x" : t.status === "in_progress" ? "~" : " "}] ${t.content}`
+          ).join("\n    ");
+          blocks.push({
+            type: "tool",
+            name: "TodoWrite",
+            arg: "\n    " + summary,
+            id: `${messageId}-${blockIndex++}`
+          });
+        } else {
+          blocks.push({ type: "tool", name: "TodoWrite", id: `${messageId}-${blockIndex++}` });
+        }
+      } else if (name === "WebFetch") {
+        const url = input?.url;
+        blocks.push({
+          type: "tool",
+          name: "WebFetch",
+          arg: url,
+          id: `${messageId}-${blockIndex++}`
+        });
+      } else if (name === "WebSearch") {
+        const query3 = input?.query;
+        blocks.push({
+          type: "tool",
+          name: "WebSearch",
+          arg: query3,
+          id: `${messageId}-${blockIndex++}`
+        });
+      } else if (name === "Task") {
+        const description = input?.description;
+        blocks.push({
+          type: "tool",
+          name: "Task",
+          arg: description,
+          id: `${messageId}-${blockIndex++}`
+        });
+      } else if (name === "Skill") {
+        const skill = input?.skill;
+        blocks.push({ type: "tool", name: "Skill", arg: skill, id: `${messageId}-${blockIndex++}` });
+      }
+    }
+  }
+  if (textBuffer) {
+    blocks.push({ type: "text", content: textBuffer, id: `${messageId}-${blockIndex++}` });
+  }
+  return blocks;
+};
+
+// src/lib/processEvents.ts
+var processEvents = (events) => {
+  const blocks = [];
+  const assistantEvents = events.filter((event) => event.type === "assistant");
+  const messageMap = /* @__PURE__ */ new Map();
+  for (const event of assistantEvents) {
+    const message = event.message;
+    const messageId = message?.id;
+    const content = message?.content;
+    if (messageId && content) {
+      if (!messageMap.has(messageId)) {
+        messageMap.set(messageId, []);
+      }
+      messageMap.get(messageId).push(...content);
+    }
+  }
+  const mergedEvents = Array.from(messageMap.entries()).map(([messageId, allContent]) => {
+    const seenBlocks = /* @__PURE__ */ new Set();
+    const uniqueContent = [];
+    for (const block of allContent) {
+      const blockType = block.type;
+      let blockKey;
+      if (blockType === "tool_use") {
+        blockKey = `tool:${block.id}`;
+      } else if (blockType === "text") {
+        const text = block.text;
+        let isDuplicate = false;
+        for (const seenKey of seenBlocks) {
+          if (seenKey.startsWith("text:")) {
+            const seenText = seenKey.substring(5);
+            if (seenText.startsWith(text)) {
+              isDuplicate = true;
+              break;
+            } else if (text.startsWith(seenText)) {
+              seenBlocks.delete(seenKey);
+              const idx = uniqueContent.findIndex((b) => b.type === "text" && b.text === seenText);
+              if (idx >= 0) uniqueContent.splice(idx, 1);
+              break;
+            }
+          }
+        }
+        if (isDuplicate) continue;
+        blockKey = `text:${text}`;
+      } else {
+        blockKey = JSON.stringify(block);
+      }
+      if (!seenBlocks.has(blockKey)) {
+        seenBlocks.add(blockKey);
+        uniqueContent.push(block);
+      }
+    }
+    return {
+      type: "assistant",
+      message: {
+        id: messageId,
+        content: uniqueContent
+      }
+    };
+  });
+  const assistantBlocks = mergedEvents.flatMap((event) => eventToBlocks(event));
+  const processedUserIds = /* @__PURE__ */ new Set();
+  const processedAssistantIds = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (event.type === "user") {
+      const message = event.message;
+      const messageId = message?.id ?? `user-${Date.now()}`;
+      if (!processedUserIds.has(messageId)) {
+        processedUserIds.add(messageId);
+        blocks.push(...eventToBlocks(event));
+      }
+    } else if (event.type === "assistant") {
+      const message = event.message;
+      const messageId = message?.id;
+      if (messageId && !processedAssistantIds.has(messageId)) {
+        processedAssistantIds.add(messageId);
+        const merged = assistantBlocks.filter((b) => b.id.startsWith(messageId));
+        blocks.push(...merged);
+      }
+    }
+  }
+  return blocks;
+};
+
+// src/components/renderStaticItem.tsx
+import React4 from "react";
+import { Box as Box2, Text as Text4 } from "ink";
+import BigText2 from "ink-big-text";
+import Gradient2 from "ink-gradient";
+
+// src/components/Header.tsx
+import React3 from "react";
+import { Box, Text as Text3 } from "ink";
+import BigText from "ink-big-text";
+import Gradient from "ink-gradient";
+var Header = ({
+  /** The Claude CLI version */
+  claudeVersion,
+  /** The Ralph version */
+  ralphVersion,
+  /** Optional box width */
+  width
+}) => {
+  return /* @__PURE__ */ React3.createElement(
+    Box,
+    {
+      flexDirection: "column",
+      marginBottom: 1,
+      borderStyle: "single",
+      alignItems: "center",
+      width,
+      paddingX: 2
+    },
+    /* @__PURE__ */ React3.createElement(Gradient, { colors: ["#30A6E4", "#EBC635"] }, /* @__PURE__ */ React3.createElement(BigText, { text: "Ralph", font: "tiny" })),
+    /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "@herbcaudill/ralph v", ralphVersion, " \u2022 Claude Code v", claudeVersion)
+  );
+};
+
+// src/lib/formatText.ts
+import chalk2 from "chalk";
+var formatText = (content) => {
+  let result = "";
+  let i = 0;
+  let inBold = false;
+  let inCode = false;
+  while (i < content.length) {
+    if (content[i] === "*" && content[i + 1] === "*") {
+      inBold = !inBold;
+      i += 2;
+    } else if (content[i] === "`") {
+      inCode = !inCode;
+      i++;
+    } else {
+      let char = content[i];
+      if (inCode) {
+        char = chalk2.yellow(char);
+      } else if (inBold) {
+        char = chalk2.bold(char);
+      }
+      result += char;
+      i++;
+    }
+  }
+  return result;
+};
+
+// src/lib/formatToolUse.ts
+import chalk3 from "chalk";
+var formatToolUse = (name, arg) => {
+  const formattedName = chalk3.blue(name);
+  if (arg) {
+    return `  ${formattedName} ${chalk3.dim(arg)}`;
+  }
+  return `  ${formattedName}`;
+};
+
+// src/lib/formatUserMessage.ts
+import chalk4 from "chalk";
+var formatUserMessage = (content) => {
+  return chalk4.green(content);
+};
+
+// src/lib/formatContentBlock.ts
+var formatContentBlock = (block) => {
+  if (block.type === "text") {
+    const formatted = formatText(block.content);
+    return formatted.split("\n");
+  }
+  if (block.type === "user") {
+    return [formatUserMessage(block.content)];
+  }
+  return [formatToolUse(block.name, block.arg)];
+};
+
+// src/components/renderStaticItem.tsx
+var renderStaticItem = (item) => {
+  if (item.type === "header") {
+    return /* @__PURE__ */ React4.createElement(Header, { claudeVersion: item.claudeVersion, ralphVersion: item.ralphVersion });
+  }
+  if (item.type === "session") {
+    return /* @__PURE__ */ React4.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React4.createElement(Gradient2, { colors: ["#30A6E4", "#EBC635"] }, /* @__PURE__ */ React4.createElement(BigText2, { text: `R${item.session}`, font: "tiny" })));
+  }
+  const lines = formatContentBlock(item.block);
+  return /* @__PURE__ */ React4.createElement(Box2, { flexDirection: "column", marginBottom: 1 }, lines.map((line, i) => /* @__PURE__ */ React4.createElement(Text4, { key: i }, line || " ")));
+};
+
+// src/components/SessionRunner.tsx
+var log2 = createDebugLogger("session");
+var ralphDir5 = join10(process.cwd(), ".ralph");
+var todoFile5 = join10(ralphDir5, "todo.md");
+var repoName = basename(process.cwd());
+var SessionRunner = ({
+  totalSessions,
+  claudeVersion,
+  ralphVersion,
+  watch,
+  agent
+}) => {
+  const { exit } = useApp();
+  const { columns } = useTerminalSize();
+  const [currentSession, setCurrentSession] = useState3(1);
+  const [events, setEvents] = useState3([]);
+  const eventsRef = useRef([]);
+  const [error, setError] = useState3();
+  const [isRunning, setIsRunning] = useState3(false);
+  const [isAddingTodo, setIsAddingTodo] = useState3(false);
+  const [todoText, setTodoText] = useState3("");
+  const [todoMessage, setTodoMessage] = useState3(null);
+  const [userMessageText, setUserMessageText] = useState3("");
+  const [userMessageStatus, setUserMessageStatus] = useState3(null);
+  const [hasTodoFile, setHasTodoFile] = useState3(false);
+  const [startupSnapshot] = useState3(() => captureStartupSnapshot());
+  const [progressData, setProgressData] = useState3(() => {
+    const snapshot = captureStartupSnapshot();
+    if (!snapshot) return { type: "none", completed: 0, total: 0 };
+    return { type: snapshot.type, completed: 0, total: snapshot.initialCount };
+  });
+  const [isWatching, setIsWatching] = useState3(false);
+  const [detectedIssue, setDetectedIssue] = useState3(null);
+  const watchCleanupRef = useRef(null);
+  const [watchCycle, setWatchCycle] = useState3(0);
+  const [stopAfterCurrent, setStopAfterCurrent] = useState3(false);
+  const stopAfterCurrentRef = useRef(false);
+  const [isPaused, setIsPaused] = useState3(false);
+  const isPausedRef = useRef(false);
+  const [currentTaskId, setCurrentTaskId] = useState3(null);
+  const [currentTaskTitle, setCurrentTaskTitle] = useState3(null);
+  const [staticItems, setStaticItems] = useState3([
+    { type: "header", claudeVersion, ralphVersion, key: "header" }
+  ]);
+  const renderedBlocksRef = useRef(/* @__PURE__ */ new Set());
+  const lastSessionRef = useRef(0);
+  const messageQueueRef = useRef(null);
+  const logFileRef = useRef(null);
+  const stdinSupportsRawMode = process.stdin.isTTY === true;
+  const handleTodoSubmit = (text) => {
+    const trimmed = text.trim();
+    if (!trimmed) {
+      setIsAddingTodo(false);
+      setTodoText("");
+      return;
+    }
+    try {
+      addTodo(trimmed);
+      setTodoMessage({ type: "success", text: "\u2705 added" });
+      setTodoText("");
+      setIsAddingTodo(false);
+      setTimeout(() => setTodoMessage(null), 2e3);
+    } catch (err) {
+      setTodoMessage({
+        type: "error",
+        text: `Failed to add todo: ${err instanceof Error ? err.message : String(err)}`
+      });
+      setTodoText("");
+      setIsAddingTodo(false);
+      setTimeout(() => setTodoMessage(null), 5e3);
+    }
+  };
+  const handleUserMessageSubmit = (text) => {
+    const trimmed = text.trim();
+    if (!trimmed) {
+      setUserMessageText("");
+      return;
+    }
+    if (messageQueueRef.current && isRunning) {
+      const userMessage = createUserMessage(trimmed);
+      messageQueueRef.current.push(userMessage);
+      const displayEvent = {
+        type: "user",
+        message: {
+          id: `user-injected-${Date.now()}`,
+          role: "user",
+          content: [{ type: "text", text: trimmed }]
+        }
+      };
+      setEvents((prev) => [...prev, displayEvent]);
+    } else {
+      setUserMessageStatus({
+        type: "error",
+        text: "Unable to send message - Claude is not running"
+      });
+    }
+    setUserMessageText("");
+    setTimeout(() => setUserMessageStatus(null), 3e3);
+  };
+  useInput2(
+    (input, key) => {
+      if (key.ctrl && input === "t" && hasTodoFile) {
+        setIsAddingTodo(true);
+        setTodoText("");
+        setTodoMessage(null);
+      }
+      if (key.ctrl && input === "s" && isRunning && !stopAfterCurrent) {
+        setStopAfterCurrent(true);
+      }
+      if (key.ctrl && input === "p") {
+        if (isPaused) {
+          setIsPaused(false);
+          if (!isRunning) {
+            setTimeout(() => setCurrentSession((i) => i + 1), 100);
+          }
+        } else if (isRunning) {
+          setIsPaused(true);
+        }
+      }
+      if (key.escape) {
+        if (isAddingTodo) {
+          setIsAddingTodo(false);
+          setTodoText("");
+        }
+      }
+    },
+    { isActive: stdinSupportsRawMode }
+  );
+  useEffect3(() => {
+    eventsRef.current = events;
+  }, [events]);
+  useEffect3(() => {
+    stopAfterCurrentRef.current = stopAfterCurrent;
+  }, [stopAfterCurrent]);
+  useEffect3(() => {
+    isPausedRef.current = isPaused;
+  }, [isPaused]);
+  useEffect3(() => {
+    if (!isRunning && startupSnapshot) {
+      setProgressData(getProgress(startupSnapshot.initialCount, startupSnapshot.timestamp));
+    }
+  }, [currentSession, isRunning, startupSnapshot]);
+  useEffect3(() => {
+    if (!isRunning || !startupSnapshot) return;
+    const pollInterval = setInterval(() => {
+      setProgressData(getProgress(startupSnapshot.initialCount, startupSnapshot.timestamp));
+    }, 5e3);
+    return () => clearInterval(pollInterval);
+  }, [isRunning, startupSnapshot]);
+  useEffect3(() => {
+    if (!isWatching) return;
+    const cleanup = watchForNewIssues((issue) => {
+      setDetectedIssue(issue);
+      if (startupSnapshot) {
+        setProgressData(getProgress(startupSnapshot.initialCount, startupSnapshot.timestamp));
+      }
+      setTimeout(() => {
+        setIsWatching(false);
+        setDetectedIssue(null);
+        renderedBlocksRef.current.clear();
+        setCurrentSession((i) => i + 1);
+        setWatchCycle((c) => c + 1);
+      }, 1500);
+    });
+    watchCleanupRef.current = cleanup;
+    return () => {
+      cleanup();
+      watchCleanupRef.current = null;
+    };
+  }, [isWatching, startupSnapshot]);
+  useEffect3(() => {
+    const newItems = [];
+    if (currentSession > lastSessionRef.current) {
+      newItems.push({
+        type: "session",
+        session: currentSession,
+        key: `session-${currentSession}`
+      });
+      lastSessionRef.current = currentSession;
+    }
+    const blocks = processEvents(events);
+    for (const block of blocks) {
+      const blockKey = block.id;
+      if (!renderedBlocksRef.current.has(blockKey)) {
+        renderedBlocksRef.current.add(blockKey);
+        newItems.push({ type: "block", block, key: blockKey });
+      }
+    }
+    if (newItems.length > 0) {
+      setStaticItems((prev) => [...prev, ...newItems]);
+    }
+  }, [events, currentSession]);
+  useEffect3(() => {
+    if (currentSession > totalSessions) {
+      exit();
+      return;
+    }
+    const currentProgress = startupSnapshot ? getProgress(startupSnapshot.initialCount, startupSnapshot.timestamp) : { type: "none", completed: 0, total: 0 };
+    if (currentProgress.completed >= currentProgress.total && currentProgress.type !== "none") {
+      if (watch) {
+        setIsWatching(true);
+      } else {
+        exit();
+        process.exit(0);
+      }
+      return;
+    }
+    if (!logFileRef.current) {
+      logFileRef.current = getNextLogFile();
+      writeFileSync2(logFileRef.current, "");
+    }
+    const logFile = logFileRef.current;
+    setEvents([]);
+    const promptContent = getPromptContent();
+    const todoExists = existsSync8(todoFile5);
+    setHasTodoFile(todoExists);
+    const todoContent = todoExists ? readFileSync5(todoFile5, "utf-8") : "";
+    const roundHeader = `# Ralph, round ${currentSession}
+
+`;
+    const fullPrompt = todoContent ? `${roundHeader}${promptContent}
+
+## Current Todo List
+
+${todoContent}` : `${roundHeader}${promptContent}`;
+    const abortController = new AbortController();
+    setIsRunning(true);
+    const messageQueue = new MessageQueue();
+    messageQueueRef.current = messageQueue;
+    messageQueue.push(createUserMessage(fullPrompt));
+    const runQuery = async () => {
+      let finalResult = "";
+      log2(`Starting session ${currentSession}`);
+      try {
+        log2(`Beginning query() loop`);
+        for await (const message of query({
+          prompt: messageQueue,
+          options: {
+            abortController,
+            permissionMode: "bypassPermissions",
+            allowDangerouslySkipPermissions: true,
+            includePartialMessages: true,
+            env: {
+              ...process.env,
+              // Disable LSP plugins to avoid crashes when TypeScript LSP server errors
+              ENABLE_LSP_TOOL: "0",
+              // Signal that tests should use minimal reporters (dots)
+              RALPH_QUIET: "1"
+            }
+          }
+        })) {
+          log2(`Received message type: ${message.type}`);
+          appendFileSync(logFile, JSON.stringify(message) + "\n");
+          const event = sdkMessageToEvent(message);
+          if (event) {
+            setEvents((prev) => [...prev, event]);
+          }
+          if (message.type === "assistant") {
+            const assistantMessage = message.message;
+            const content = assistantMessage?.content;
+            if (content) {
+              for (const block of content) {
+                if (block.type === "text" && typeof block.text === "string") {
+                  const taskInfo = parseTaskLifecycleEvent(block.text);
+                  if (taskInfo) {
+                    if (taskInfo.action === "starting") {
+                      setCurrentTaskId(taskInfo.taskId ?? null);
+                      setCurrentTaskTitle(taskInfo.taskTitle ?? null);
+                      log2(
+                        `Task started: ${taskInfo.taskId}${taskInfo.taskTitle ? ` - ${taskInfo.taskTitle}` : ""}`
+                      );
+                      const taskStartedEvent = {
+                        type: "ralph_task_started",
+                        taskId: taskInfo.taskId,
+                        taskTitle: taskInfo.taskTitle,
+                        session: currentSession
+                      };
+                      appendFileSync(logFile, JSON.stringify(taskStartedEvent) + "\n");
+                    } else if (taskInfo.action === "completed") {
+                      log2(
+                        `Task completed: ${taskInfo.taskId}${taskInfo.taskTitle ? ` - ${taskInfo.taskTitle}` : ""}`
+                      );
+                      const taskCompletedEvent = {
+                        type: "ralph_task_completed",
+                        taskId: taskInfo.taskId,
+                        taskTitle: taskInfo.taskTitle,
+                        session: currentSession
+                      };
+                      appendFileSync(logFile, JSON.stringify(taskCompletedEvent) + "\n");
+                    }
+                  }
+                }
+              }
+            }
+          }
+          if (message.type === "result" && "result" in message && typeof message.result === "string") {
+            log2(`Received result message`);
+            finalResult = message.result;
+            log2(`Closing message queue on result`);
+            messageQueue.close();
+          }
+        }
+        log2(`query() loop completed normally`);
+        setIsRunning(false);
+        log2(`Ensuring message queue is closed`);
+        messageQueue.close();
+        messageQueueRef.current = null;
+        if (stopAfterCurrentRef.current) {
+          log2(`Stop after current requested - exiting gracefully`);
+          exit();
+          process.exit(0);
+          return;
+        }
+        if (finalResult.includes("<promise>COMPLETE</promise>")) {
+          if (watch) {
+            setIsWatching(true);
+          } else {
+            exit();
+            process.exit(0);
+          }
+          return;
+        }
+        if (isPausedRef.current) {
+          log2(`Paused after session ${currentSession}`);
+          return;
+        }
+        setTimeout(() => setCurrentSession((i) => i + 1), 500);
+      } catch (err) {
+        log2(`query() loop error: ${err instanceof Error ? err.message : String(err)}`);
+        setIsRunning(false);
+        log2(`Closing message queue after error`);
+        messageQueue.close();
+        messageQueueRef.current = null;
+        if (abortController.signal.aborted) {
+          log2(`Abort signal detected`);
+          return;
+        }
+        setError(`Error running Claude: ${err instanceof Error ? err.message : String(err)}`);
+        setTimeout(() => {
+          exit();
+          process.exit(1);
+        }, 100);
+      }
+    };
+    runQuery();
+    return () => {
+      log2(`Cleanup: aborting and closing queue for session ${currentSession}`);
+      abortController.abort();
+      messageQueue.close();
+      messageQueueRef.current = null;
+    };
+  }, [currentSession, totalSessions, exit, watch, watchCycle]);
+  if (error) {
+    return /* @__PURE__ */ React5.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Text5, { color: "red" }, error));
+  }
+  return /* @__PURE__ */ React5.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Static, { items: staticItems }, (item) => /* @__PURE__ */ React5.createElement(Box3, { key: item.key, flexDirection: "column" }, renderStaticItem(item))), isAddingTodo && /* @__PURE__ */ React5.createElement(Box3, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text5, { color: "yellow" }, "Todo:"), /* @__PURE__ */ React5.createElement(EnhancedTextInput, { value: todoText, onChange: setTodoText, onSubmit: handleTodoSubmit }), /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "(Enter to add, Esc to cancel)")), todoMessage && /* @__PURE__ */ React5.createElement(Box3, { marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text5, { color: todoMessage.type === "success" ? "green" : "red" }, todoMessage.text)), !isWatching && /* @__PURE__ */ React5.createElement(Box3, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "\u2500".repeat(columns)), /* @__PURE__ */ React5.createElement(Box3, null, /* @__PURE__ */ React5.createElement(Text5, { color: isRunning ? "yellow" : "gray" }, "\u276F "), /* @__PURE__ */ React5.createElement(
+    EnhancedTextInput,
+    {
+      value: userMessageText,
+      placeholder: isRunning ? "Type a message for Ralph..." : "Waiting for Ralph to start...",
+      onChange: setUserMessageText,
+      onSubmit: handleUserMessageSubmit,
+      focus: isRunning && !isAddingTodo
+    }
+  )), userMessageStatus && /* @__PURE__ */ React5.createElement(
+    Text5,
+    {
+      color: userMessageStatus.type === "success" ? "green" : userMessageStatus.type === "error" ? "red" : "yellow"
+    },
+    userMessageStatus.text
+  ), /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "\u2500".repeat(columns))), /* @__PURE__ */ React5.createElement(Box3, { marginTop: 1, justifyContent: "space-between" }, isWatching ? detectedIssue ? /* @__PURE__ */ React5.createElement(Text5, { color: "green" }, /* @__PURE__ */ React5.createElement(Spinner, { type: "dots" }), " New issue: ", /* @__PURE__ */ React5.createElement(Text5, { color: "yellow" }, detectedIssue.IssueID), detectedIssue.Title ? ` - ${detectedIssue.Title}` : "") : /* @__PURE__ */ React5.createElement(Text5, { color: "cyan" }, "Waiting for new issues ", /* @__PURE__ */ React5.createElement(Spinner, { type: "simpleDotsScrolling" })) : isPaused && !isRunning ? /* @__PURE__ */ React5.createElement(Text5, { color: "magenta" }, "\u23F8 Paused after round ", /* @__PURE__ */ React5.createElement(Text5, { color: "yellow" }, currentSession), " ", /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "(Ctrl-P to resume)")) : isRunning ? stopAfterCurrent ? /* @__PURE__ */ React5.createElement(Text5, { color: "yellow" }, /* @__PURE__ */ React5.createElement(Spinner, { type: "dots" }), " Stopping after round", " ", /* @__PURE__ */ React5.createElement(Text5, { color: "yellow" }, currentSession), " completes...", " ", /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "(Ctrl-S pressed)")) : isPaused ? /* @__PURE__ */ React5.createElement(Text5, { color: "magenta" }, /* @__PURE__ */ React5.createElement(Spinner, { type: "dots" }), " Pausing after round", " ", /* @__PURE__ */ React5.createElement(Text5, { color: "yellow" }, currentSession), " completes...", " ", /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "(Ctrl-P pressed)")) : /* @__PURE__ */ React5.createElement(Text5, { color: "cyan" }, /* @__PURE__ */ React5.createElement(Spinner, { type: "dots" }), " Running round ", /* @__PURE__ */ React5.createElement(Text5, { color: "yellow" }, currentSession), " ", "(max ", totalSessions, ")") : /* @__PURE__ */ React5.createElement(Text5, { color: "cyan" }, /* @__PURE__ */ React5.createElement(Spinner, { type: "simpleDotsScrolling" }), " Waiting for Ralph to start..."), progressData.type !== "none" && progressData.total > 0 && /* @__PURE__ */ React5.createElement(
+    ProgressBar,
+    {
+      completed: progressData.completed,
+      total: progressData.total,
+      repoName
+    }
+  )));
+};
+
+// src/components/ReplayLog.tsx
+import React8, { useState as useState5, useEffect as useEffect5 } from "react";
+import { Box as Box6, Text as Text8, useApp as useApp2 } from "ink";
+import { readFileSync as readFileSync6 } from "fs";
+
+// src/components/EventDisplay.tsx
+import React6, { useMemo, useState as useState4, useEffect as useEffect4, useRef as useRef2 } from "react";
+import { Box as Box4, Text as Text6, useInput as useInput3 } from "ink";
+
+// src/lib/formatSessionHeader.ts
+import chalk5 from "chalk";
+var formatSessionHeader = (session) => {
+  return chalk5.cyan.bold(`\u2500\u2500\u2500 Round ${session} \u2500\u2500\u2500`);
+};
+
+// src/components/processEvents.ts
+var processEvents2 = (events) => {
+  const assistantEvents = events.filter((event) => event.type === "assistant");
+  const messageMap = /* @__PURE__ */ new Map();
+  for (const event of assistantEvents) {
+    const message = event.message;
+    const messageId = message?.id;
+    const content = message?.content;
+    if (messageId && content) {
+      if (!messageMap.has(messageId)) {
+        messageMap.set(messageId, []);
+      }
+      messageMap.get(messageId).push(...content);
+    }
+  }
+  const mergedEvents = Array.from(messageMap.entries()).map(([messageId, allContent]) => {
+    const seenBlocks = /* @__PURE__ */ new Set();
+    const uniqueContent = [];
+    for (const block of allContent) {
+      const blockType = block.type;
+      let blockKey;
+      if (blockType === "tool_use") {
+        blockKey = `tool:${block.id}`;
+      } else if (blockType === "text") {
+        const text = block.text;
+        let isDuplicate = false;
+        for (const seenKey of seenBlocks) {
+          if (seenKey.startsWith("text:")) {
+            const seenText = seenKey.substring(5);
+            if (seenText.startsWith(text)) {
+              isDuplicate = true;
+              break;
+            } else if (text.startsWith(seenText)) {
+              seenBlocks.delete(seenKey);
+              const idx = uniqueContent.findIndex((b) => b.type === "text" && b.text === seenText);
+              if (idx >= 0) uniqueContent.splice(idx, 1);
+              break;
+            }
+          }
+        }
+        if (isDuplicate) continue;
+        blockKey = `text:${text}`;
+      } else {
+        blockKey = JSON.stringify(block);
+      }
+      if (!seenBlocks.has(blockKey)) {
+        seenBlocks.add(blockKey);
+        uniqueContent.push(block);
+      }
+    }
+    return {
+      type: "assistant",
+      message: {
+        id: messageId,
+        content: uniqueContent
+      }
+    };
+  });
+  return mergedEvents.flatMap((event) => eventToBlocks(event));
+};
+
+// src/components/blocksToLines.ts
+var blocksToLines = (blocks) => {
+  const lines = [];
+  for (const block of blocks) {
+    const blockLines = formatContentBlock(block);
+    lines.push(...blockLines);
+    lines.push("");
+  }
+  return lines;
+};
+
+// src/components/EventDisplay.tsx
+var EventDisplay = ({ events, session, completedSessions, height }) => {
+  const [scrollOffset, setScrollOffset] = useState4(0);
+  const userScrolledRef = useRef2(false);
+  const prevLineCountRef = useRef2(0);
+  const allLines = useMemo(() => {
+    const lines = [];
+    for (const completed of completedSessions) {
+      lines.push("");
+      lines.push("");
+      lines.push(formatSessionHeader(completed.session));
+      lines.push("");
+      const blocks = processEvents2(completed.events);
+      lines.push(...blocksToLines(blocks));
+    }
+    lines.push("");
+    lines.push("");
+    lines.push(formatSessionHeader(session));
+    lines.push("");
+    const currentBlocks = processEvents2(events);
+    lines.push(...blocksToLines(currentBlocks));
+    return lines;
+  }, [events, session, completedSessions]);
+  useEffect4(() => {
+    if (allLines.length > prevLineCountRef.current && !userScrolledRef.current) {
+      setScrollOffset(0);
+    }
+    prevLineCountRef.current = allLines.length;
+  }, [allLines.length]);
+  useInput3((input, key) => {
+    if (!height) return;
+    const maxOffset = Math.max(0, allLines.length - height);
+    const pageSize = Math.max(1, height - 2);
+    if (key.upArrow || input === "k") {
+      userScrolledRef.current = true;
+      setScrollOffset((prev) => Math.min(maxOffset, prev + 1));
+    } else if (key.downArrow || input === "j") {
+      const newOffset = Math.max(0, scrollOffset - 1);
+      setScrollOffset(newOffset);
+      if (newOffset === 0) {
+        userScrolledRef.current = false;
+      }
+    } else if (key.pageUp) {
+      userScrolledRef.current = true;
+      setScrollOffset((prev) => Math.min(maxOffset, prev + pageSize));
+    } else if (key.pageDown) {
+      const newOffset = Math.max(0, scrollOffset - pageSize);
+      setScrollOffset(newOffset);
+      if (newOffset === 0) {
+        userScrolledRef.current = false;
+      }
+    } else if (input === "g" && key.shift) {
+      setScrollOffset(0);
+      userScrolledRef.current = false;
+    } else if (input === "g") {
+      userScrolledRef.current = true;
+      setScrollOffset(maxOffset);
+    }
+  });
+  const visibleLines = useMemo(() => {
+    if (!height || allLines.length <= height) {
+      return allLines;
+    }
+    const endIndex = allLines.length - scrollOffset;
+    const startIndex = Math.max(0, endIndex - height);
+    return allLines.slice(startIndex, endIndex);
+  }, [allLines, height, scrollOffset]);
+  return /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column" }, visibleLines.map((line, index) => /* @__PURE__ */ React6.createElement(Text6, { key: index, wrap: "wrap" }, line || " ")));
+};
+
+// src/components/FullScreenLayout.tsx
+import React7 from "react";
+import { Box as Box5, Text as Text7 } from "ink";
+import BigText3 from "ink-big-text";
+import Gradient3 from "ink-gradient";
+
+// src/components/useContentHeight.ts
+var HEADER_HEIGHT = 5;
+var FOOTER_HEIGHT = 2;
+var BORDER_HEIGHT = 2;
+var useContentHeight = (hasFooter = true) => {
+  const { rows } = useTerminalSize();
+  const footerHeight = hasFooter ? FOOTER_HEIGHT : 0;
+  return Math.max(1, rows - HEADER_HEIGHT - footerHeight - BORDER_HEIGHT);
+};
+
+// src/components/FullScreenLayout.tsx
+var FullScreenLayout = ({ title, children, footer, version }) => {
+  const { columns, rows } = useTerminalSize();
+  const contentHeight = useContentHeight(!!footer);
+  return /* @__PURE__ */ React7.createElement(
+    Box5,
+    {
+      flexDirection: "column",
+      width: columns,
+      height: rows,
+      borderStyle: "round",
+      borderColor: "gray"
+    },
+    /* @__PURE__ */ React7.createElement(
+      Box5,
+      {
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        height: HEADER_HEIGHT,
+        borderStyle: "single",
+        borderTop: false,
+        borderLeft: false,
+        borderRight: false,
+        borderColor: "gray"
+      },
+      /* @__PURE__ */ React7.createElement(Gradient3, { colors: ["#30A6E4", "#EBC635"] }, /* @__PURE__ */ React7.createElement(BigText3, { text: title, font: "tiny" }))
+    ),
+    /* @__PURE__ */ React7.createElement(
+      Box5,
+      {
+        flexDirection: "column",
+        flexGrow: 1,
+        paddingX: 1,
+        height: contentHeight,
+        overflowY: "hidden"
+      },
+      children
+    ),
+    footer && /* @__PURE__ */ React7.createElement(
+      Box5,
+      {
+        paddingX: 1,
+        height: FOOTER_HEIGHT,
+        borderStyle: "single",
+        borderTop: true,
+        borderBottom: false,
+        borderLeft: false,
+        borderRight: false,
+        borderColor: "gray",
+        alignItems: "center",
+        justifyContent: "space-between"
+      },
+      /* @__PURE__ */ React7.createElement(Box5, null, footer),
+      version && /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, version)
+    )
+  );
+};
+
+// src/components/ReplayLog.tsx
+var ReplayLog = ({
+  /** The path to the replay log file */
+  filePath
+}) => {
+  const { exit } = useApp2();
+  const [events, setEvents] = useState5([]);
+  const [error, setError] = useState5();
+  useEffect5(() => {
+    try {
+      const content = readFileSync6(filePath, "utf-8");
+      const eventStrings = content.split(/\n\n+/).filter((s) => s.trim());
+      const parsedEvents = [];
+      for (const eventStr of eventStrings) {
+        try {
+          const event = JSON.parse(eventStr);
+          parsedEvents.push(event);
+        } catch {
+        }
+      }
+      setEvents(parsedEvents);
+      setTimeout(() => {
+        exit();
+        process.exit(0);
+      }, 100);
+    } catch (err) {
+      setError(`Failed to read replay file: ${err instanceof Error ? err.message : String(err)}`);
+      setTimeout(() => {
+        exit();
+        process.exit(1);
+      }, 100);
+    }
+  }, [filePath, exit]);
+  if (error) {
+    return /* @__PURE__ */ React8.createElement(Box6, { flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text8, { color: "red" }, error));
+  }
+  const footer = /* @__PURE__ */ React8.createElement(Text8, { dimColor: true }, "Replaying: ", filePath);
+  const contentHeight = useContentHeight(true);
+  return /* @__PURE__ */ React8.createElement(FullScreenLayout, { title: "Ralph", footer }, /* @__PURE__ */ React8.createElement(EventDisplay, { events, session: 1, completedSessions: [], height: contentHeight }));
+};
+
+// src/components/JsonOutput.tsx
+import React9, { useState as useState6, useEffect as useEffect6, useRef as useRef3 } from "react";
+import { useApp as useApp3, Text as Text9 } from "ink";
+import { writeFileSync as writeFileSync3, readFileSync as readFileSync7, existsSync as existsSync9 } from "fs";
+import { join as join11, basename as basename2 } from "path";
+import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
+
+// src/lib/parseStdinCommand.ts
+var log3 = createDebugLogger("stdin-command");
+var parseStdinCommand = (line) => {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed !== "object" || parsed === null) {
+      log3(`Invalid command - not an object: ${trimmed}`);
+      return null;
+    }
+    if (parsed.type === "message") {
+      if (typeof parsed.text !== "string") {
+        log3(`Invalid message command - missing or invalid text: ${trimmed}`);
+        return null;
+      }
+      return { type: "message", text: parsed.text };
+    }
+    if (parsed.type === "stop") {
+      return { type: "stop" };
+    }
+    if (parsed.type === "pause") {
+      return { type: "pause" };
+    }
+    if (parsed.type === "resume") {
+      return { type: "resume" };
+    }
+    log3(`Unknown command type: ${parsed.type}`);
+    return null;
+  } catch (err) {
+    log3(`Failed to parse command: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+};
+
+// src/lib/createStdinCommandHandler.ts
+import { createInterface } from "readline";
+var log4 = createDebugLogger("stdin-command");
+var createStdinCommandHandler = (getOptions) => {
+  if (process.stdin.isTTY) {
+    log4(`stdin is TTY - skipping stdin command handler`);
+    return () => {
+    };
+  }
+  log4(`Setting up stdin command handler`);
+  const rl = createInterface({
+    input: process.stdin,
+    terminal: false
+  });
+  const lineHandler = (line) => {
+    const command = parseStdinCommand(line);
+    if (!command) return;
+    const options = getOptions();
+    log4(`Received command: ${command.type}`);
+    if (command.type === "message") {
+      if (options.messageQueue) {
+        const userMessage = createUserMessage(command.text);
+        options.messageQueue.push(userMessage);
+        log4(`Pushed message to queue: ${command.text.slice(0, 50)}...`);
+        options.onMessage?.(command.text);
+      } else {
+        log4(`Cannot send message - no active message queue`);
+      }
+    } else if (command.type === "stop") {
+      log4(`Stop command received`);
+      options.onStop();
+    } else if (command.type === "pause") {
+      log4(`Pause command received`);
+      options.onPause?.();
+    } else if (command.type === "resume") {
+      log4(`Resume command received`);
+      options.onResume?.();
+    }
+  };
+  rl.on("line", lineHandler);
+  return () => {
+    log4(`Cleaning up stdin command handler`);
+    rl.off("line", lineHandler);
+    rl.close();
+  };
+};
+
+// src/lib/outputEvent.ts
+var outputEvent = (event) => {
+  process.stdout.write(JSON.stringify(event) + "\n");
+};
+
+// src/components/JsonOutput.tsx
+var log5 = createDebugLogger("session");
+var todoFile6 = join11(process.cwd(), ".ralph", "todo.md");
+var repoName2 = basename2(process.cwd());
+var JsonOutput = ({ totalSessions, agent }) => {
+  const { exit } = useApp3();
+  const [currentSession, setCurrentSession] = useState6(1);
+  const [error, setError] = useState6();
+  const [isRunning, setIsRunning] = useState6(false);
+  const [startupSnapshot] = useState6(() => captureStartupSnapshot());
+  const messageQueueRef = useRef3(null);
+  const logFileRef = useRef3(null);
+  const [stopAfterCurrent, setStopAfterCurrent] = useState6(false);
+  const stopAfterCurrentRef = useRef3(false);
+  const [isPaused, setIsPaused] = useState6(false);
+  const isPausedRef = useRef3(false);
+  const stdinCleanupRef = useRef3(null);
+  const currentTaskIdRef = useRef3(null);
+  const currentTaskTitleRef = useRef3(null);
+  useEffect6(() => {
+    stopAfterCurrentRef.current = stopAfterCurrent;
+  }, [stopAfterCurrent]);
+  useEffect6(() => {
+    isPausedRef.current = isPaused;
+  }, [isPaused]);
+  useEffect6(() => {
+    const cleanup = createStdinCommandHandler(() => ({
+      messageQueue: messageQueueRef.current,
+      onStop: () => {
+        setStopAfterCurrent(true);
+        outputEvent({ type: "ralph_stop_requested" });
+      },
+      onPause: () => {
+        setIsPaused(true);
+        outputEvent({ type: "ralph_pause_requested" });
+      },
+      onResume: () => {
+        const wasPaused = isPausedRef.current;
+        setIsPaused(false);
+        outputEvent({ type: "ralph_resumed" });
+        if (wasPaused && !isRunning) {
+          setTimeout(() => setCurrentSession((i) => i + 1), 100);
+        }
+      },
+      onMessage: (text) => {
+        outputEvent({
+          type: "ralph_message_received",
+          text: text.slice(0, 100) + (text.length > 100 ? "..." : "")
+        });
+      }
+    }));
+    stdinCleanupRef.current = cleanup;
+    return () => {
+      cleanup();
+      stdinCleanupRef.current = null;
+    };
+  }, []);
+  useEffect6(() => {
+    if (currentSession > totalSessions) {
+      outputEvent({ type: "ralph_exit", reason: "max_sessions" });
+      exit();
+      return;
+    }
+    const currentProgress = startupSnapshot ? getProgress(startupSnapshot.initialCount, startupSnapshot.timestamp) : { type: "none", completed: 0, total: 0 };
+    if (currentProgress.completed >= currentProgress.total && currentProgress.type !== "none") {
+      outputEvent({ type: "ralph_exit", reason: "all_tasks_complete" });
+      exit();
+      process.exit(0);
+      return;
+    }
+    if (!logFileRef.current) {
+      logFileRef.current = getNextLogFile();
+      writeFileSync3(logFileRef.current, "");
+    }
+    const promptContent = getPromptContent();
+    const todoExists = existsSync9(todoFile6);
+    const todoContent = todoExists ? readFileSync7(todoFile6, "utf-8") : "";
+    const fullPrompt = todoContent ? `${promptContent}
+
+## Current Todo List
+
+${todoContent}` : promptContent;
+    const abortController = new AbortController();
+    setIsRunning(true);
+    outputEvent({
+      type: "ralph_session_start",
+      session: currentSession,
+      totalSessions,
+      repo: repoName2,
+      taskId: currentTaskIdRef.current,
+      taskTitle: currentTaskTitleRef.current
+    });
+    const messageQueue = new MessageQueue();
+    messageQueueRef.current = messageQueue;
+    messageQueue.push(createUserMessage(fullPrompt));
+    const runQuery = async () => {
+      let finalResult = "";
+      log5(`Starting session ${currentSession}`);
+      try {
+        log5(`Beginning query() loop`);
+        for await (const message of query2({
+          prompt: messageQueue,
+          options: {
+            abortController,
+            permissionMode: "bypassPermissions",
+            allowDangerouslySkipPermissions: true,
+            includePartialMessages: false,
+            // Only complete messages for JSON output
+            env: {
+              ...process.env,
+              // Disable LSP plugins to avoid crashes when TypeScript LSP server errors
+              ENABLE_LSP_TOOL: "0"
+            }
+          }
+        })) {
+          log5(`Received message type: ${message.type}`);
+          outputEvent(message);
+          if (message.type === "assistant") {
+            const assistantMessage = message.message;
+            const content = assistantMessage?.content;
+            if (content) {
+              for (const block of content) {
+                if (block.type === "text" && typeof block.text === "string") {
+                  const taskInfo = parseTaskLifecycleEvent(block.text);
+                  if (taskInfo) {
+                    if (taskInfo.action === "starting") {
+                      currentTaskIdRef.current = taskInfo.taskId ?? null;
+                      currentTaskTitleRef.current = taskInfo.taskTitle ?? null;
+                      log5(
+                        `Task started: ${taskInfo.taskId}${taskInfo.taskTitle ? ` - ${taskInfo.taskTitle}` : ""}`
+                      );
+                      outputEvent({
+                        type: "ralph_task_started",
+                        taskId: taskInfo.taskId,
+                        taskTitle: taskInfo.taskTitle,
+                        session: currentSession
+                      });
+                    } else if (taskInfo.action === "completed") {
+                      log5(
+                        `Task completed: ${taskInfo.taskId}${taskInfo.taskTitle ? ` - ${taskInfo.taskTitle}` : ""}`
+                      );
+                      outputEvent({
+                        type: "ralph_task_completed",
+                        taskId: taskInfo.taskId,
+                        taskTitle: taskInfo.taskTitle,
+                        session: currentSession
+                      });
+                    }
+                  }
+                }
+              }
+            }
+          }
+          if (message.type === "result" && "result" in message && typeof message.result === "string") {
+            log5(`Received result message`);
+            finalResult = message.result;
+            log5(`Closing message queue on result`);
+            messageQueue.close();
+          }
+        }
+        log5(`query() loop completed normally`);
+        setIsRunning(false);
+        log5(`Ensuring message queue is closed`);
+        messageQueue.close();
+        messageQueueRef.current = null;
+        outputEvent({
+          type: "ralph_session_end",
+          session: currentSession,
+          taskId: currentTaskIdRef.current,
+          taskTitle: currentTaskTitleRef.current
+        });
+        if (stopAfterCurrentRef.current) {
+          log5(`Stop after current requested - exiting gracefully`);
+          outputEvent({ type: "ralph_exit", reason: "stop_requested" });
+          exit();
+          process.exit(0);
+          return;
+        }
+        if (finalResult.includes("<promise>COMPLETE</promise>")) {
+          outputEvent({ type: "ralph_exit", reason: "task_complete" });
+          exit();
+          process.exit(0);
+          return;
+        }
+        if (isPausedRef.current) {
+          log5(`Paused after session ${currentSession}`);
+          outputEvent({ type: "ralph_paused", session: currentSession });
+          return;
+        }
+        setTimeout(() => setCurrentSession((i) => i + 1), 500);
+      } catch (err) {
+        log5(`query() loop error: ${err instanceof Error ? err.message : String(err)}`);
+        setIsRunning(false);
+        log5(`Closing message queue after error`);
+        messageQueue.close();
+        messageQueueRef.current = null;
+        if (abortController.signal.aborted) {
+          log5(`Abort signal detected`);
+          return;
+        }
+        const errorMsg = `Error running Claude: ${err instanceof Error ? err.message : String(err)}`;
+        setError(errorMsg);
+        outputEvent({ type: "ralph_error", error: errorMsg });
+        setTimeout(() => {
+          exit();
+          process.exit(1);
+        }, 100);
+      }
+    };
+    runQuery();
+    return () => {
+      log5(`Cleanup: aborting and closing queue for session ${currentSession}`);
+      abortController.abort();
+      messageQueue.close();
+      messageQueueRef.current = null;
+    };
+  }, [currentSession, totalSessions, exit, startupSnapshot]);
+  if (error) {
+    return /* @__PURE__ */ React9.createElement(Text9, null, "");
+  }
+  return /* @__PURE__ */ React9.createElement(Text9, null, "");
+};
+
+// src/components/App.tsx
+var App = ({
+  sessions,
+  replayFile,
+  claudeVersion,
+  ralphVersion,
+  watch,
+  json,
+  agent
+}) => {
+  if (replayFile) {
+    return /* @__PURE__ */ React10.createElement(ReplayLog, { filePath: replayFile });
+  }
+  if (json) {
+    return /* @__PURE__ */ React10.createElement(JsonOutput, { totalSessions: sessions, agent });
+  }
+  return /* @__PURE__ */ React10.createElement(
+    SessionRunner,
+    {
+      totalSessions: sessions,
+      claudeVersion,
+      ralphVersion,
+      watch,
+      agent
+    }
+  );
+};
+
+// src/components/InitRalph.tsx
+import { Text as Text10, Box as Box7 } from "ink";
+import React11, { useEffect as useEffect7, useState as useState7 } from "react";
+import { existsSync as existsSync11, readFileSync as readFileSync8, appendFileSync as appendFileSync2, writeFileSync as writeFileSync4 } from "fs";
+import { join as join13, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/lib/copyTemplates.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync2, copyFileSync } from "fs";
+import { join as join12, dirname as dirname2 } from "path";
+function copyTemplates(templatesDir, destDir, files) {
+  const result = { created: [], skipped: [], errors: [] };
+  for (const { src, dest } of files) {
+    const srcPath = join12(templatesDir, src);
+    const destPath = join12(destDir, dest);
+    const destDirPath = dirname2(destPath);
+    if (!existsSync10(destDirPath)) {
+      mkdirSync2(destDirPath, { recursive: true });
+    }
+    if (existsSync10(destPath)) {
+      result.skipped.push(dest);
+    } else if (existsSync10(srcPath)) {
+      copyFileSync(srcPath, destPath);
+      result.created.push(dest);
+    } else {
+      result.errors.push(`Template not found: ${src}`);
+    }
+  }
+  return result;
+}
+
+// src/components/InitRalph.tsx
+function InitRalph() {
+  const __dirname = dirname3(fileURLToPath2(import.meta.url));
+  const [status, setStatus] = useState7("checking");
+  const [createdFiles, setCreatedFiles] = useState7([]);
+  const [skippedFiles, setSkippedFiles] = useState7([]);
+  const [errors, setErrors] = useState7([]);
+  useEffect7(() => {
+    const ralphDir6 = join13(process.cwd(), ".ralph");
+    const claudeDir = join13(process.cwd(), ".claude");
+    if (existsSync11(join13(ralphDir6, "workflow.md"))) {
+      setStatus("exists");
+      return;
+    }
+    const initialize = async () => {
+      const templatesDir = join13(__dirname, "..", "..", "templates");
+      setStatus("creating");
+      try {
+        const allCreated = [];
+        const allSkipped = [];
+        const allErrors = [];
+        const ralphResult = copyTemplates(templatesDir, ralphDir6, [
+          { src: "workflow.md", dest: "workflow.md" }
+        ]);
+        allCreated.push(...ralphResult.created.map((f) => `.ralph/${f}`));
+        allSkipped.push(...ralphResult.skipped.map((f) => `.ralph/${f}`));
+        allErrors.push(...ralphResult.errors);
+        const skillsResult = copyTemplates(templatesDir, claudeDir, [
+          { src: "skills/manage-tasks/SKILL.md", dest: "skills/manage-tasks/SKILL.md" }
+        ]);
+        allCreated.push(...skillsResult.created.map((f) => `.claude/${f}`));
+        allSkipped.push(...skillsResult.skipped.map((f) => `.claude/${f}`));
+        allErrors.push(...skillsResult.errors);
+        const agentsResult = copyTemplates(templatesDir, claudeDir, [
+          { src: "agents/make-tests.md", dest: "agents/make-tests.md" },
+          { src: "agents/write-docs.md", dest: "agents/write-docs.md" },
+          { src: "agents/run-tests.md", dest: "agents/run-tests.md" }
+        ]);
+        allCreated.push(...agentsResult.created.map((f) => `.claude/${f}`));
+        allSkipped.push(...agentsResult.skipped.map((f) => `.claude/${f}`));
+        allErrors.push(...agentsResult.errors);
+        const gitignorePath = join13(process.cwd(), ".gitignore");
+        const eventsLogEntry = ".ralph/events-*.jsonl";
+        if (existsSync11(gitignorePath)) {
+          const content = readFileSync8(gitignorePath, "utf-8");
+          if (!content.includes(eventsLogEntry)) {
+            const newline = content.endsWith("\n") ? "" : "\n";
+            appendFileSync2(gitignorePath, `${newline}${eventsLogEntry}
+`);
+            allCreated.push("(added .ralph/events-*.jsonl to .gitignore)");
+          }
+        } else {
+          writeFileSync4(gitignorePath, `${eventsLogEntry}
+`);
+          allCreated.push("(created .gitignore with .ralph/events-*.jsonl)");
+        }
+        setCreatedFiles(allCreated);
+        setSkippedFiles(allSkipped);
+        setErrors(allErrors);
+        setStatus("done");
+        setTimeout(() => process.exit(0), 100);
+      } catch (error) {
+        setErrors([`Failed to initialize: ${error}`]);
+        setStatus("done");
+        setTimeout(() => process.exit(1), 100);
+      }
+    };
+    initialize();
+  }, []);
+  if (status === "checking") {
+    return /* @__PURE__ */ React11.createElement(Text10, null, "Checking directories...");
+  }
+  if (status === "exists") {
+    return /* @__PURE__ */ React11.createElement(Box7, { flexDirection: "column" }, /* @__PURE__ */ React11.createElement(Text10, { color: "yellow" }, "Ralph is already initialized"), /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "To reinitialize, remove the workflow first: rm .ralph/workflow.md"));
+  }
+  if (status === "creating") {
+    return /* @__PURE__ */ React11.createElement(Text10, { color: "cyan" }, "Initializing ralph...");
+  }
+  return /* @__PURE__ */ React11.createElement(Box7, { flexDirection: "column" }, createdFiles.map((file) => /* @__PURE__ */ React11.createElement(Text10, { key: file }, /* @__PURE__ */ React11.createElement(Text10, { color: "green" }, "\u2713"), " Created ", /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, file))), skippedFiles.map((file) => /* @__PURE__ */ React11.createElement(Text10, { key: file }, /* @__PURE__ */ React11.createElement(Text10, { color: "yellow" }, "\u25CB"), " Skipped ", /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, file), /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, " (already exists)"))), errors.map((error, i) => /* @__PURE__ */ React11.createElement(Text10, { key: i }, /* @__PURE__ */ React11.createElement(Text10, { color: "red" }, "\u2717"), " ", error)), errors.length === 0 && /* @__PURE__ */ React11.createElement(React11.Fragment, null, /* @__PURE__ */ React11.createElement(Text10, { color: "green" }, "\n", "Ralph initialized successfully!"), /* @__PURE__ */ React11.createElement(Text10, { bold: true }, "\n", "Next steps:"), /* @__PURE__ */ React11.createElement(Text10, null, /* @__PURE__ */ React11.createElement(Text10, { color: "cyan" }, " 1. Edit .ralph/workflow.md"), /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, " - Customize build commands for your project")), /* @__PURE__ */ React11.createElement(Text10, null, /* @__PURE__ */ React11.createElement(Text10, { color: "cyan" }, " 2. Initialize beads"), /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, " - Run `bd init` to set up the issue tracker")), /* @__PURE__ */ React11.createElement(Text10, null, /* @__PURE__ */ React11.createElement(Text10, { color: "cyan" }, " 3. Create issues"), /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, ' - Run `bd create --title="..." --type=task` to add work')), /* @__PURE__ */ React11.createElement(Text10, null, /* @__PURE__ */ React11.createElement(Text10, { bold: true }, "\n", "Then run: "), /* @__PURE__ */ React11.createElement(Text10, { color: "cyan" }, "ralph"), "\n")));
+}
+
+// src/lib/getClaudeVersion.ts
+import { execSync as execSync4 } from "child_process";
+var getClaudeVersion = () => {
+  try {
+    const output = execSync4("claude --version", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const match = output.match(/^([\d.]+)/);
+    return match ? match[1] : "unknown";
+  } catch {
+    return "unknown";
+  }
+};
+
+// src/lib/getOpenIssueCount.ts
+import { execSync as execSync5 } from "child_process";
+var getOpenIssueCount = () => {
+  try {
+    const output = execSync5("bd list --status=open --json", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const issues = JSON.parse(output);
+    return Array.isArray(issues) ? issues.length : 0;
+  } catch {
+    return 0;
+  }
+};
+
+// src/lib/getDefaultSessions.ts
+var getDefaultSessions = () => {
+  const openIssues = getOpenIssueCount();
+  if (openIssues === 0) {
+    return 10;
+  }
+  const calculated = Math.ceil(openIssues * 1.2);
+  return Math.max(10, Math.min(100, calculated));
+};
+
+// src/lib/getLatestLogFile.ts
+import { join as join14 } from "path";
+var getLatestLogFile = () => {
+  const maxNumber = findMaxLogNumber();
+  if (maxNumber === 0) {
+    return void 0;
+  }
+  const ralphDir6 = join14(process.cwd(), ".ralph");
+  return join14(ralphDir6, `events-${maxNumber}.jsonl`);
+};
+
+// package.json
+var package_default = {
+  name: "@herbcaudill/ralph",
+  version: "1.0.2",
+  description: "Autonomous AI session engine for Claude CLI",
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    ralph: "./bin/ralph.js"
+  },
+  files: [
+    "dist",
+    "bin",
+    "templates"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsc --watch",
+    typecheck: "tsc --noEmit",
+    ralph: "tsx src/index.ts",
+    "test:all": "pnpm typecheck && vitest run",
+    test: "vitest run",
+    "test:e2e": "vitest --config vitest.e2e.config.ts",
+    "test:watch": "vitest --watch",
+    "test:ui": "vitest --ui",
+    format: "prettier --write . --log-level silent",
+    prepublishOnly: "pnpm build"
+  },
+  keywords: [
+    "claude",
+    "ai",
+    "automation",
+    "cli",
+    "session",
+    "autonomous"
+  ],
+  author: "Herb Caudill",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/HerbCaudill/ralph.git"
+  },
+  dependencies: {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.7",
+    chalk: "^5.6.2",
+    commander: "^14.0.2",
+    ink: "^6.6.0",
+    "ink-big-text": "^2.0.0",
+    "ink-gradient": "^3.0.0",
+    "ink-select-input": "^6.2.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    react: "^19.2.3"
+  },
+  devDependencies: {
+    "@herbcaudill/ralph-shared": "workspace:*",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.8",
+    "@vitest/ui": "^4.0.17",
+    execa: "^9.6.1",
+    "ink-testing-library": "^4.0.0",
+    prettier: "^3.5.3",
+    tsup: "^8.5.1",
+    tsx: "^4.21.0",
+    typescript: "~5.9.3",
+    vitest: "^4.0.17"
+  },
+  engines: {
+    node: ">=18.0.0"
+  }
+};
+
+// src/cli.ts
+var program = new Command().name("ralph").description("Autonomous AI session engine for Claude CLI").version(package_default.version).argument(
+  "[sessions]",
+  "number of sessions (default: 120% of open issues, min 10, max 100)",
+  (val) => parseInt(val, 10)
+).option("--replay [file]", "replay events from log file").option("--watch", "watch for new beads issues after completion").option("--json", "output events as newline-delimited JSON to stdout").option("--agent <name>", "agent to use (e.g., claude, codex)", "claude").action(
+  (sessionsArg, options) => {
+    const sessions = sessionsArg ?? getDefaultSessions();
+    const replayFile = options.replay !== void 0 ? typeof options.replay === "string" ? options.replay : getLatestLogFile() : void 0;
+    const claudeVersion = getClaudeVersion();
+    const ralphVersion = package_default.version;
+    const watch = options.watch === true;
+    const json = options.json === true;
+    const agent = options.agent;
+    const validAgents = ["claude", "codex"];
+    if (!validAgents.includes(agent)) {
+      console.error(
+        `Error: Invalid agent "${agent}". Available agents: ${validAgents.join(", ")}`
+      );
+      process.exit(1);
+    }
+    if (!json) {
+      process.stdout.write("\x1B[2J\x1B[H");
+    }
+    render(
+      React12.createElement(App, {
+        sessions,
+        replayFile,
+        claudeVersion,
+        ralphVersion,
+        watch,
+        json,
+        agent
+      })
+    );
+  }
+);
+program.command("init").description("initialize .ralph directory with templates").action(() => {
+  render(React12.createElement(InitRalph));
+});
+program.command("todo [description...]").description("add a todo item and commit it (safe to use while ralph is running)").action(
+  async (descriptionParts) => {
+    let description = descriptionParts.join(" ").trim();
+    if (!description) {
+      const readline = await import("readline");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      description = await new Promise((resolve) => {
+        rl.question("Todo: ", (answer) => {
+          rl.close();
+          resolve(answer.trim());
+        });
+      });
+      if (!description) {
+        console.error("No todo description provided");
+        process.exit(1);
+      }
+    }
+    try {
+      addTodo(description);
+    } catch (error) {
+      console.error(`Failed to add todo: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+  }
+);
+
+// src/index.ts
+var run = () => {
+  program.parse(process.argv);
 };
-/**  Run if called directly as a script. */
 if (import.meta.url === `file://${process.argv[1]}`) {
-    run();
+  run();
 }
+export {
+  run
+};
 //# sourceMappingURL=index.js.map