@ulpi/cli 0.1.4 → 0.1.6

package/dist/chunk-SEU7WWNQ.js

@@ -0,0 +1,1251 @@
+import {
+  SESSIONS_DIR
+} from "./chunk-C7CLUQI6.js";
+
+// ../../packages/session-engine/dist/index.js
+import * as fs from "fs";
+import * as path from "path";
+import * as path2 from "path";
+import * as fs2 from "fs";
+import * as path3 from "path";
+import { execFileSync } from "child_process";
+import * as fs3 from "fs";
+import * as path4 from "path";
+function projectDirToSlug(dir) {
+  const slug = dir.replace(/^\//, "").replace(/\//g, "-").replace(/\./g, "_").replace(/-{2,}/g, "-").replace(/^-|-$/g, "").toLowerCase();
+  return slug || "unknown-project";
+}
+function validateSessionId(sessionId) {
+  if (!sessionId || sessionId.includes("..") || sessionId.includes("/") || sessionId.includes("\\")) {
+    throw new Error("Invalid session ID");
+  }
+  if (sessionId.length > 200) {
+    throw new Error("Session ID too long");
+  }
+  if (!/^[a-zA-Z0-9_-]+$/.test(sessionId)) {
+    throw new Error("Invalid session ID characters");
+  }
+}
+var JsonSessionStore = class {
+  baseDir;
+  projectSlug;
+  constructor(baseDir, projectDir) {
+    this.baseDir = baseDir ?? path.dirname(SESSIONS_DIR);
+    this.projectSlug = projectDir ? projectDirToSlug(projectDir) : null;
+  }
+  /**
+   * Load session state from disk.
+   * Returns `null` if the file does not exist or contains invalid JSON.
+   */
+  load(sessionId) {
+    validateSessionId(sessionId);
+    try {
+      const raw = fs.readFileSync(this.sessionPath(sessionId), "utf-8");
+      return JSON.parse(raw);
+    } catch {
+    }
+    if (this.projectSlug) {
+      try {
+        const flatPath = path.join(this.baseDir, "sessions", `${sessionId}.json`);
+        const raw = fs.readFileSync(flatPath, "utf-8");
+        return JSON.parse(raw);
+      } catch {
+      }
+    }
+    if (!this.projectSlug) {
+      try {
+        const sessionsDir = path.join(this.baseDir, "sessions");
+        const entries = fs.readdirSync(sessionsDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue;
+          try {
+            const subPath = path.join(sessionsDir, entry.name, `${sessionId}.json`);
+            const raw = fs.readFileSync(subPath, "utf-8");
+            return JSON.parse(raw);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  /**
+   * Persist session state atomically.
+   *
+   * The directory tree is created on demand. Data is first written to a
+   * temporary file adjacent to the target, then renamed so the operation
+   * is atomic on POSIX file-systems.
+   */
+  save(state) {
+    validateSessionId(state.sessionId);
+    const target = this.sessionPath(state.sessionId);
+    const dir = path.dirname(target);
+    fs.mkdirSync(dir, { recursive: true });
+    const tmp = `${target}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(state, null, 2), "utf-8");
+    fs.renameSync(tmp, target);
+  }
+  /**
+   * Delete a session's state file. Silently ignores missing files.
+   */
+  delete(sessionId) {
+    validateSessionId(sessionId);
+    try {
+      fs.unlinkSync(this.sessionPath(sessionId));
+      return;
+    } catch {
+    }
+    if (this.projectSlug) {
+      try {
+        fs.unlinkSync(path.join(this.baseDir, "sessions", `${sessionId}.json`));
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+      }
+    }
+  }
+  /**
+   * List all persisted session IDs by scanning the sessions directory.
+   */
+  list() {
+    if (this.projectSlug) {
+      return this.scanJsonFiles(path.join(this.baseDir, "sessions", this.projectSlug));
+    }
+    const base = path.join(this.baseDir, "sessions");
+    return [.../* @__PURE__ */ new Set([...this.scanJsonFiles(base), ...this.scanSubdirs(base)])];
+  }
+  /** Resolve the on-disk path for a given session ID. */
+  sessionPath(sessionId) {
+    if (this.projectSlug) {
+      return path.join(this.baseDir, "sessions", this.projectSlug, `${sessionId}.json`);
+    }
+    return path.join(this.baseDir, "sessions", `${sessionId}.json`);
+  }
+  /**
+   * List session IDs for a specific project directory.
+   * Returns sessions where state.projectDir matches the given path.
+   */
+  listByProject(projectDir) {
+    const slug = projectDirToSlug(projectDir);
+    const results = this.scanJsonFiles(path.join(this.baseDir, "sessions", slug));
+    const flatDir = path.join(this.baseDir, "sessions");
+    const normalizedTarget = path.resolve(projectDir);
+    for (const id of this.scanJsonFiles(flatDir)) {
+      if (results.includes(id)) continue;
+      try {
+        const raw = fs.readFileSync(path.join(flatDir, `${id}.json`), "utf-8");
+        const state = JSON.parse(raw);
+        if (path.resolve(state.projectDir) === normalizedTarget) {
+          results.push(id);
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  /**
+   * Get the most recent session for a specific project directory.
+   * Prefers sessions with actual activity over empty sessions.
+   * Returns null if no sessions found for the project.
+   */
+  getLatestForProject(projectDir) {
+    const sessionIds = this.listByProject(projectDir);
+    if (sessionIds.length === 0) {
+      return null;
+    }
+    let latest = null;
+    let latestTime = -Infinity;
+    let latestActive = null;
+    let latestActiveTime = -Infinity;
+    for (const id of sessionIds) {
+      const s = this.load(id);
+      if (!s) continue;
+      const t = new Date(s.startedAt).getTime();
+      if (t > latestTime) {
+        latestTime = t;
+        latest = s;
+      }
+      const hasActivity = s.filesRead.length > 0 || s.filesWritten.length > 0 || s.commandsRun.length > 0 || s.rulesEnforced > 0;
+      if (hasActivity && t > latestActiveTime) {
+        latestActiveTime = t;
+        latestActive = s;
+      }
+    }
+    return latestActive ?? latest;
+  }
+  // --- Iteration tracking (v2) ---
+  /**
+   * Add an iteration to a session's state.
+   * Creates the iterations array if it doesn't exist.
+   */
+  addIteration(sessionId, iteration) {
+    const state = this.load(sessionId);
+    if (!state) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    if (!state.iterations) {
+      state.iterations = [];
+    }
+    state.iterations.push(iteration);
+    state.activeIterationId = iteration.id;
+    this.save(state);
+  }
+  /**
+   * Update an existing iteration within a session.
+   * Merges the provided updates into the existing iteration.
+   */
+  updateIteration(sessionId, iterationId, updates) {
+    const state = this.load(sessionId);
+    if (!state || !state.iterations) {
+      throw new Error(`Session ${sessionId} not found or has no iterations`);
+    }
+    const index = state.iterations.findIndex((it) => it.id === iterationId);
+    if (index === -1) {
+      throw new Error(`Iteration ${iterationId} not found in session ${sessionId}`);
+    }
+    state.iterations[index] = { ...state.iterations[index], ...updates };
+    if (updates.status && updates.status !== "running" && updates.status !== "pending" && state.activeIterationId === iterationId) {
+      state.activeIterationId = void 0;
+    }
+    this.save(state);
+  }
+  /**
+   * Get all iterations for a specific task within a session.
+   */
+  getIterationsForTask(sessionId, taskId) {
+    const state = this.load(sessionId);
+    if (!state || !state.iterations) {
+      return [];
+    }
+    return state.iterations.filter((it) => it.taskId === taskId);
+  }
+  /**
+   * Get all iterations for a session.
+   */
+  getIterations(sessionId) {
+    const state = this.load(sessionId);
+    return state?.iterations ?? [];
+  }
+  scanJsonFiles(dir) {
+    try {
+      return fs.readdirSync(dir).filter((f) => f.endsWith(".json") && !f.endsWith(".tmp")).map((f) => f.replace(/\.json$/, ""));
+    } catch {
+      return [];
+    }
+  }
+  scanSubdirs(base) {
+    try {
+      const ids = [];
+      for (const entry of fs.readdirSync(base, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+          ids.push(...this.scanJsonFiles(path.join(base, entry.name)));
+        }
+      }
+      return ids;
+    } catch {
+      return [];
+    }
+  }
+};
+function createEmptyState(sessionId, projectDir) {
+  validateSessionId(sessionId);
+  if (!projectDir || typeof projectDir !== "string") {
+    throw new Error("Invalid project directory");
+  }
+  return {
+    sessionId,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    projectDir,
+    branch: void 0,
+    filesRead: [],
+    filesWritten: [],
+    filesDeleted: [],
+    commandsRun: [],
+    testsRun: false,
+    testsPassed: null,
+    lintRun: false,
+    lintPassed: null,
+    buildRun: false,
+    buildPassed: null,
+    formatterRun: false,
+    branchCreated: false,
+    planApproved: false,
+    rulesEnforced: 0,
+    actionsBlocked: 0,
+    autoActionsRun: 0,
+    consecutiveBlocks: 0,
+    lastNotifications: {},
+    stack: void 0,
+    phase: void 0,
+    transcriptPath: void 0,
+    untrackedFilesAtStart: void 0,
+    workingTreeDirtyAtStart: void 0
+  };
+}
+function createInitialState(sessionId, projectDir) {
+  return createEmptyState(sessionId, projectDir);
+}
+function generateIterationId() {
+  return `iter_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+function startIteration(taskId, agentType, agentModel) {
+  return {
+    id: generateIterationId(),
+    taskId,
+    agentType,
+    agentModel,
+    status: "running",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function completeIteration(iteration, result) {
+  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const duration = iteration.startedAt ? new Date(completedAt).getTime() - new Date(iteration.startedAt).getTime() : void 0;
+  return {
+    ...iteration,
+    status: result.status ?? (result.error ? "failed" : "completed"),
+    completedAt,
+    duration,
+    exitCode: result.exitCode,
+    tokenUsage: result.tokenUsage,
+    filesChanged: result.filesChanged,
+    commitSha: result.commitSha,
+    outputSummary: result.outputSummary,
+    error: result.error
+  };
+}
+function updateStateFromInput(state, input, config) {
+  const next = {
+    ...state,
+    filesRead: [...state.filesRead],
+    filesWritten: [...state.filesWritten],
+    filesDeleted: [...state.filesDeleted],
+    commandsRun: [...state.commandsRun],
+    lastNotifications: { ...state.lastNotifications }
+  };
+  const toolName = input.tool_name;
+  const toolInput = input.tool_input;
+  const toolResponse = input.tool_response;
+  if (toolName === "Read" && toolInput?.file_path) {
+    const norm = normalizePath(toolInput.file_path, next.projectDir);
+    if (!next.filesRead.includes(norm)) {
+      next.filesRead.push(norm);
+    }
+  }
+  if ((toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit") && toolInput?.file_path) {
+    const norm = normalizePath(toolInput.file_path, next.projectDir);
+    if (!next.filesWritten.includes(norm)) {
+      next.filesWritten.push(norm);
+    }
+  }
+  if (toolName === "Bash" && toolInput?.command) {
+    const cmd = toolInput.command;
+    next.commandsRun.push(cmd);
+    trackDeletedFiles(cmd, next);
+    if (isBranchCreationCommand(cmd)) {
+      next.branchCreated = true;
+      next.branch = extractBranchName(cmd) ?? next.branch;
+    }
+    const passed = didCommandPass(toolResponse);
+    if (isTestCommand(cmd, config)) {
+      next.testsRun = true;
+      if (passed !== null) {
+        next.testsPassed = passed;
+      }
+    }
+    if (isLintCommand(cmd, config)) {
+      next.lintRun = true;
+      if (passed !== null) {
+        next.lintPassed = passed;
+      }
+    }
+    if (isBuildCommand(cmd, config)) {
+      next.buildRun = true;
+      if (passed !== null) {
+        next.buildPassed = passed;
+      }
+    }
+    if (isFormatCommand(cmd, config)) {
+      next.formatterRun = true;
+    }
+  }
+  return next;
+}
+var TEST_PATTERNS = [
+  /\bjest\b/,
+  /\bvitest\b/,
+  /\bpytest\b/,
+  /\bgo\s+test\b/,
+  /\bcargo\s+test\b/,
+  /\bphpunit\b/,
+  /\bpest\b/,
+  /\brspec\b/,
+  /\bmocha\b/,
+  /\bava\b/,
+  /\bnpm\s+run\s+test\b/,
+  /\bpnpm\s+(run\s+)?test\b/,
+  /\byarn\s+(run\s+)?test\b/,
+  /\bbun\s+test\b/,
+  /\bmake\s+test\b/
+];
+var LINT_PATTERNS = [
+  /\beslint\b/,
+  /\btsc\s+--noEmit\b/,
+  /\btsc\b.*--noEmit\b/,
+  /\bruff\s+check\b/,
+  /\bruff\s+lint\b/,
+  /\bcargo\s+clippy\b/,
+  /\bphpstan\b/,
+  /\bpylint\b/,
+  /\bflake8\b/,
+  /\bmypy\b/,
+  /\bgolangci-lint\b/,
+  /\brubocop\b/,
+  /\bnpm\s+run\s+lint\b/,
+  /\bpnpm\s+(run\s+)?lint\b/,
+  /\byarn\s+(run\s+)?lint\b/
+];
+var BUILD_PATTERNS = [
+  /\bnpm\s+run\s+build\b/,
+  /\bpnpm\s+(run\s+)?build\b/,
+  /\byarn\s+(run\s+)?build\b/,
+  /\bcargo\s+build\b/,
+  /\bgo\s+build\b/,
+  /\bmake\s+build\b/,
+  /\bmake\b(?!.*test|.*lint|.*format)/,
+  /\btsc\b(?!.*--noEmit)/,
+  /\bvite\s+build\b/,
+  /\bnext\s+build\b/
+];
+var FORMAT_PATTERNS = [
+  /\bprettier\b/,
+  /\bblack\b/,
+  /\bruff\s+format\b/,
+  /\bgofmt\b/,
+  /\bgoimports\b/,
+  /\brustfmt\b/,
+  /\bphp-cs-fixer\b/,
+  /\bpint\b/,
+  /\bnpm\s+run\s+format\b/,
+  /\bpnpm\s+(run\s+)?format\b/,
+  /\byarn\s+(run\s+)?format\b/
+];
+function matchesPatterns(command, patterns, configCommand) {
+  if (configCommand && command.includes(configCommand)) {
+    return true;
+  }
+  return patterns.some((p) => p.test(command));
+}
+function isTestCommand(command, config) {
+  return matchesPatterns(command, TEST_PATTERNS, config?.test_command);
+}
+function isLintCommand(command, config) {
+  return matchesPatterns(command, LINT_PATTERNS, config?.lint_command);
+}
+function isBuildCommand(command, config) {
+  return matchesPatterns(command, BUILD_PATTERNS, config?.build_command);
+}
+function isFormatCommand(command, config) {
+  return matchesPatterns(command, FORMAT_PATTERNS, config?.format_command);
+}
+var BRANCH_CREATION_RE = /\bgit\s+(?:checkout\s+-b|switch\s+-c|branch)\s+/;
+function isBranchCreationCommand(command) {
+  return BRANCH_CREATION_RE.test(command);
+}
+function extractBranchName(command) {
+  const cbMatch = command.match(
+    /\bgit\s+(?:checkout\s+-b|switch\s+-c)\s+(\S+)/
+  );
+  if (cbMatch) return cbMatch[1];
+  const brMatch = command.match(/\bgit\s+branch\s+(?!-\w)(\S+)/);
+  if (brMatch) return brMatch[1];
+  return void 0;
+}
+function trackDeletedFiles(command, state) {
+  const rmMatch = command.match(/\brm\s+(.*)/);
+  if (!rmMatch) return;
+  const args = rmMatch[1].split(/\s+/).filter((a) => {
+    return a.length > 0 && !a.startsWith("-");
+  });
+  for (const arg of args) {
+    const norm = normalizePath(arg, state.projectDir);
+    if (!state.filesDeleted.includes(norm)) {
+      state.filesDeleted.push(norm);
+    }
+  }
+}
+function normalizePath(filePath, projectDir) {
+  let normalized = filePath;
+  if (path2.isAbsolute(normalized)) {
+    const prefix = projectDir.endsWith(path2.sep) ? projectDir : projectDir + path2.sep;
+    if (normalized.startsWith(prefix)) {
+      normalized = normalized.slice(prefix.length);
+    }
+  }
+  normalized = normalized.replace(/^\.\//, "");
+  return normalized;
+}
+function didCommandPass(response) {
+  if (!response) return null;
+  if (typeof response.exit_code === "number") {
+    return response.exit_code === 0;
+  }
+  if (typeof response.success === "boolean") {
+    return response.success;
+  }
+  return null;
+}
+var MAX_EVENTS_PER_SESSION = 1e4;
+function eventLogPath(sessionId, baseDir, projectDir) {
+  if (projectDir) {
+    const slug = projectDirToSlug(projectDir);
+    return path3.join(baseDir, "sessions", slug, `${sessionId}.events.jsonl`);
+  }
+  return path3.join(baseDir, "sessions", `${sessionId}.events.jsonl`);
+}
+function countFilePath(logPath) {
+  return logPath + ".count";
+}
+function readEventCount(logPath) {
+  const countPath = countFilePath(logPath);
+  try {
+    const raw = fs2.readFileSync(countPath, "utf-8").trim();
+    const count2 = parseInt(raw, 10);
+    if (!Number.isNaN(count2) && count2 >= 0) {
+      return count2;
+    }
+  } catch {
+  }
+  let count = 0;
+  try {
+    const existing = fs2.readFileSync(logPath, "utf-8");
+    count = existing.split("\n").filter((l) => l.trim().length > 0).length;
+  } catch {
+  }
+  try {
+    fs2.writeFileSync(countPath, String(count), "utf-8");
+  } catch {
+  }
+  return count;
+}
+function writeEventCount(logPath, count) {
+  try {
+    fs2.writeFileSync(countFilePath(logPath), String(count), "utf-8");
+  } catch {
+  }
+}
+function appendEvent(sessionId, event, projectDir, baseDir) {
+  validateSessionId(sessionId);
+  const dir = baseDir ?? path3.dirname(SESSIONS_DIR);
+  const logPath = eventLogPath(sessionId, dir, projectDir);
+  const currentCount = readEventCount(logPath);
+  if (currentCount >= MAX_EVENTS_PER_SESSION) {
+    console.error(
+      `[ulpi] Session ${sessionId}: event log at capacity (${MAX_EVENTS_PER_SESSION}), dropping new events`
+    );
+    return;
+  }
+  fs2.mkdirSync(path3.dirname(logPath), { recursive: true });
+  fs2.appendFileSync(logPath, JSON.stringify(event) + "\n", "utf-8");
+  writeEventCount(logPath, currentCount + 1);
+}
+function readEvents(sessionId, projectDir, baseDir) {
+  validateSessionId(sessionId);
+  const dir = baseDir ?? path3.dirname(SESSIONS_DIR);
+  const logPath = eventLogPath(sessionId, dir, projectDir);
+  let raw;
+  try {
+    raw = fs2.readFileSync(logPath, "utf-8");
+  } catch {
+    if (projectDir) {
+      const flatPath = eventLogPath(sessionId, dir);
+      try {
+        raw = fs2.readFileSync(flatPath, "utf-8");
+      } catch {
+        return [];
+      }
+    } else {
+      return [];
+    }
+  }
+  const events = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    try {
+      events.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return events;
+}
+function nextPhase(current, hookEvent, context) {
+  switch (current) {
+    case "idle":
+      if (hookEvent === "SessionStart") {
+        return { phase: "active" };
+      }
+      break;
+    case "active":
+      if (hookEvent === "PostToolUse" && context?.hasNewCommit) {
+        return { phase: "active_committed", sideEffect: "capture" };
+      }
+      if (hookEvent === "SessionEnd") {
+        return { phase: "ended" };
+      }
+      break;
+    case "active_committed":
+      if (hookEvent === "PostToolUse" && context?.hasNewCommit) {
+        return { phase: "active_committed", sideEffect: "capture" };
+      }
+      if (hookEvent === "SessionEnd") {
+        return { phase: "ended" };
+      }
+      break;
+    case "ended":
+      break;
+  }
+  return { phase: current };
+}
+function detectNewCommit(projectDir, lastKnownHead) {
+  try {
+    const currentHead = execFileSync("git", ["rev-parse", "HEAD"], {
+      cwd: projectDir,
+      encoding: "utf-8",
+      timeout: 3e3
+    }).toString().trim();
+    if (currentHead && currentHead !== lastKnownHead) {
+      return { hasNewCommit: true, newHead: currentHead };
+    }
+    return { hasNewCommit: false, newHead: null };
+  } catch {
+    return { hasNewCommit: false, newHead: null };
+  }
+}
+var SessionEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  maxListeners = 50;
+  /**
+   * Subscribe to all events or a specific event type.
+   *
+   * @param eventType - Event type to listen for, or "*" for all events
+   * @param listener - Callback function
+   * @returns Unsubscribe function
+   */
+  on(eventType, listener) {
+    const key = eventType;
+    let set = this.listeners.get(key);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(key, set);
+    }
+    if (set.size >= this.maxListeners) {
+      console.error(
+        `[ulpi] Warning: SessionEventEmitter has ${set.size} listeners for "${key}". Possible memory leak.`
+      );
+    }
+    set.add(listener);
+    return () => {
+      set?.delete(listener);
+      if (set?.size === 0) {
+        this.listeners.delete(key);
+      }
+    };
+  }
+  /**
+   * Subscribe to an event type, but only fire once.
+   */
+  once(eventType, listener) {
+    const unsubscribe = this.on(eventType, (event) => {
+      unsubscribe();
+      listener(event);
+    });
+    return unsubscribe;
+  }
+  /**
+   * Emit an event to all matching listeners.
+   * Each listener is wrapped in try/catch so one failure doesn't affect others.
+   *
+   * @param event - The session event to emit
+   */
+  emit(event) {
+    const specificListeners = this.listeners.get(event.event);
+    if (specificListeners) {
+      for (const listener of specificListeners) {
+        try {
+          listener(event);
+        } catch (err) {
+          console.error(
+            `[ulpi] SessionEventEmitter listener error for "${event.event}":`,
+            err instanceof Error ? err.message : String(err)
+          );
+        }
+      }
+    }
+    const wildcardListeners = this.listeners.get("*");
+    if (wildcardListeners) {
+      for (const listener of wildcardListeners) {
+        try {
+          listener(event);
+        } catch (err) {
+          console.error(
+            `[ulpi] SessionEventEmitter wildcard listener error:`,
+            err instanceof Error ? err.message : String(err)
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Remove all listeners for a specific event type, or all listeners.
+   */
+  removeAllListeners(eventType) {
+    if (eventType) {
+      this.listeners.delete(eventType);
+    } else {
+      this.listeners.clear();
+    }
+  }
+  /**
+   * Get the number of listeners for a specific event type.
+   */
+  listenerCount(eventType) {
+    return this.listeners.get(eventType)?.size ?? 0;
+  }
+  /**
+   * Set the maximum number of listeners per event type.
+   */
+  setMaxListeners(n) {
+    this.maxListeners = n;
+  }
+};
+var MAX_LIVE_OUTPUT = 25e4;
+var MAX_HISTORY_OUTPUT = 1e5;
+var TRUNCATED_PREFIX = "[...output truncated";
+function appendWithCharLimit(current, chunk, maxChars) {
+  const combined = current + chunk;
+  if (combined.length <= maxChars) {
+    return combined;
+  }
+  const omitted = combined.length - maxChars;
+  const prefix = `${TRUNCATED_PREFIX} (${omitted} chars omitted)...]
+`;
+  const tail = combined.slice(combined.length - maxChars + prefix.length);
+  return prefix + tail;
+}
+var OutputBuffer = class {
+  liveBuffer = "";
+  historyBuffer = "";
+  liveLimit;
+  historyLimit;
+  totalCharsReceived = 0;
+  constructor(liveLimit = MAX_LIVE_OUTPUT, historyLimit = MAX_HISTORY_OUTPUT) {
+    this.liveLimit = liveLimit;
+    this.historyLimit = historyLimit;
+  }
+  /**
+   * Append text to both buffers.
+   */
+  append(text) {
+    this.totalCharsReceived += text.length;
+    this.liveBuffer = appendWithCharLimit(this.liveBuffer, text, this.liveLimit);
+    this.historyBuffer = appendWithCharLimit(this.historyBuffer, text, this.historyLimit);
+  }
+  /**
+   * Get the live output buffer (larger, for display).
+   */
+  getLiveOutput() {
+    return this.liveBuffer;
+  }
+  /**
+   * Get the history output buffer (smaller, for storage).
+   */
+  getHistoryOutput() {
+    return this.historyBuffer;
+  }
+  /**
+   * Get total characters received (before truncation).
+   */
+  getTotalReceived() {
+    return this.totalCharsReceived;
+  }
+  /**
+   * Check if any output has been truncated.
+   */
+  isTruncated() {
+    return this.totalCharsReceived > this.liveLimit;
+  }
+  /**
+   * Clear both buffers.
+   */
+  clear() {
+    this.liveBuffer = "";
+    this.historyBuffer = "";
+    this.totalCharsReceived = 0;
+  }
+};
+function toMemorySafeOutput(output, maxChars = MAX_HISTORY_OUTPUT) {
+  if (output.length <= maxChars) {
+    return output;
+  }
+  return appendWithCharLimit("", output, maxChars);
+}
+var SESSION_STATE_FILE = "session-state.json";
+var MAX_SESSION_AGE_MS = 24 * 60 * 60 * 1e3;
+function saveSessionSnapshot(snapshotDir, state) {
+  const snapshot = {
+    state,
+    pid: process.pid,
+    snapshotAt: (/* @__PURE__ */ new Date()).toISOString(),
+    gracefulEnd: false
+  };
+  const filePath = path4.join(snapshotDir, SESSION_STATE_FILE);
+  fs3.mkdirSync(snapshotDir, { recursive: true });
+  const tmp = `${filePath}.tmp`;
+  fs3.writeFileSync(tmp, JSON.stringify(snapshot, null, 2), "utf-8");
+  fs3.renameSync(tmp, filePath);
+}
+function loadSessionSnapshot(snapshotDir) {
+  const filePath = path4.join(snapshotDir, SESSION_STATE_FILE);
+  try {
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function removeSessionSnapshot(snapshotDir) {
+  const filePath = path4.join(snapshotDir, SESSION_STATE_FILE);
+  try {
+    fs3.unlinkSync(filePath);
+  } catch {
+  }
+}
+function markSessionGracefulEnd(snapshotDir) {
+  const snapshot = loadSessionSnapshot(snapshotDir);
+  if (!snapshot) return;
+  snapshot.gracefulEnd = true;
+  snapshot.snapshotAt = (/* @__PURE__ */ new Date()).toISOString();
+  const filePath = path4.join(snapshotDir, SESSION_STATE_FILE);
+  const tmp = `${filePath}.tmp`;
+  fs3.writeFileSync(tmp, JSON.stringify(snapshot, null, 2), "utf-8");
+  fs3.renameSync(tmp, filePath);
+}
+function detectOrphanedSessions(baseDir) {
+  const dir = baseDir ?? path4.dirname(SESSIONS_DIR);
+  const sessionsDir = path4.join(dir, "sessions");
+  const orphans = [];
+  let projectDirs;
+  try {
+    projectDirs = fs3.readdirSync(sessionsDir, { withFileTypes: true });
+  } catch {
+    return orphans;
+  }
+  for (const entry of projectDirs) {
+    if (!entry.isDirectory()) continue;
+    const projectSlug = entry.name;
+    const projectSessionsDir = path4.join(sessionsDir, projectSlug);
+    let files;
+    try {
+      files = fs3.readdirSync(projectSessionsDir);
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (!file.endsWith(".json") || file.endsWith(".tmp") || file.endsWith(".count")) continue;
+      if (file === SESSION_STATE_FILE) continue;
+      const sessionId = file.replace(/\.json$/, "");
+      try {
+        validateSessionId(sessionId);
+      } catch {
+        continue;
+      }
+      const raw = fs3.readFileSync(path4.join(projectSessionsDir, file), "utf-8");
+      let state;
+      try {
+        state = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      if (state.phase === "ended") continue;
+      const startedAt = new Date(state.startedAt).getTime();
+      const now = Date.now();
+      if (now - startedAt > MAX_SESSION_AGE_MS) {
+        orphans.push({
+          sessionId,
+          projectSlug,
+          snapshotAt: state.startedAt,
+          pid: 0,
+          // Unknown PID for sessions without snapshots
+          reason: "too_old"
+        });
+      }
+    }
+  }
+  return orphans;
+}
+function cleanupOrphanedSession(sessionId, baseDir, projectDir) {
+  validateSessionId(sessionId);
+  const dir = baseDir ?? path4.dirname(SESSIONS_DIR);
+  const slug = projectDir ? projectDirToSlug(projectDir) : null;
+  const paths = [];
+  if (slug) {
+    paths.push(path4.join(dir, "sessions", slug, `${sessionId}.json`));
+  }
+  paths.push(path4.join(dir, "sessions", `${sessionId}.json`));
+  for (const filePath of paths) {
+    try {
+      const raw = fs3.readFileSync(filePath, "utf-8");
+      const state = JSON.parse(raw);
+      state.phase = "ended";
+      const tmp = `${filePath}.tmp`;
+      fs3.writeFileSync(tmp, JSON.stringify(state, null, 2), "utf-8");
+      fs3.renameSync(tmp, filePath);
+      return;
+    } catch {
+      continue;
+    }
+  }
+}
+var idCounter = 0;
+function generateSubagentId() {
+  idCounter++;
+  return `subagent_${Date.now()}_${idCounter}_${Math.random().toString(36).slice(2, 7)}`;
+}
+var SubagentTraceParser = class {
+  subagents = /* @__PURE__ */ new Map();
+  activeStack = [];
+  onEvent;
+  trackHierarchy;
+  maxResultLength;
+  toolUseIdToSubagentId = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.onEvent = options.onEvent;
+    this.trackHierarchy = options.trackHierarchy ?? true;
+    this.maxResultLength = options.maxResultLength ?? 2e3;
+  }
+  /**
+   * Process a single JSONL line. Parses as JSON and detects subagent events.
+   *
+   * @param line - Raw JSONL line string
+   * @returns Array of detected events (empty if line is not subagent-related)
+   */
+  processLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return [];
+    let message;
+    try {
+      const parsed = JSON.parse(trimmed);
+      message = {
+        type: parsed.type,
+        tool: parsed.tool,
+        raw: parsed
+      };
+    } catch {
+      return [];
+    }
+    return this.processMessage(message);
+  }
+  /**
+   * Process a parsed JSONL message.
+   */
+  processMessage(message) {
+    const events = [];
+    if (this.isTaskToolInvocation(message)) {
+      const event = this.handleSpawn(message);
+      if (event) events.push(event);
+    }
+    if (this.isToolResult(message)) {
+      const event = this.handleResult(message);
+      if (event) events.push(event);
+    }
+    if (this.isErrorMessage(message)) {
+      const event = this.handleError(message);
+      if (event) events.push(event);
+    }
+    return events;
+  }
+  /**
+   * Get all currently active (running) subagents.
+   */
+  getActiveSubagents() {
+    return Array.from(this.subagents.values()).filter(
+      (s) => s.status === "running"
+    );
+  }
+  /**
+   * Get the full subagent tree rooted at top-level nodes.
+   * Returns top-level nodes only (children are accessible via the Map).
+   */
+  getTree() {
+    return Array.from(this.subagents.values()).filter(
+      (s) => s.parentId === void 0
+    );
+  }
+  /**
+   * Get all tracked subagents as a flat list.
+   */
+  getAllSubagents() {
+    return Array.from(this.subagents.values());
+  }
+  /**
+   * Get a specific subagent by ID.
+   */
+  getSubagent(id) {
+    return this.subagents.get(id);
+  }
+  /**
+   * Get children of a specific subagent.
+   */
+  getChildren(parentId) {
+    const parent = this.subagents.get(parentId);
+    if (!parent) return [];
+    return parent.children.map((id) => this.subagents.get(id)).filter((n) => n !== void 0);
+  }
+  /**
+   * Get the current nesting depth.
+   */
+  getCurrentDepth() {
+    return this.activeStack.length;
+  }
+  /**
+   * Get a summary of subagent activity.
+   */
+  getSummary() {
+    const nodes = Array.from(this.subagents.values());
+    const byAgentType = {};
+    let totalDurationMs = 0;
+    let maxDepth = 0;
+    for (const node of nodes) {
+      const type = node.agentType ?? "unknown";
+      byAgentType[type] = (byAgentType[type] ?? 0) + 1;
+      if (node.durationMs !== void 0) {
+        totalDurationMs += node.durationMs;
+      }
+      if (node.depth > maxDepth) {
+        maxDepth = node.depth;
+      }
+    }
+    return {
+      totalSpawned: nodes.length,
+      completed: nodes.filter((n) => n.status === "completed").length,
+      errored: nodes.filter((n) => n.status === "error").length,
+      running: nodes.filter((n) => n.status === "running").length,
+      maxDepth,
+      totalDurationMs,
+      byAgentType
+    };
+  }
+  /**
+   * Reset the parser state.
+   */
+  reset() {
+    this.subagents.clear();
+    this.activeStack = [];
+    this.toolUseIdToSubagentId.clear();
+  }
+  // ─── Private Methods ───
+  isTaskToolInvocation(message) {
+    if (message.tool?.name?.toLowerCase() === "task") {
+      return true;
+    }
+    const raw = message.raw;
+    if (raw.type === "assistant" && Array.isArray(raw.content)) {
+      for (const block of raw.content) {
+        if (typeof block === "object" && block !== null && "type" in block && block.type === "tool_use" && "name" in block && typeof block.name === "string" && block.name.toLowerCase() === "task") {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  isToolResult(message) {
+    return message.raw.type === "tool_result" || message.type === "result";
+  }
+  isErrorMessage(message) {
+    return message.raw.type === "error" || message.type === "error" || typeof message.raw.error === "object" && message.raw.error !== null;
+  }
+  handleSpawn(message) {
+    const raw = message.raw;
+    let toolInput;
+    let toolUseId;
+    if (message.tool?.input) {
+      toolInput = message.tool.input;
+    } else if (raw.type === "assistant" && Array.isArray(raw.content)) {
+      for (const block of raw.content) {
+        if (typeof block === "object" && block !== null && "type" in block && block.type === "tool_use" && "name" in block && block.name.toLowerCase() === "task") {
+          toolInput = block.input;
+          toolUseId = block.id;
+          break;
+        }
+      }
+    }
+    if (!toolInput) return null;
+    const agentType = toolInput.subagent_type || "unknown";
+    const description = toolInput.description || "";
+    const id = generateSubagentId();
+    const parentId = this.trackHierarchy && this.activeStack.length > 0 ? this.activeStack[this.activeStack.length - 1] : void 0;
+    const node = {
+      id,
+      parentId,
+      toolName: "Task",
+      status: "running",
+      children: [],
+      startTime: (/* @__PURE__ */ new Date()).toISOString(),
+      description,
+      agentType,
+      depth: this.activeStack.length
+    };
+    if (parentId) {
+      const parent = this.subagents.get(parentId);
+      if (parent) {
+        parent.children.push(id);
+      }
+    }
+    this.subagents.set(id, node);
+    this.activeStack.push(id);
+    if (toolUseId) {
+      this.toolUseIdToSubagentId.set(toolUseId, id);
+    }
+    const event = {
+      type: "spawn",
+      subagentId: id,
+      timestamp: node.startTime,
+      agentType,
+      description,
+      parentId
+    };
+    this.emitEvent(event);
+    return event;
+  }
+  handleResult(message) {
+    const raw = message.raw;
+    let subagentId;
+    const toolUseId = raw.tool_use_id;
+    if (toolUseId) {
+      subagentId = this.toolUseIdToSubagentId.get(toolUseId);
+    }
+    if (!subagentId && this.activeStack.length > 0) {
+      subagentId = this.activeStack[this.activeStack.length - 1];
+    }
+    if (!subagentId) return null;
+    const node = this.subagents.get(subagentId);
+    if (!node || node.status !== "running") return null;
+    const isError = raw.is_error === true || typeof raw.content === "string" && raw.content.toLowerCase().includes("error");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const durationMs = new Date(now).getTime() - new Date(node.startTime).getTime();
+    node.status = isError ? "error" : "completed";
+    node.endTime = now;
+    node.durationMs = durationMs;
+    let resultContent;
+    if (typeof raw.content === "string") {
+      resultContent = raw.content;
+    } else if (Array.isArray(raw.content)) {
+      resultContent = raw.content.map((block) => {
+        if (typeof block === "string") return block;
+        if (typeof block === "object" && block !== null && "text" in block) {
+          return block.text;
+        }
+        return "";
+      }).join("\n");
+    }
+    if (resultContent && resultContent.length > this.maxResultLength) {
+      resultContent = resultContent.slice(0, this.maxResultLength) + "...";
+    }
+    if (isError) {
+      node.error = resultContent;
+    } else {
+      node.result = resultContent;
+    }
+    const stackIndex = this.activeStack.indexOf(subagentId);
+    if (stackIndex !== -1) {
+      this.activeStack.splice(stackIndex, 1);
+    }
+    if (toolUseId) {
+      this.toolUseIdToSubagentId.delete(toolUseId);
+    }
+    const event = {
+      type: isError ? "error" : "complete",
+      subagentId,
+      timestamp: now,
+      agentType: node.agentType,
+      description: node.description,
+      parentId: node.parentId,
+      durationMs,
+      result: isError ? void 0 : resultContent,
+      error: isError ? resultContent : void 0
+    };
+    this.emitEvent(event);
+    return event;
+  }
+  handleError(message) {
+    if (this.activeStack.length === 0) return null;
+    const subagentId = this.activeStack[this.activeStack.length - 1];
+    const node = this.subagents.get(subagentId);
+    if (!node || node.status !== "running") return null;
+    const raw = message.raw;
+    let errorMessage = "Unknown error";
+    if (typeof raw.error === "object" && raw.error !== null) {
+      const errorObj = raw.error;
+      errorMessage = errorObj.message || errorMessage;
+    } else if (typeof raw.message === "string") {
+      errorMessage = raw.message;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const durationMs = new Date(now).getTime() - new Date(node.startTime).getTime();
+    node.status = "error";
+    node.endTime = now;
+    node.durationMs = durationMs;
+    node.error = errorMessage;
+    this.activeStack.pop();
+    const event = {
+      type: "error",
+      subagentId,
+      timestamp: now,
+      agentType: node.agentType,
+      description: node.description,
+      parentId: node.parentId,
+      error: errorMessage,
+      durationMs
+    };
+    this.emitEvent(event);
+    return event;
+  }
+  emitEvent(event) {
+    if (this.onEvent) {
+      try {
+        this.onEvent(event);
+      } catch {
+      }
+    }
+  }
+};
+
+export {
+  projectDirToSlug,
+  validateSessionId,
+  JsonSessionStore,
+  createEmptyState,
+  createInitialState,
+  generateIterationId,
+  startIteration,
+  completeIteration,
+  updateStateFromInput,
+  appendEvent,
+  readEvents,
+  nextPhase,
+  detectNewCommit,
+  SessionEventEmitter,
+  MAX_LIVE_OUTPUT,
+  MAX_HISTORY_OUTPUT,
+  appendWithCharLimit,
+  OutputBuffer,
+  toMemorySafeOutput,
+  saveSessionSnapshot,
+  loadSessionSnapshot,
+  removeSessionSnapshot,
+  markSessionGracefulEnd,
+  detectOrphanedSessions,
+  cleanupOrphanedSession,
+  SubagentTraceParser
+};