@glrs-dev/cli 2.3.0 → 2.4.0

package/dist/commands/autopilot-interactive.js

@@ -0,0 +1,248 @@
+import {
+  __require
+} from "../chunk-3RG5ZIWI.js";
+
+// src/commands/autopilot-interactive.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/plan-paths.ts
+import { execFile } from "child_process";
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+function execFileP(file, args, opts = {}) {
+  const { cwd, timeoutMs = 5e3 } = opts;
+  return new Promise((resolve3, reject) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    execFile(
+      file,
+      args,
+      { signal: controller.signal, cwd, encoding: "utf8" },
+      (err, stdout) => {
+        clearTimeout(timer);
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve3(stdout ?? "");
+      }
+    );
+  });
+}
+function expandTilde(p) {
+  if (p === "~") return os.homedir();
+  if (p.startsWith("~/")) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+async function getRepoFolder(worktreeDir) {
+  let stdout;
+  try {
+    stdout = await execFileP(
+      "git",
+      ["rev-parse", "--git-common-dir"],
+      { cwd: worktreeDir }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error running `git rev-parse --git-common-dir`";
+    throw new Error(
+      `getRepoFolder: failed to resolve git-common-dir for ${worktreeDir}: ${msg}`
+    );
+  }
+  const gitCommonDir = stdout.trim();
+  if (!gitCommonDir) {
+    throw new Error(
+      `getRepoFolder: \`git rev-parse --git-common-dir\` returned empty for ${worktreeDir}`
+    );
+  }
+  const absCommonDir = path.isAbsolute(gitCommonDir) ? gitCommonDir : path.resolve(worktreeDir, gitCommonDir);
+  const repoRoot = path.dirname(absCommonDir);
+  return path.basename(repoRoot);
+}
+async function getPlanDir(worktreeDir) {
+  const override = process.env.GLRS_PLAN_DIR ?? process.env.GLORIOUS_PLAN_DIR;
+  const base = override ? expandTilde(override) : path.join(os.homedir(), ".glrs", "opencode");
+  const repoFolder = await getRepoFolder(worktreeDir);
+  const planDir = path.join(base, repoFolder, "plans");
+  await fs.mkdir(planDir, { recursive: true });
+  return planDir;
+}
+
+// src/commands/autopilot-interactive.ts
+function defaultBanner(message) {
+  process.stdout.write(`
+${message}
+`);
+}
+async function orchestrateAutopilot(opts, deps) {
+  const banner = deps.onBanner ?? defaultBanner;
+  const cwd = opts.cwd ?? process.cwd();
+  banner("\u2192 Phase 1/3: Scoping (interactive)...");
+  const scoperResult = await deps.runScoper({
+    planDir: opts.planDir,
+    slug: opts.slug,
+    initialGoal: opts.initialGoal,
+    ...opts.existingPlanContent ? { existingPlanContent: opts.existingPlanContent } : {}
+  });
+  banner(`\u2713 Scope captured at ${scoperResult.scopePath}`);
+  const actualSlug = path2.basename(path2.dirname(scoperResult.scopePath));
+  banner("\u2192 Phase 2/3: Planning (headless)...");
+  const planResult = await deps.runPlan({
+    scopePath: scoperResult.scopePath,
+    planDir: opts.planDir,
+    slug: actualSlug || opts.slug
+  });
+  banner(`\u2713 Plan written at ${planResult.planPath}`);
+  banner("\u2192 Phase 3/3: Executing (headless loop)...");
+  const loopResult = await deps.runLoop({
+    planPath: planResult.planPath,
+    cwd
+  });
+  return {
+    scopePath: scoperResult.scopePath,
+    planPath: planResult.planPath,
+    loopResult
+  };
+}
+function deriveSlug(goal) {
+  const slug = goal.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+  return slug.length > 0 ? slug : `feature-${Date.now()}`;
+}
+function extractGoalFromPlan(content, filePath) {
+  const h1Match = content.match(/^#\s+(.+)$/m);
+  if (h1Match) return h1Match[1].trim();
+  const goalSectionMatch = content.match(/^##\s+Goal\s*\n+([^\n#][^\n]*)/m);
+  if (goalSectionMatch) return goalSectionMatch[1].trim();
+  const base = path2.basename(filePath, path2.extname(filePath));
+  return base.replace(/-/g, " ");
+}
+async function runInteractiveAutopilot(cwd, planPath, _deps, options) {
+  const _getPlanDir = _deps?.getPlanDir ?? getPlanDir;
+  const planDir = await _getPlanDir(cwd);
+  let goal;
+  let ticketRef;
+  let existingPlanContent;
+  if (planPath) {
+    const resolvedPath = path2.resolve(cwd, planPath);
+    const isDir = fs2.existsSync(resolvedPath) && fs2.statSync(resolvedPath).isDirectory();
+    const hasMainMd = isDir && fs2.existsSync(path2.join(resolvedPath, "main.md"));
+    const isMdFile = !isDir && resolvedPath.endsWith(".md") && fs2.existsSync(resolvedPath);
+    if (isDir && !hasMainMd) {
+      const { pickPlanFile } = await import("./plan-picker.js");
+      const picked = await pickPlanFile(resolvedPath);
+      if (!picked) {
+        return {
+          scopePath: "",
+          planPath: resolvedPath,
+          loopResult: { exitReason: "error", iterations: 0, message: "No plan selected." }
+        };
+      }
+      return runInteractiveAutopilot(cwd, picked, _deps, options);
+    }
+    if (hasMainMd || isMdFile) {
+      const { parsePlanState } = await import("@glrs-dev/autopilot");
+      const planState = parsePlanState(resolvedPath);
+      if (planState.totalItems > 0) {
+        const banner = _deps?.onBanner ?? ((msg) => process.stdout.write(`
+${msg}
+`));
+        const unchecked = planState.totalItems - planState.checkedItems;
+        if (unchecked === 0) {
+          banner(`\u26A0 All ${planState.totalItems} items already checked \u2014 nothing to execute`);
+          return {
+            scopePath: "",
+            planPath: resolvedPath,
+            loopResult: { exitReason: "sentinel", iterations: 0, message: "All items already checked." }
+          };
+        }
+        banner(`\u2192 Plan validated: ${unchecked}/${planState.totalItems} items remaining`);
+        if (planState.type === "multi") {
+          banner(`  ${planState.phaseCount} phases, ${planState.phaseCount - planState.phasesCompleted} remaining`);
+        }
+        banner(`\u2192 Executing against: ${resolvedPath}`);
+        const { runLoopSession: runLoopSession2 } = await import("@glrs-dev/autopilot");
+        const _runLoop = _deps?.runLoop ?? runLoopSession2;
+        const loopResult = await _runLoop({ planPath: resolvedPath, cwd, fast: options?.fast, resume: options?.resume, maxIterationsPerPhase: options?.maxIterationsPerPhase, parallel: options?.parallel, ship: options?.ship, logger: options?.logger });
+        return {
+          scopePath: "",
+          planPath: resolvedPath,
+          loopResult
+        };
+      }
+      if (isDir) {
+        const banner = _deps?.onBanner ?? ((msg) => process.stdout.write(`
+${msg}
+`));
+        banner(`\u2192 Executing plan directory: ${resolvedPath}`);
+        const { runLoopSession: runLoopSession2 } = await import("@glrs-dev/autopilot");
+        const _runLoop = _deps?.runLoop ?? runLoopSession2;
+        const loopResult = await _runLoop({ planPath: resolvedPath, cwd, fast: options?.fast, resume: options?.resume, maxIterationsPerPhase: options?.maxIterationsPerPhase, parallel: options?.parallel, ship: options?.ship, logger: options?.logger });
+        return {
+          scopePath: "",
+          planPath: resolvedPath,
+          loopResult
+        };
+      }
+    }
+    const content = fs2.readFileSync(resolvedPath, "utf-8");
+    goal = extractGoalFromPlan(content, resolvedPath);
+    ticketRef = "";
+    existingPlanContent = content;
+  } else {
+    if (_deps?.promptGoal) {
+      goal = await _deps.promptGoal();
+    } else {
+      const { input } = await import("@inquirer/prompts");
+      goal = await input({
+        message: "What do you want to build? (one sentence, free-form)",
+        validate: (v) => v.trim().length > 0 ? true : "Please describe what you want to build."
+      });
+    }
+    if (_deps?.promptTicketRef) {
+      ticketRef = await _deps.promptTicketRef();
+    } else {
+      const { input } = await import("@inquirer/prompts");
+      ticketRef = await input({
+        message: "Optional ticket or issue ref (Linear ID, GitHub issue URL, etc.)",
+        default: ""
+      });
+    }
+  }
+  const slug = deriveSlug(goal);
+  const seedDir = path2.join(planDir, slug);
+  const seedPath = path2.join(seedDir, "scope-seed.md");
+  const _mkdirSync = _deps?.mkdirSync ?? ((p, o) => fs2.mkdirSync(p, o));
+  const _writeFileSync = _deps?.writeFileSync ?? fs2.writeFileSync;
+  _mkdirSync(seedDir, { recursive: true });
+  const seedContent = [
+    `# Scope Seed: ${slug}`,
+    "",
+    `## Goal`,
+    "",
+    goal,
+    "",
+    ...ticketRef.trim() ? [`## Ticket / Issue Ref`, "", ticketRef.trim(), ""] : []
+  ].join("\n");
+  _writeFileSync(seedPath, seedContent);
+  const { runScoperSession } = await import("./scoper.js");
+  const { runPlanSession } = await import("@glrs-dev/autopilot");
+  const { runLoopSession } = await import("@glrs-dev/autopilot");
+  return orchestrateAutopilot(
+    { slug, planDir, cwd, initialGoal: goal, existingPlanContent },
+    {
+      runScoper: _deps?.runScoper ?? runScoperSession,
+      runPlan: _deps?.runPlan ?? ((opts) => {
+        const { OpenCodeAdapter } = __require("@glrs-dev/adapter-opencode");
+        return runPlanSession({ ...opts, adapter: new OpenCodeAdapter() });
+      }),
+      runLoop: _deps?.runLoop ?? runLoopSession,
+      onBanner: _deps?.onBanner
+    }
+  );
+}
+export {
+  deriveSlug,
+  orchestrateAutopilot,
+  runInteractiveAutopilot
+};

package/dist/commands/autopilot-raw.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env bun

package/dist/commands/autopilot-raw.js

@@ -0,0 +1,368 @@
+#!/usr/bin/env bun
+
+// src/commands/autopilot-raw.ts
+import { createOpencode } from "@opencode-ai/sdk";
+import * as YAML from "yaml";
+import * as fs from "fs";
+import * as path from "path";
+var planDirArg = process.argv[2];
+if (!planDirArg) {
+  process.stderr.write("Usage: bun autopilot-raw.ts <plan-dir>\n");
+  process.exit(1);
+}
+var PLAN_DIR = path.resolve(planDirArg);
+var SPEC_DIR = path.join(PLAN_DIR, "spec");
+var MAIN_YAML = path.join(SPEC_DIR, "main.yaml");
+var MAX_ITERATIONS = 10;
+var POLL_INTERVAL_MS = 2e3;
+if (!fs.existsSync(PLAN_DIR) || !fs.statSync(PLAN_DIR).isDirectory()) {
+  process.stderr.write(`Plan dir does not exist: ${PLAN_DIR}
+`);
+  process.exit(1);
+}
+function log(level, msg) {
+  const ts = (/* @__PURE__ */ new Date()).toTimeString().slice(0, 8);
+  process.stderr.write(`${ts} [${level.padEnd(4)}] ${msg}
+`);
+}
+function unwrap(res) {
+  if (res && typeof res === "object" && "data" in res) return res.data;
+  return res;
+}
+function listMarkdownFiles() {
+  return fs.readdirSync(PLAN_DIR).filter((f) => f.endsWith(".md") && (f === "main.md" || /^wave_/.test(f))).sort((a, b) => {
+    if (a === "main.md") return -1;
+    if (b === "main.md") return 1;
+    return a.localeCompare(b, void 0, { numeric: true });
+  });
+}
+function specPathFor(mdFile) {
+  return path.join(SPEC_DIR, mdFile.replace(/\.md$/, ".yaml"));
+}
+function specIsComplete(mdFile) {
+  const p = specPathFor(mdFile);
+  if (!fs.existsSync(p)) return false;
+  try {
+    const data = YAML.parse(fs.readFileSync(p, "utf8"));
+    if (mdFile === "main.md") return Array.isArray(data?.phases) && data.phases.length > 0;
+    if (!Array.isArray(data?.items) || data.items.length === 0) return false;
+    return data.items.every((it) => typeof it?.id === "string" && typeof it?.checked === "boolean");
+  } catch {
+    return false;
+  }
+}
+function readPhaseItems(specPath) {
+  try {
+    const data = YAML.parse(fs.readFileSync(specPath, "utf8"));
+    return Array.isArray(data?.items) ? data.items : [];
+  } catch {
+    return [];
+  }
+}
+function markPhaseCompleted(phaseFile) {
+  try {
+    const data = YAML.parse(fs.readFileSync(MAIN_YAML, "utf8"));
+    for (const p of data?.phases ?? []) {
+      if (p.file === phaseFile) p.completed = true;
+    }
+    fs.writeFileSync(MAIN_YAML, YAML.stringify(data));
+  } catch (e) {
+    log("ERR", `Failed to mark ${phaseFile} completed: ${e}`);
+  }
+}
+var opencode = await createOpencode({ hostname: "127.0.0.1", port: 0, timeout: 3e4 });
+var { client, server } = opencode;
+log("INFO", `Server ready at ${server.url}`);
+var shuttingDown = false;
+async function shutdown(code = 0) {
+  if (shuttingDown) process.exit(code);
+  shuttingDown = true;
+  try {
+    await server.close();
+  } catch {
+  }
+  process.exit(code);
+}
+process.on("SIGINT", () => {
+  log("INFO", "SIGINT");
+  void shutdown(0);
+});
+process.on("SIGTERM", () => {
+  void shutdown(0);
+});
+var currentWait = null;
+function settle(w, r) {
+  clearTimeout(w.timer);
+  if (currentWait === w) currentWait = null;
+  w.resolve(r);
+}
+function waitForSession(sessionId, timeoutMs = 10 * 60 * 1e3) {
+  return new Promise((resolve2) => {
+    const w = {
+      sessionId,
+      resolve: resolve2,
+      timer: setTimeout(() => {
+        log("ERR", "Timeout");
+        settle(w, "timeout");
+      }, timeoutMs)
+    };
+    currentWait = w;
+  });
+}
+(async function consumeEvents() {
+  try {
+    const subscribed = await client.event.subscribe();
+    const stream = subscribed?.stream ?? subscribed?.data?.stream;
+    if (!stream) {
+      log("ERR", "No SSE stream");
+      return;
+    }
+    for await (const evt of stream) {
+      const type = evt?.type ?? "";
+      const props = evt?.properties ?? {};
+      const w = currentWait;
+      if (type === "session.idle" && w && props.sessionID === w.sessionId) {
+        settle(w, "idle");
+      } else if (type === "session.error" && w && props.sessionID === w.sessionId) {
+        const err = props.error?.data?.message ?? props.error?.message ?? "unknown";
+        log("ERR", `session.error: ${err}`);
+        settle(w, "error");
+      }
+    }
+  } catch (e) {
+    log("ERR", `SSE crashed: ${e}`);
+  }
+})();
+function startPoller(sessionId) {
+  const seenParts = /* @__PURE__ */ new Set();
+  let running = true;
+  const poll = async () => {
+    while (running) {
+      await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+      if (!running) break;
+      try {
+        const msgs = unwrap(await client.session.messages({ path: { id: sessionId } }));
+        if (!msgs) continue;
+        for (const msg of msgs) {
+          if (msg?.info?.role !== "assistant") continue;
+          for (const part of msg?.parts ?? []) {
+            if (part?.type !== "tool") continue;
+            const key = `${part.callID ?? part.id}:${part.state?.status}`;
+            if (seenParts.has(key)) continue;
+            seenParts.add(key);
+            const tool = part.tool ?? "?";
+            const status = part.state?.status ?? "?";
+            const title = part.state?.title ?? "";
+            const input = part.state?.input;
+            let arg = "";
+            if (input && typeof input === "object") {
+              for (const k of ["filePath", "file_path", "path", "command", "pattern", "query"]) {
+                const v = input[k];
+                if (typeof v === "string" && v.length > 0) {
+                  arg = v.split("\n")[0].slice(0, 80);
+                  break;
+                }
+              }
+            }
+            if (status === "completed") {
+              log("TOOL", `\u2713 ${tool} ${arg || title}`);
+            } else if (status === "error") {
+              const err = (part.state?.error ?? "").toString().slice(0, 100);
+              log("ERR", `\u2717 ${tool} ${arg || title} \u2192 ${err}`);
+            } else if (status === "running") {
+              log("TOOL", `\u25B6 ${tool} ${arg || title}`);
+            }
+          }
+          const cost = msg?.info?.cost;
+          const tokens = msg?.info?.tokens;
+          if (cost > 0 && !seenParts.has(`cost:${msg.info.id}`)) {
+            seenParts.add(`cost:${msg.info.id}`);
+            const parts = [`$${cost.toFixed(4)}`, `in=${tokens?.input ?? 0}`, `out=${tokens?.output ?? 0}`];
+            if (tokens?.cache?.read) parts.push(`cache=${tokens.cache.read}`);
+            log("COST", parts.join(" | "));
+          }
+        }
+      } catch {
+      }
+    }
+  };
+  poll();
+  return { stop: () => {
+    running = false;
+  } };
+}
+async function runPrompt(agent, text, model) {
+  const session = unwrap(await client.session.create({ body: {} }));
+  const sessionId = session?.id;
+  if (!sessionId) {
+    log("ERR", "No session ID");
+    return { sessionId: "", result: "error" };
+  }
+  log("INFO", `Session: ${sessionId} (${agent}${model ? ` \u2192 ${model.providerID}/${model.modelID}` : ""})`);
+  const waiter = waitForSession(sessionId);
+  const poller = startPoller(sessionId);
+  const body = { parts: [{ type: "text", text }] };
+  if (agent && agent !== "default") body.agent = agent;
+  if (model) body.model = model;
+  client.session.prompt({ path: { id: sessionId }, body }).catch((e) => {
+    log("ERR", `prompt rejected: ${e}`);
+    if (currentWait?.sessionId === sessionId) settle(currentWait, "error");
+  });
+  const result = await waiter;
+  await new Promise((r) => setTimeout(r, 500));
+  poller.stop();
+  return { sessionId, result };
+}
+function enrichmentPromptForMain(waveYamlFiles) {
+  const mainRel = path.relative(process.cwd(), path.join(PLAN_DIR, "main.md"));
+  const specRel = path.relative(process.cwd(), MAIN_YAML);
+  const phaseLines = waveYamlFiles.map((f) => `  - file: ${f}
+    completed: false`).join("\n");
+  return `Read the plan at \`${mainRel}\` and write a structured YAML spec to \`${specRel}\` using the file_edit tool.
+
+The YAML must have this exact shape:
+
+\`\`\`yaml
+title: "<plan title>"
+goal: "<goal text>"
+phases:
+${phaseLines}
+\`\`\`
+
+Use the file_edit tool to create \`${specRel}\`. Output no prose.`;
+}
+function enrichmentPromptForWave(mdFile) {
+  const mdRel = path.relative(process.cwd(), path.join(PLAN_DIR, mdFile));
+  const specRel = path.relative(process.cwd(), specPathFor(mdFile));
+  return `Read the phase plan at \`${mdRel}\` and write a structured YAML spec to \`${specRel}\` using the file_edit tool.
+
+First read the markdown. Then read relevant codebase files for context. Write a YAML file:
+
+\`\`\`yaml
+items:
+  - id: "1.1"
+    intent: "what this does"
+    checked: false
+    files:
+      - path: <relative path>
+        isNew: <bool>
+    verify: "<shell command>"
+\`\`\`
+
+Rules:
+- Every item starts with checked: false.
+- Cover every actionable item. Do not invent items.
+- Use the file_edit tool to create \`${specRel}\`. Output no prose.`;
+}
+async function runEnrichment() {
+  log("INFO", "\u2550\u2550\u2550 ENRICHMENT \u2550\u2550\u2550");
+  const mdFiles = listMarkdownFiles();
+  fs.mkdirSync(SPEC_DIR, { recursive: true });
+  for (const mdFile of mdFiles) {
+    if (specIsComplete(mdFile)) {
+      log("DIM", `Skip ${mdFile}`);
+      continue;
+    }
+    log("INFO", `Enriching ${mdFile}`);
+    const prompt = mdFile === "main.md" ? enrichmentPromptForMain(mdFiles.filter((f) => f !== "main.md").map((f) => f.replace(/\.md$/, ".yaml"))) : enrichmentPromptForWave(mdFile);
+    const { result } = await runPrompt("prime", prompt);
+    if (result !== "idle") {
+      log("ERR", `Enrichment ${mdFile}: ${result}`);
+      continue;
+    }
+    log("INFO", specIsComplete(mdFile) ? `\u2713 ${mdFile}` : `\u26A0 ${mdFile} incomplete`);
+  }
+}
+function executionPrompt(phaseFile, yamlText) {
+  const specRel = path.relative(process.cwd(), path.join(SPEC_DIR, phaseFile));
+  return `You are completing one phase of a plan. The phase spec lives at \`${specRel}\`:
+
+\`\`\`yaml
+${yamlText}
+\`\`\`
+
+Complete every item where checked: false. For each:
+1. Edit or create the files listed.
+2. Run the verify command if present.
+3. Use file_edit to change checked: false to checked: true in \`${specRel}\`.
+
+Rules:
+- Do not modify checked: true items.
+- Work in id order.
+- When all items are checked: true, you are done.`;
+}
+async function runExecution() {
+  log("INFO", "\u2550\u2550\u2550 EXECUTION \u2550\u2550\u2550");
+  if (!fs.existsSync(MAIN_YAML)) {
+    log("ERR", "No spec/main.yaml");
+    return;
+  }
+  let phases = [];
+  try {
+    const main = YAML.parse(fs.readFileSync(MAIN_YAML, "utf8"));
+    phases = main?.phases ?? [];
+  } catch (e) {
+    log("ERR", `Parse error: ${e}`);
+    return;
+  }
+  const remaining = phases.filter((p) => !p.completed);
+  log("INFO", `${phases.length} phases, ${remaining.length} remaining`);
+  if (remaining.length === 0) {
+    log("INFO", "All done.");
+    return;
+  }
+  for (let i = 0; i < remaining.length; i++) {
+    const phase = remaining[i];
+    log("INFO", `
+\u2550\u2550\u2550 PHASE: ${phase.file} (${i + 1}/${remaining.length}) \u2550\u2550\u2550`);
+    const specPath = path.join(SPEC_DIR, phase.file);
+    if (!fs.existsSync(specPath)) {
+      log("ERR", `Missing: ${specPath}`);
+      continue;
+    }
+    for (let iter = 1; iter <= MAX_ITERATIONS; iter++) {
+      const items2 = readPhaseItems(specPath);
+      const unchecked = items2.filter((it) => !it.checked);
+      if (items2.length > 0 && unchecked.length === 0) {
+        log("INFO", `\u2713 ${phase.file} complete (${items2.length}/${items2.length})`);
+        markPhaseCompleted(phase.file);
+        break;
+      }
+      log("INFO", `Iter ${iter}/${MAX_ITERATIONS} \u2014 ${items2.length - unchecked.length}/${items2.length} done`);
+      const yamlText = fs.readFileSync(specPath, "utf8");
+      const { result } = await runPrompt("build", executionPrompt(phase.file, yamlText), {
+        providerID: "amazon-bedrock",
+        modelID: "zai.glm-5"
+      });
+      if (result !== "idle") {
+        log("ERR", `Iter ${iter}: ${result}`);
+        break;
+      }
+    }
+    const items = readPhaseItems(specPath);
+    if (items.length > 0 && items.every((it) => it.checked)) {
+      markPhaseCompleted(phase.file);
+    } else {
+      log("WARN", `${phase.file}: ${items.filter((it) => it.checked).length}/${items.length}`);
+    }
+  }
+}
+var phasesRemaining = (() => {
+  if (!fs.existsSync(MAIN_YAML)) return "?";
+  try {
+    const m = YAML.parse(fs.readFileSync(MAIN_YAML, "utf8"));
+    return (m?.phases ?? []).filter((p) => !p.completed).length;
+  } catch {
+    return "?";
+  }
+})();
+log("INFO", `Plan: ${PLAN_DIR} (${listMarkdownFiles().length} md, ${phasesRemaining} phases remaining)`);
+try {
+  await runEnrichment();
+  await runExecution();
+  log("INFO", "\n\u2713 Done.");
+} catch (e) {
+  log("ERR", `Fatal: ${e?.stack ?? e}`);
+} finally {
+  await shutdown(0);
+}

package/dist/commands/autopilot-tui.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `glrs autopilot` — TUI plan picker at cwd, then run the autopilot session
+ * with live event rendering to stderr.
+ */
+declare function runAutopilot(): Promise<void>;
+
+export { runAutopilot };

package/dist/commands/autopilot-tui.js

@@ -0,0 +1,7 @@
+import {
+  runAutopilot
+} from "../chunk-2VMFXAJH.js";
+import "../chunk-3RG5ZIWI.js";
+export {
+  runAutopilot
+};

package/dist/commands/autopilot.d.ts

@@ -0,0 +1,39 @@
+import * as cmd_ts_dist_cjs_runner_js from 'cmd-ts/dist/cjs/runner.js';
+import * as cmd_ts_dist_cjs_helpdoc_js from 'cmd-ts/dist/cjs/helpdoc.js';
+import * as cmd_ts_dist_cjs_argparser_js from 'cmd-ts/dist/cjs/argparser.js';
+
+/**
+ * `glrs oc autopilot` — Interactive three-phase autopilot orchestrator.
+ *
+ * --plan / -p <path>: use an existing plan at this path.
+ * --fast / -f: enrich plan for fast-model execution, then run with mid-execute tier.
+ * --status: read and pretty-print the current autopilot status from .agent/autopilot-status.json.
+ *
+ * When no --plan is given, opens an interactive file picker.
+ * When a plan is provided and has checkboxes, skips scoping/planning and executes directly.
+ *
+ * This is a thin wrapper: parse args → create SessionRunner → attach CLI renderer → run.
+ */
+declare const autopilotInteractiveCmd: Partial<cmd_ts_dist_cjs_argparser_js.Register> & {
+    parse(context: cmd_ts_dist_cjs_argparser_js.ParseContext): Promise<cmd_ts_dist_cjs_argparser_js.ParsingResult<{
+        plan: string | undefined;
+        fast: boolean;
+        resume: boolean;
+        maxIterationsPerPhase: number | undefined;
+        parallel: number | undefined;
+        ship: boolean;
+        status: boolean;
+    }>>;
+} & cmd_ts_dist_cjs_helpdoc_js.PrintHelp & cmd_ts_dist_cjs_helpdoc_js.ProvidesHelp & cmd_ts_dist_cjs_helpdoc_js.Named & Partial<cmd_ts_dist_cjs_helpdoc_js.Versioned> & cmd_ts_dist_cjs_argparser_js.Register & cmd_ts_dist_cjs_runner_js.Handling<{
+    plan: string | undefined;
+    fast: boolean;
+    resume: boolean;
+    maxIterationsPerPhase: number | undefined;
+    parallel: number | undefined;
+    ship: boolean;
+    status: boolean;
+}, Promise<void>> & {
+    run(context: cmd_ts_dist_cjs_argparser_js.ParseContext): Promise<cmd_ts_dist_cjs_argparser_js.ParsingResult<Promise<void>>>;
+} & Partial<cmd_ts_dist_cjs_helpdoc_js.Versioned & cmd_ts_dist_cjs_helpdoc_js.Descriptive & cmd_ts_dist_cjs_helpdoc_js.Aliased>;
+
+export { autopilotInteractiveCmd };