ralphctl 0.4.2 → 0.4.4

package/dist/chunk-ZLWSPLWI.mjs

@@ -0,0 +1,1117 @@
+#!/usr/bin/env node
+import {
+  EXIT_INTERRUPTED
+} from "./chunk-CFUVE2BP.mjs";
+import {
+  getPrompt
+} from "./chunk-747KW2RW.mjs";
+import {
+  emoji,
+  getAiProvider,
+  log,
+  setAiProvider
+} from "./chunk-XN2UIHBY.mjs";
+import {
+  ensureError,
+  wrapAsync
+} from "./chunk-IWXBJD2D.mjs";
+import {
+  assertSafeCwd
+} from "./chunk-WDMLPXOD.mjs";
+import {
+  IOError,
+  SpawnError
+} from "./chunk-VAZ3LJBI.mjs";
+
+// src/integration/ui/tui/runtime/screen.ts
+var ENTER_ALT_SCREEN = "\x1B[?1049h";
+var LEAVE_ALT_SCREEN = "\x1B[?1049l";
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
+var CLEAR_SCREEN = "\x1B[2J\x1B[H";
+var altScreenActive = false;
+var safetyNetsInstalled = false;
+function writeRaw(seq) {
+  if (process.stdout.isTTY) process.stdout.write(seq);
+}
+function restore() {
+  if (!altScreenActive) return;
+  altScreenActive = false;
+  writeRaw(SHOW_CURSOR);
+  writeRaw(LEAVE_ALT_SCREEN);
+}
+function installSafetyNets() {
+  if (safetyNetsInstalled) return;
+  safetyNetsInstalled = true;
+  process.on("exit", restore);
+  for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.on(sig, () => {
+      restore();
+      process.kill(process.pid, sig);
+    });
+  }
+  process.on("uncaughtException", (err) => {
+    restore();
+    setImmediate(() => {
+      throw err;
+    });
+  });
+}
+function enterAltScreen() {
+  if (altScreenActive) return;
+  if (!process.stdout.isTTY) return;
+  installSafetyNets();
+  altScreenActive = true;
+  writeRaw(ENTER_ALT_SCREEN);
+  writeRaw(CLEAR_SCREEN);
+  writeRaw(HIDE_CURSOR);
+}
+function exitAltScreen() {
+  restore();
+}
+
+// src/integration/ui/tui/runtime/suspend.ts
+var activeInstance = null;
+function registerTuiInstance(instance) {
+  activeInstance = instance;
+  return () => {
+    if (activeInstance === instance) {
+      activeInstance = null;
+    }
+  };
+}
+async function withSuspendedTui(cb) {
+  const instance = activeInstance;
+  if (instance === null) {
+    return cb();
+  }
+  exitAltScreen();
+  try {
+    return await cb();
+  } finally {
+    enterAltScreen();
+    instance.clear();
+  }
+}
+
+// src/integration/ai/session/session.ts
+import { spawn, spawnSync } from "child_process";
+
+// src/integration/ai/session/process-manager.ts
+var GRACEFUL_SHUTDOWN_TIMEOUT_MS = 5e3;
+var FORCE_QUIT_WINDOW_MS = 5e3;
+var ProcessManager = class _ProcessManager {
+  static instance = null;
+  /** All active AI child processes */
+  children = /* @__PURE__ */ new Set();
+  /** Cleanup callbacks (for stopping spinners, removing temp files) */
+  cleanupCallbacks = /* @__PURE__ */ new Set();
+  /** Whether we're currently shutting down */
+  exiting = false;
+  /** Whether signal handlers have been installed */
+  handlersInstalled = false;
+  /** Timestamp of first SIGINT (for double-signal detection) */
+  firstSigintAt = null;
+  /** Stored signal handler references for cleanup */
+  sigintHandler = null;
+  sigtermHandler = null;
+  constructor() {
+  }
+  /**
+   * Get the singleton instance.
+   */
+  static getInstance() {
+    _ProcessManager.instance ??= new _ProcessManager();
+    return _ProcessManager.instance;
+  }
+  /**
+   * Reset the singleton for testing.
+   * @internal
+   */
+  static resetForTesting() {
+    if (_ProcessManager.instance) {
+      _ProcessManager.instance.dispose();
+      _ProcessManager.instance = null;
+    }
+  }
+  /**
+   * Register a child process for tracking.
+   * Automatically installs signal handlers on first registration.
+   * Throws an error if called during shutdown.
+   *
+   * @throws Error if called during shutdown
+   */
+  registerChild(child) {
+    if (this.exiting) {
+      throw new Error("Cannot register child process during shutdown");
+    }
+    this.children.add(child);
+    child.once("close", () => {
+      this.children.delete(child);
+    });
+    if (!this.handlersInstalled) {
+      this.installSignalHandlers();
+      this.handlersInstalled = true;
+    }
+  }
+  /**
+   * Eagerly install signal handlers without requiring a child registration.
+   * Call this at the top of execution loops so Ctrl+C works even before
+   * the first AI process is spawned (e.g. while the spinner is visible).
+   * Idempotent — safe to call multiple times.
+   */
+  ensureHandlers() {
+    if (!this.handlersInstalled) {
+      this.installSignalHandlers();
+      this.handlersInstalled = true;
+    }
+  }
+  /**
+   * Wire a task-scoped AbortSignal to a terminate callback. When the signal
+   * aborts, the callback fires once. Returns a disposer that detaches the
+   * listener — call it in a `finally` after the child exits so listeners
+   * don't accumulate across repeated runs.
+   *
+   * If the signal is already aborted, terminate runs on the next microtask
+   * so the caller always observes a consistent async flow.
+   */
+  registerAbort(signal, terminate) {
+    let fired = false;
+    const handler = () => {
+      if (fired) return;
+      fired = true;
+      try {
+        terminate();
+      } catch (err) {
+        log.error(`Error in abort-signal handler: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    };
+    if (signal.aborted) {
+      queueMicrotask(handler);
+    }
+    signal.addEventListener("abort", handler, { once: true });
+    return () => {
+      signal.removeEventListener("abort", handler);
+    };
+  }
+  /**
+   * Check if a shutdown is in progress.
+   * Used by execution loops to break immediately on Ctrl+C.
+   */
+  isShuttingDown() {
+    return this.exiting;
+  }
+  /**
+   * Manually unregister a child process.
+   * Normally not needed - children auto-unregister via event listeners.
+   */
+  unregisterChild(child) {
+    this.children.delete(child);
+  }
+  /**
+   * Register a cleanup callback (for spinners, temp files, etc.).
+   * Returns a deregister function.
+   */
+  registerCleanup(callback) {
+    this.cleanupCallbacks.add(callback);
+    return () => {
+      this.cleanupCallbacks.delete(callback);
+    };
+  }
+  /**
+   * Kill all tracked child processes with the given signal.
+   * Catches errors (ESRCH = already dead, EPERM = permission denied).
+   */
+  killAll(signal) {
+    for (const child of this.children) {
+      try {
+        child.kill(signal);
+      } catch (err) {
+        const error = err;
+        if (error.code === "ESRCH") {
+          this.children.delete(child);
+        } else if (error.code === "EPERM") {
+          log.warn(`Permission denied killing process ${String(child.pid)}`);
+        } else {
+          log.error(`Error killing process ${String(child.pid)}: ${error.message}`);
+        }
+      }
+    }
+  }
+  /**
+   * Graceful shutdown sequence:
+   * 1. Run all cleanup callbacks (stop spinners)
+   * 2. Send SIGINT to all children (what AI CLI processes expect)
+   * 3. Wait up to 5 seconds for children to exit
+   * 4. Send SIGKILL to any remaining children (force)
+   * 5. Exit with code 130 (SIGINT) or 1 (force-quit)
+   *
+   * Double Ctrl+C: immediate SIGKILL + exit(1)
+   */
+  async shutdown(signal) {
+    if (signal === "SIGINT" && this.firstSigintAt) {
+      const now = Date.now();
+      if (now - this.firstSigintAt < FORCE_QUIT_WINDOW_MS) {
+        log.warn("\n\nForce quit (double signal) \u2014 killing all processes immediately...");
+        this.killAll("SIGKILL");
+        process.exit(1);
+        return;
+      }
+    }
+    if (this.exiting) {
+      return;
+    }
+    this.exiting = true;
+    if (signal === "SIGINT") {
+      this.firstSigintAt = Date.now();
+    }
+    log.dim("\n\nShutting down gracefully... (press Ctrl+C again to force-quit)");
+    for (const callback of this.cleanupCallbacks) {
+      try {
+        callback();
+      } catch (err) {
+        log.error(`Error in cleanup callback: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    this.cleanupCallbacks.clear();
+    this.killAll("SIGINT");
+    const waitStart = Date.now();
+    while (this.children.size > 0 && Date.now() - waitStart < GRACEFUL_SHUTDOWN_TIMEOUT_MS) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    if (this.children.size > 0) {
+      log.warn(`Force-killing ${String(this.children.size)} remaining process(es)...`);
+      this.killAll("SIGKILL");
+    }
+    process.exit(signal === "SIGINT" ? EXIT_INTERRUPTED : 1);
+  }
+  /**
+   * Clean up all resources (for testing).
+   * @internal
+   */
+  dispose() {
+    if (this.sigintHandler) {
+      process.removeListener("SIGINT", this.sigintHandler);
+      this.sigintHandler = null;
+    }
+    if (this.sigtermHandler) {
+      process.removeListener("SIGTERM", this.sigtermHandler);
+      this.sigtermHandler = null;
+    }
+    this.children.clear();
+    this.cleanupCallbacks.clear();
+    this.exiting = false;
+    this.handlersInstalled = false;
+    this.firstSigintAt = null;
+  }
+  /**
+   * Install signal handlers for SIGINT and SIGTERM.
+   * Uses process.on() (persistent) not process.once() (one-shot).
+   * Stores handler references so dispose() can remove them.
+   */
+  installSignalHandlers() {
+    this.sigintHandler = () => {
+      void this.shutdown("SIGINT");
+    };
+    this.sigtermHandler = () => {
+      void this.shutdown("SIGTERM");
+    };
+    process.on("SIGINT", this.sigintHandler);
+    process.on("SIGTERM", this.sigtermHandler);
+  }
+};
+var processLifecycleAdapter = {
+  ensureHandlers: () => {
+    ProcessManager.getInstance().ensureHandlers();
+  },
+  isShuttingDown: () => ProcessManager.getInstance().isShuttingDown(),
+  registerAbort: (signal, terminate) => ProcessManager.getInstance().registerAbort(signal, terminate)
+};
+
+// src/integration/ai/providers/claude.ts
+import { Result } from "typescript-result";
+var claudeAdapter = {
+  name: "claude",
+  displayName: "Claude",
+  binary: "claude",
+  baseArgs: ["--permission-mode", "acceptEdits", "--effort", "xhigh"],
+  experimental: false,
+  buildInteractiveArgs(prompt, extraArgs = []) {
+    return [...this.baseArgs, ...extraArgs, "--", prompt];
+  },
+  buildHeadlessArgs(extraArgs = []) {
+    return ["-p", "--output-format", "json", ...this.baseArgs, ...extraArgs];
+  },
+  parseJsonOutput(stdout) {
+    const jsonResult = Result.try(() => JSON.parse(stdout));
+    if (!jsonResult.ok) {
+      return { result: stdout, sessionId: null, model: null };
+    }
+    const parsed = jsonResult.value;
+    return {
+      result: parsed.result ?? stdout,
+      sessionId: parsed.session_id ?? null,
+      model: parsed.model ?? null
+    };
+  },
+  buildResumeArgs(sessionId) {
+    if (!/^[a-zA-Z0-9_][a-zA-Z0-9_-]{0,127}$/.test(sessionId)) {
+      throw new Error("Invalid session ID format");
+    }
+    return ["--resume", sessionId];
+  },
+  detectRateLimit(stderr) {
+    const patterns = [/rate.?limit/i, /\b429\b/, /too many requests/i, /overloaded/i, /\b529\b/];
+    const isRateLimited = patterns.some((p) => p.test(stderr));
+    if (!isRateLimited) {
+      return { rateLimited: false, retryAfterMs: null };
+    }
+    const retryMatch = /retry.?after:?\s*(\d+)/i.exec(stderr);
+    const retryAfterMs = retryMatch?.[1] ? parseInt(retryMatch[1], 10) * 1e3 : null;
+    return { rateLimited: true, retryAfterMs };
+  },
+  getSpawnEnv() {
+    return { CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD: "1" };
+  }
+};
+
+// src/integration/ai/providers/copilot.ts
+import { lstat, readdir, unlink } from "fs/promises";
+import { join } from "path";
+import { Result as Result2 } from "typescript-result";
+var copilotAdapter = {
+  name: "copilot",
+  displayName: "Copilot",
+  binary: "copilot",
+  experimental: true,
+  baseArgs: ["--allow-all-tools"],
+  buildInteractiveArgs(prompt, extraArgs = []) {
+    return [...this.baseArgs, ...extraArgs, "-i", prompt];
+  },
+  buildHeadlessArgs(extraArgs = []) {
+    return ["-p", "--output-format", "json", "--autopilot", "--no-ask-user", "--share", ...this.baseArgs, ...extraArgs];
+  },
+  parseJsonOutput(stdout) {
+    const lines = stdout.trim().split("\n").filter(Boolean);
+    if (lines.length === 0) {
+      return { result: "", sessionId: null, model: null };
+    }
+    const lastLine = lines.at(-1) ?? "";
+    const jsonResult = Result2.try(() => JSON.parse(lastLine));
+    if (jsonResult.ok) {
+      const parsed = jsonResult.value;
+      return {
+        result: parsed.result ?? parsed.result_text ?? lastLine,
+        sessionId: parsed.session_id ?? null,
+        model: null
+      };
+    }
+    return { result: stdout.trim(), sessionId: null, model: null };
+  },
+  buildResumeArgs(sessionId) {
+    if (!/^[a-zA-Z0-9_][a-zA-Z0-9_-]{0,127}$/.test(sessionId)) {
+      throw new Error("Invalid session ID format");
+    }
+    return [`--resume=${sessionId}`];
+  },
+  async extractSessionId(cwd) {
+    const filesResult = await wrapAsync(
+      () => readdir(cwd),
+      (err) => new IOError(`Failed to read directory: ${cwd}`, err instanceof Error ? err : void 0)
+    );
+    if (!filesResult.ok) return null;
+    const files = filesResult.value;
+    const shareFile = files.find((f) => /^copilot-session-[a-zA-Z0-9_][a-zA-Z0-9_-]*\.md$/.test(f));
+    if (!shareFile) return null;
+    const match = /^copilot-session-([a-zA-Z0-9_][a-zA-Z0-9_-]{0,127})\.md$/.exec(shareFile);
+    if (!match?.[1]) return null;
+    const filePath = join(cwd, shareFile);
+    const stat = await lstat(filePath).catch(() => null);
+    if (stat?.isFile()) {
+      await unlink(filePath).catch(() => {
+      });
+    }
+    return match[1];
+  },
+  detectRateLimit(stderr) {
+    const patterns = [/rate.?limit/i, /\b429\b/, /too many requests/i, /overloaded/i, /\b529\b/];
+    const isRateLimited = patterns.some((p) => p.test(stderr));
+    if (!isRateLimited) {
+      return { rateLimited: false, retryAfterMs: null };
+    }
+    const retryMatch = /retry.?after:?\s*(\d+)/i.exec(stderr);
+    const retryAfterMs = retryMatch?.[1] ? parseInt(retryMatch[1], 10) * 1e3 : null;
+    return { rateLimited: true, retryAfterMs };
+  },
+  getSpawnEnv() {
+    return {};
+  }
+};
+
+// src/integration/external/provider.ts
+async function resolveProvider() {
+  const stored = await getAiProvider();
+  if (stored) return stored;
+  const choice = await getPrompt().select({
+    message: `${emoji.donut} Which AI buddy should help with my homework?`,
+    choices: [
+      { label: "Claude Code", value: "claude" },
+      { label: "GitHub Copilot", value: "copilot" }
+    ]
+  });
+  await setAiProvider(choice);
+  return choice;
+}
+function providerDisplayName(provider) {
+  return provider === "claude" ? "Claude" : "Copilot";
+}
+
+// src/integration/ai/providers/registry.ts
+function getProvider(provider) {
+  switch (provider) {
+    case "claude":
+      return claudeAdapter;
+    case "copilot":
+      return copilotAdapter;
+  }
+}
+async function getActiveProvider() {
+  const provider = await resolveProvider();
+  return getProvider(provider);
+}
+
+// src/integration/ai/session/session.ts
+function spawnInteractive(prompt, options, provider) {
+  assertSafeCwd(options.cwd);
+  const args = prompt ? provider.buildInteractiveArgs(prompt, options.args ?? []) : [...provider.baseArgs, ...options.args ?? []];
+  const env = options.env ? { ...process.env, ...options.env } : void 0;
+  const result = spawnSync(provider.binary, args, {
+    cwd: options.cwd,
+    stdio: "inherit",
+    env
+  });
+  if (result.error) {
+    return { code: 1, error: `Failed to spawn ${provider.binary} CLI: ${result.error.message}` };
+  }
+  return { code: result.status ?? 1 };
+}
+async function spawnHeadless(options, provider) {
+  assertSafeCwd(options.cwd);
+  const p = provider ?? await getActiveProvider();
+  return new Promise((resolve, reject) => {
+    const allArgs = p.buildHeadlessArgs(options.args ?? []);
+    if (options.resumeSessionId) {
+      try {
+        allArgs.push(...p.buildResumeArgs(options.resumeSessionId));
+      } catch {
+        reject(new SpawnError("Invalid session ID format", "", 1));
+        return;
+      }
+    }
+    const child = spawn(p.binary, allArgs, {
+      cwd: options.cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: options.env ? { ...process.env, ...options.env } : void 0
+    });
+    const manager = ProcessManager.getInstance();
+    try {
+      manager.registerChild(child);
+    } catch {
+      reject(new SpawnError("Cannot spawn during shutdown", "", 1));
+      return;
+    }
+    let detachAbort = null;
+    if (options.abortSignal) {
+      detachAbort = manager.registerAbort(options.abortSignal, () => {
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+      });
+    }
+    const MAX_STDOUT_SIZE = 1e7;
+    const MAX_PROMPT_SIZE = 1e6;
+    if (options.prompt) {
+      if (options.prompt.length > MAX_PROMPT_SIZE) {
+        reject(new SpawnError("Prompt exceeds maximum size (1MB)", "", 1));
+        return;
+      }
+      child.stdin.write(options.prompt);
+    }
+    child.stdin.end();
+    let rawStdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      if (rawStdout.length < MAX_STDOUT_SIZE) {
+        rawStdout += data.toString();
+      }
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      detachAbort?.();
+      void (async () => {
+        const exitCode = code ?? 1;
+        const { result, sessionId: parsedSessionId, model: parsedModel } = p.parseJsonOutput(rawStdout);
+        const sessionId = parsedSessionId ?? await p.extractSessionId?.(options.cwd) ?? null;
+        if (exitCode !== 0) {
+          reject(
+            new SpawnError(
+              `${p.displayName} CLI exited with code ${String(exitCode)}: ${stderr}`,
+              stderr,
+              exitCode,
+              sessionId
+            )
+          );
+        } else {
+          resolve({ stdout: result, stderr, exitCode: 0, sessionId, model: parsedModel });
+        }
+      })().catch((err) => {
+        reject(new SpawnError(`Unexpected error in close handler: ${String(err)}`, "", 1));
+      });
+    });
+    child.on("error", (err) => {
+      detachAbort?.();
+      reject(new SpawnError(`Failed to spawn ${p.binary} CLI: ${err.message}`, "", 1));
+    });
+  });
+}
+var DEFAULT_MAX_RETRIES = 5;
+var BASE_DELAY_MS = 2e3;
+var MAX_DELAY_MS = 12e4;
+var DEFAULT_TOTAL_TIMEOUT_MS = 6e5;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function jitter() {
+  return Math.floor(Math.random() * 1e3);
+}
+async function spawnWithRetry(options, retryOptions, provider) {
+  const p = provider ?? await getActiveProvider();
+  const maxRetries = retryOptions?.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const totalTimeoutMs = retryOptions?.totalTimeoutMs ?? DEFAULT_TOTAL_TIMEOUT_MS;
+  const startTime = Date.now();
+  let resumeSessionId = options.resumeSessionId;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const elapsed = Date.now() - startTime;
+    if (attempt > 0 && elapsed >= totalTimeoutMs) {
+      throw new SpawnError(`Total retry timeout exceeded (${String(totalTimeoutMs)}ms)`, "", 1, resumeSessionId);
+    }
+    if (options.abortSignal?.aborted) {
+      throw new SpawnError("Aborted by caller", "", 1, resumeSessionId);
+    }
+    const r = await wrapAsync(async () => spawnHeadless({ ...options, resumeSessionId }, p), ensureError);
+    if (r.ok) return r.value;
+    const err = r.error;
+    if (!(err instanceof SpawnError) || !err.rateLimited) {
+      throw err;
+    }
+    if (err.sessionId) {
+      resumeSessionId = err.sessionId;
+    }
+    if (attempt >= maxRetries) {
+      throw err;
+    }
+    const delay = Math.min(err.retryAfterMs ?? BASE_DELAY_MS * Math.pow(2, attempt), MAX_DELAY_MS) + jitter();
+    retryOptions?.onRetry?.(attempt + 1, delay, err);
+    await sleep(delay);
+  }
+  throw new Error("Max retries exceeded");
+}
+
+// src/integration/ai/session/session-adapter.ts
+var ProviderAiSessionAdapter = class {
+  provider = null;
+  /** Lazily resolve and cache the active provider. */
+  async getProvider() {
+    this.provider ??= await getActiveProvider();
+    return this.provider;
+  }
+  /** Public eager resolver — required before the sync getters can be used safely. */
+  async ensureReady() {
+    await this.getProvider();
+  }
+  async spawnInteractive(prompt, options) {
+    const provider = await this.getProvider();
+    await withSuspendedTui(() => {
+      const result = spawnInteractive(
+        prompt,
+        {
+          cwd: options.cwd,
+          args: options.args,
+          env: options.env
+        },
+        provider
+      );
+      if (result.error) {
+        throw new Error(result.error);
+      }
+    });
+  }
+  async spawnHeadless(prompt, options) {
+    const provider = await this.getProvider();
+    const result = await spawnHeadless(
+      {
+        cwd: options.cwd,
+        args: options.args,
+        env: options.env,
+        prompt,
+        resumeSessionId: options.resumeSessionId,
+        abortSignal: options.abortSignal
+      },
+      provider
+    );
+    return {
+      output: result.stdout,
+      sessionId: result.sessionId ?? void 0,
+      model: result.model ?? void 0
+    };
+  }
+  async spawnWithRetry(prompt, options) {
+    const provider = await this.getProvider();
+    const result = await spawnWithRetry(
+      {
+        cwd: options.cwd,
+        args: options.args,
+        env: options.env,
+        prompt,
+        resumeSessionId: options.resumeSessionId,
+        abortSignal: options.abortSignal
+      },
+      { maxRetries: options.maxRetries },
+      provider
+    );
+    return {
+      output: result.stdout,
+      sessionId: result.sessionId ?? void 0,
+      model: result.model ?? void 0
+    };
+  }
+  async resumeSession(sessionId, prompt, options) {
+    const provider = await this.getProvider();
+    const result = await spawnWithRetry(
+      {
+        cwd: options.cwd,
+        args: options.args,
+        env: options.env,
+        prompt,
+        resumeSessionId: sessionId,
+        abortSignal: options.abortSignal
+      },
+      void 0,
+      provider
+    );
+    return {
+      output: result.stdout,
+      sessionId: result.sessionId ?? void 0,
+      model: result.model ?? void 0
+    };
+  }
+  getProviderName() {
+    if (!this.provider) {
+      throw new Error("Provider not yet resolved. Call an async method first.");
+    }
+    return this.provider.name;
+  }
+  getProviderDisplayName() {
+    if (!this.provider) {
+      throw new Error("Provider not yet resolved. Call an async method first.");
+    }
+    return this.provider.displayName;
+  }
+  getSpawnEnv() {
+    if (!this.provider) {
+      throw new Error("Provider not yet resolved. Call an async method first.");
+    }
+    return this.provider.getSpawnEnv();
+  }
+};
+
+// src/integration/signals/parser.ts
+var SIGNAL_PATTERNS = {
+  progress: /<progress>([\s\S]*?)<\/progress>/g,
+  progressWithFiles: /<progress>([\s\S]*?)<\/progress>/,
+  evaluation_passed: /<evaluation-passed>/,
+  evaluation_failed: /<evaluation-failed>([\s\S]*?)<\/evaluation-failed>/,
+  task_verified: /<task-verified>([\s\S]*?)<\/task-verified>/,
+  task_complete: /<task-complete>/,
+  task_blocked: /<task-blocked>([\s\S]*?)<\/task-blocked>/,
+  note: /<note>([\s\S]*?)<\/note>/g,
+  check_script: /<check-script>([\s\S]*?)<\/check-script>/,
+  agents_md: /<agents-md>([\s\S]*?)<\/agents-md>/
+};
+var DIMENSION_LINE = /\*\*([A-Za-z][A-Za-z0-9]{2,29})\*\*\s*:\s*(PASS|FAIL)\s*(?:—|-)\s*(.+)/gi;
+function parseDimensionScores(output) {
+  const scores = [];
+  const seen = /* @__PURE__ */ new Set();
+  DIMENSION_LINE.lastIndex = 0;
+  let match;
+  while ((match = DIMENSION_LINE.exec(output)) !== null) {
+    const rawName = match[1];
+    const verdict = match[2];
+    const finding = match[3];
+    if (!rawName || !verdict || !finding) continue;
+    const name = rawName.toLowerCase();
+    if (seen.has(name)) continue;
+    seen.add(name);
+    scores.push({
+      dimension: name,
+      passed: verdict.toUpperCase() === "PASS",
+      finding: finding.trim()
+    });
+  }
+  return scores;
+}
+var DANGEROUS_COMMAND_PATTERNS = [
+  /\|\s*(ba)?sh\b/,
+  /\bcurl\b[^|;&\n]*\|/,
+  /\bwget\b[^|;&\n]*(-O-|--output-document=-)[^|;&\n]*\|/,
+  /\beval\b/,
+  /\brm\s+-[rf]+\b/
+];
+function isDangerousCommand(command) {
+  return DANGEROUS_COMMAND_PATTERNS.some((re) => re.test(command));
+}
+var SignalParser = class {
+  parseSignals(output) {
+    const signals = [];
+    const timestamp = /* @__PURE__ */ new Date();
+    let progressMatch;
+    while ((progressMatch = SIGNAL_PATTERNS.progress.exec(output)) !== null) {
+      const summary = progressMatch[1]?.trim();
+      if (summary) {
+        const progressSignal = {
+          type: "progress",
+          summary,
+          // Note: Phase 1 doesn't parse files attribute; added in Phase 2+
+          timestamp
+        };
+        signals.push(progressSignal);
+      }
+    }
+    if (output.includes("<evaluation-passed>")) {
+      const dimensions = parseDimensionScores(output);
+      const evaluationSignal = {
+        type: "evaluation",
+        status: "passed",
+        dimensions,
+        timestamp
+      };
+      signals.push(evaluationSignal);
+    } else {
+      const failedMatch = SIGNAL_PATTERNS.evaluation_failed.exec(output);
+      if (failedMatch?.[1]) {
+        const critique = failedMatch[1].trim();
+        const dimensions = parseDimensionScores(output);
+        const evaluationSignal = {
+          type: "evaluation",
+          status: dimensions.length > 0 ? "failed" : "malformed",
+          dimensions,
+          critique: dimensions.length > 0 ? critique : void 0,
+          timestamp
+        };
+        signals.push(evaluationSignal);
+      } else if (parseDimensionScores(output).length > 0) {
+        const dimensions = parseDimensionScores(output);
+        const evaluationSignal = {
+          type: "evaluation",
+          status: "failed",
+          dimensions,
+          timestamp
+        };
+        signals.push(evaluationSignal);
+      }
+    }
+    const taskVerifiedMatch = SIGNAL_PATTERNS.task_verified.exec(output);
+    if (taskVerifiedMatch?.[1]) {
+      const verificationOutput = taskVerifiedMatch[1].trim();
+      const verifiedSignal = {
+        type: "task-verified",
+        output: verificationOutput,
+        timestamp
+      };
+      signals.push(verifiedSignal);
+    }
+    if (output.includes("<task-complete>")) {
+      const completeSignal = {
+        type: "task-complete",
+        timestamp
+      };
+      signals.push(completeSignal);
+    }
+    const taskBlockedMatch = SIGNAL_PATTERNS.task_blocked.exec(output);
+    if (taskBlockedMatch?.[1]) {
+      const reason = taskBlockedMatch[1].trim();
+      const blockedSignal = {
+        type: "task-blocked",
+        reason,
+        timestamp
+      };
+      signals.push(blockedSignal);
+    }
+    let noteMatch;
+    while ((noteMatch = SIGNAL_PATTERNS.note.exec(output)) !== null) {
+      const text = noteMatch[1]?.trim();
+      if (text) {
+        const noteSignal = {
+          type: "note",
+          text,
+          timestamp
+        };
+        signals.push(noteSignal);
+      }
+    }
+    const checkScriptMatch = SIGNAL_PATTERNS.check_script.exec(output);
+    if (checkScriptMatch?.[1]) {
+      const command = checkScriptMatch[1].trim();
+      if (command.length > 0 && !isDangerousCommand(command)) {
+        const checkScriptSignal = {
+          type: "check-script-discovery",
+          command,
+          timestamp
+        };
+        signals.push(checkScriptSignal);
+      }
+    }
+    const agentsMdMatch = SIGNAL_PATTERNS.agents_md.exec(output);
+    if (agentsMdMatch?.[1]) {
+      const content = agentsMdMatch[1].trim();
+      if (content.length > 0) {
+        const agentsMdSignal = {
+          type: "agents-md-proposal",
+          content,
+          timestamp
+        };
+        signals.push(agentsMdSignal);
+      }
+    }
+    return signals;
+  }
+};
+
+// src/integration/ai/prompts/loader.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function getPromptDir() {
+  const bundled = join2(__dirname, "prompts");
+  if (existsSync(bundled)) return bundled;
+  return __dirname;
+}
+var promptDir = getPromptDir();
+function loadTemplate(name) {
+  return readFileSync(join2(promptDir, `${name}.md`), "utf-8");
+}
+function loadPartial(name) {
+  return loadTemplate(name).replace(/\s+$/, "");
+}
+var UNREPLACED_TOKEN_RE = /\{\{[A-Z_]+\}\}/g;
+function composePrompt(template, substitutions) {
+  let result = template;
+  for (const [key, value] of Object.entries(substitutions)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  const remaining = result.match(UNREPLACED_TOKEN_RE);
+  if (remaining) {
+    throw new Error(`composePrompt: unreplaced placeholders: ${[...new Set(remaining)].join(", ")}`);
+  }
+  return result;
+}
+var CHECK_GATE_EXAMPLE = "Run the project's check gate \u2014 all pass (omit this step when the project has no check script)";
+function buildPlanCommon(projectToolingSection) {
+  return composePrompt(loadPartial("plan-common"), {
+    PLAN_COMMON_EXAMPLES: loadPartial("plan-common-examples"),
+    PROJECT_TOOLING: projectToolingSection,
+    CHECK_GATE_EXAMPLE
+  });
+}
+function buildPlannerBase(projectToolingSection) {
+  return {
+    HARNESS_CONTEXT: loadPartial("harness-context"),
+    COMMON: buildPlanCommon(projectToolingSection),
+    VALIDATION: loadPartial("validation-checklist"),
+    SIGNALS: loadPartial("signals-planning"),
+    CHECK_GATE_EXAMPLE
+  };
+}
+function buildInteractivePrompt(context, outputFile, schema, projectToolingSection) {
+  return composePrompt(loadTemplate("plan-interactive"), {
+    ...buildPlannerBase(projectToolingSection),
+    CONTEXT: context,
+    OUTPUT_FILE: outputFile,
+    SCHEMA: schema
+  });
+}
+function buildAutoPrompt(context, schema, projectToolingSection) {
+  return composePrompt(loadTemplate("plan-auto"), {
+    ...buildPlannerBase(projectToolingSection),
+    CONTEXT: context,
+    SCHEMA: schema
+  });
+}
+function buildTaskExecutionPrompt(progressFilePath, noCommit, contextFileName, projectToolingSection = "") {
+  let template = loadTemplate("task-execution");
+  if (noCommit) {
+    template = template.replace(/^[ \t]*\{\{COMMIT_STEP\}\}\n/m, "\n");
+    template = template.replace(/^[ \t]*\{\{COMMIT_CONSTRAINT\}\}\n/m, "");
+  }
+  const commitStep = noCommit ? "" : "   - **Before continuing:** Create a git commit with a descriptive message for the changes made.";
+  const commitConstraint = noCommit ? "" : "- **Must commit** \u2014 Create a git commit before signaling completion.";
+  return composePrompt(template, {
+    HARNESS_CONTEXT: loadPartial("harness-context"),
+    SIGNALS: loadPartial("signals-task"),
+    PROGRESS_FILE: progressFilePath,
+    COMMIT_STEP: commitStep,
+    COMMIT_CONSTRAINT: commitConstraint,
+    CONTEXT_FILE: contextFileName,
+    PROJECT_TOOLING: projectToolingSection
+  });
+}
+function buildTicketRefinePrompt(ticketContent, outputFile, schema, issueContext = "") {
+  const template = loadTemplate("ticket-refine");
+  const issueContextSection = issueContext ? `<context>
+
+${issueContext}
+
+</context>` : "";
+  return composePrompt(template, {
+    TICKET: ticketContent,
+    OUTPUT_FILE: outputFile,
+    SCHEMA: schema,
+    ISSUE_CONTEXT: issueContextSection
+  });
+}
+function buildIdeatePrompt(ideaTitle, ideaDescription, projectName, repositories, outputFile, schema, projectToolingSection) {
+  return composePrompt(loadTemplate("ideate"), {
+    ...buildPlannerBase(projectToolingSection),
+    IDEA_TITLE: ideaTitle,
+    IDEA_DESCRIPTION: ideaDescription,
+    PROJECT_NAME: projectName,
+    REPOSITORIES: repositories,
+    OUTPUT_FILE: outputFile,
+    SCHEMA: schema
+  });
+}
+function buildIdeateAutoPrompt(ideaTitle, ideaDescription, projectName, repositories, schema, projectToolingSection) {
+  return composePrompt(loadTemplate("ideate-auto"), {
+    ...buildPlannerBase(projectToolingSection),
+    IDEA_TITLE: ideaTitle,
+    IDEA_DESCRIPTION: ideaDescription,
+    PROJECT_NAME: projectName,
+    REPOSITORIES: repositories,
+    SCHEMA: schema
+  });
+}
+function renderExtraDimensions(extras) {
+  if (extras.length === 0) {
+    return { section: "", passBar: "", assessment: "" };
+  }
+  const section = extras.map(
+    (name) => `
+<dimension name="${name}" floor="false">
+Additional task-specific dimension flagged by the planner. Apply judgment to whether the implementation satisfies this dimension given the task's verification criteria and steps.
+</dimension>
+`
+  ).join("");
+  const passBar = extras.map((name) => `
+- **${name}**: Task-specific dimension flagged by the planner`).join("");
+  return {
+    section,
+    passBar,
+    assessment: extras.map((name) => `
+**${name}**: PASS/FAIL \u2014 [one-line finding]`).join("")
+  };
+}
+function buildEvaluatorPrompt(ctx) {
+  const template = loadTemplate("task-evaluation");
+  const descriptionSection = ctx.taskDescription ? `
+**Description:** ${ctx.taskDescription}` : "";
+  const stepsSection = ctx.taskSteps.length > 0 ? `
+**Implementation Steps:**
+${ctx.taskSteps.map((s) => `- ${s}`).join("\n")}` : "";
+  const criteriaSection = ctx.verificationCriteria.length > 0 ? `
+**Verification Criteria:**
+${ctx.verificationCriteria.map((c) => `- ${c}`).join("\n")}` : "";
+  const checkSection = ctx.checkScriptSection ? `
+
+${ctx.checkScriptSection}` : "";
+  const extras = renderExtraDimensions(ctx.extraDimensions);
+  const extraAssessmentPass = extras.assessment.replace(/PASS\/FAIL/g, "PASS");
+  return composePrompt(template, {
+    HARNESS_CONTEXT: loadPartial("harness-context"),
+    SIGNALS: loadPartial("signals-evaluation"),
+    TASK_NAME: ctx.taskName,
+    TASK_DESCRIPTION_SECTION: descriptionSection,
+    TASK_STEPS_SECTION: stepsSection,
+    VERIFICATION_CRITERIA_SECTION: criteriaSection,
+    PROJECT_PATH: ctx.projectPath,
+    CHECK_SCRIPT_SECTION: checkSection,
+    PROJECT_TOOLING: ctx.projectToolingSection,
+    EXTRA_DIMENSIONS_SECTION: extras.section,
+    EXTRA_DIMENSIONS_PASS_BAR: extras.passBar,
+    EXTRA_DIMENSIONS_ASSESSMENT_PASS: extraAssessmentPass,
+    EXTRA_DIMENSIONS_ASSESSMENT_MIXED: extras.assessment
+  });
+}
+function buildSprintFeedbackPrompt(sprintName, completedTasks, feedback, branch) {
+  const template = loadTemplate("sprint-feedback");
+  const branchSection = branch ? `
+**Branch:** ${branch}
+` : "";
+  return composePrompt(template, {
+    HARNESS_CONTEXT: loadPartial("harness-context"),
+    SIGNALS: loadPartial("signals-task"),
+    SPRINT_NAME: sprintName,
+    BRANCH_SECTION: branchSection,
+    COMPLETED_TASKS: completedTasks,
+    FEEDBACK: feedback
+  });
+}
+function buildCheckScriptDiscoverPrompt(repoPath) {
+  return composePrompt(loadTemplate("check-script-discover"), {
+    REPO_PATH: repoPath
+  });
+}
+function buildRepoOnboardPrompt(ctx) {
+  const existingSection = ctx.existingAgentsMd ? `
+**Existing project context file:**
+
+\`\`\`
+${ctx.existingAgentsMd}
+\`\`\`
+` : "";
+  return composePrompt(loadTemplate("repo-onboard"), {
+    REPO_PATH: ctx.repoPath,
+    MODE: ctx.mode,
+    EXISTING_AGENTS_MD: existingSection,
+    PROJECT_TYPE: ctx.projectType || "unknown",
+    CHECK_SCRIPT_SUGGESTION: ctx.checkScriptSuggestion,
+    FILE_NAME: ctx.fileName
+  });
+}
+
+export {
+  buildInteractivePrompt,
+  buildAutoPrompt,
+  buildTaskExecutionPrompt,
+  buildTicketRefinePrompt,
+  buildIdeatePrompt,
+  buildIdeateAutoPrompt,
+  buildEvaluatorPrompt,
+  buildSprintFeedbackPrompt,
+  buildCheckScriptDiscoverPrompt,
+  buildRepoOnboardPrompt,
+  processLifecycleAdapter,
+  resolveProvider,
+  providerDisplayName,
+  getActiveProvider,
+  spawnInteractive,
+  enterAltScreen,
+  exitAltScreen,
+  registerTuiInstance,
+  withSuspendedTui,
+  ProviderAiSessionAdapter,
+  SignalParser
+};