@glrs-dev/harness-plugin-opencode 2.2.0 → 2.3.0

package/dist/cli.js

@@ -6,17 +6,24 @@ import {
   refreshPluginCache,
   validateModelOverride
 } from "./chunk-PDMXYZM4.js";
+import {
+  MAX_ITERATIONS,
+  TIMEOUT_MS,
+  runRalphLoop
+} from "./chunk-NIFAVPNN.js";
+import "./chunk-MJSMBY2Y.js";
+import {
+  createSession,
+  getLastAssistantMessage,
+  sendAndWait
+} from "./chunk-GCWHRUOK.js";
 
 // src/cli.ts
 import {
   binary,
-  command as command2,
-  flag,
-  option as option2,
-  optional as optional2,
+  command as command3,
+  flag as flag2,
   positional as positional2,
-  restPositionals,
-  string,
   subcommands,
   run
 } from "cmd-ts";
@@ -1093,9 +1100,9 @@ function getOpencodeConfigPath3() {
   const configHome = process.env["XDG_CONFIG_HOME"] ?? path5.join(os4.homedir(), ".config");
   return path5.join(configHome, "opencode", "opencode.json");
 }
-function cmd(command3) {
+function cmd(command4) {
   try {
-    return execSync(command3, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return execSync(command4, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
     return null;
   }
@@ -1216,12 +1223,6 @@ ${c3.bold}Doctor \u2014 ${PLUGIN_NAME3}${c3.reset}
   } else {
     warn2("node/npx not found \u2014 memory MCP won't work");
   }
-  const planCheckResult = cmd(`bunx ${PLUGIN_NAME3} plan-check --help 2>/dev/null`);
-  if (planCheckResult !== null) {
-    ok2("plan-check CLI invokable");
-  } else {
-    warn2("plan-check CLI not invokable \u2014 try: bun install");
-  }
   if (which("bun")) {
     ok2(`bun ${cmd("bun --version") ?? ""}`);
   } else if (which("npm")) {
@@ -1232,41 +1233,168 @@ ${c3.bold}Doctor \u2014 ${PLUGIN_NAME3}${c3.reset}
   console.log();
 }
 
-// src/bin/plan-check.ts
-import { execFileSync } from "child_process";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname3, join as join5 } from "path";
-function planCheck(args) {
-  const here = dirname3(fileURLToPath2(import.meta.url));
-  const candidates = [
-    join5(here, "plan-check.sh"),
-    // dev: src/bin/plan-check.sh
-    join5(here, "bin", "plan-check.sh")
-    // dist: dist/ → dist/bin/plan-check.sh
-  ];
-  let scriptPath;
-  for (const p of candidates) {
+// src/autopilot/cli.ts
+import { command, option, positional, string as stringType, optional, number as numberType, flag } from "cmd-ts";
+
+// src/autopilot/debrief.ts
+function shouldRunDebrief(opts) {
+  if (opts.noDebrief) return false;
+  const envVal = opts.env["GLRS_AUTOPILOT_DEBRIEF"];
+  if (envVal !== void 0 && envVal.toLowerCase() === "off") return false;
+  return true;
+}
+async function defaultExecGitDiffStat(cwd) {
+  const { execFile: execFileCb } = await import("child_process");
+  const { promisify } = await import("util");
+  const execFile2 = promisify(execFileCb);
+  try {
+    const { stdout } = await execFile2("git", ["diff", "--stat", "HEAD~1", "HEAD"], { cwd });
+    return stdout.trim();
+  } catch {
     try {
-      execFileSync("test", ["-f", p]);
-      scriptPath = p;
-      break;
+      const { stdout } = await execFile2("git", ["diff", "--stat"], { cwd });
+      return stdout.trim() || "(no uncommitted changes)";
     } catch {
+      return "(git diff unavailable)";
     }
   }
-  if (!scriptPath) {
-    console.error("plan-check: could not find plan-check.sh");
-    process.exit(2);
-  }
+}
+function buildContextMessage(loopResult, prompt, gitDiffStat) {
+  const cost = loopResult.cumulativeCostUsd !== void 0 ? `$${loopResult.cumulativeCostUsd.toFixed(4)}` : "not available";
+  const sessionId = loopResult.sessionId ?? "not available";
+  return [
+    "## Autopilot session context",
+    "",
+    `**Exit reason:** ${loopResult.exitReason}`,
+    `**Iterations completed:** ${loopResult.iterations}`,
+    `**Exit message:** ${loopResult.message}`,
+    `**Cumulative cost:** ${cost}`,
+    `**Session ID:** ${sessionId}`,
+    "",
+    "## Original prompt",
+    "",
+    prompt,
+    "",
+    "## Git diff stat (last commit vs HEAD~1)",
+    "",
+    gitDiffStat || "(no changes)",
+    "",
+    "---",
+    "",
+    "Please produce the five-section debrief as instructed in your system prompt."
+  ].join("\n");
+}
+async function runDebrief(opts) {
+  const _createSession = opts._deps?.createSession ?? createSession;
+  const _sendAndWait = opts._deps?.sendAndWait ?? sendAndWait;
+  const _getLastAssistantMessage = opts._deps?.getLastAssistantMessage ?? getLastAssistantMessage;
+  const _execGitDiffStat = opts._deps?.execGitDiffStat ?? defaultExecGitDiffStat;
   try {
-    execFileSync("bash", [scriptPath, ...args], {
-      stdio: "inherit",
-      encoding: "utf8"
+    const gitDiffStat = await _execGitDiffStat(opts.cwd).catch(() => "(git diff unavailable)");
+    const contextMessage = buildContextMessage(opts.loopResult, opts.prompt, gitDiffStat);
+    const sessionId = await _createSession(opts.server.client, {
+      cwd: opts.cwd,
+      agentName: "debriefer"
     });
-  } catch (e) {
-    process.exit(e.status ?? 1);
+    await _sendAndWait(opts.server.client, {
+      sessionId,
+      message: contextMessage,
+      stallMs: 5 * 60 * 1e3
+      // 5 min stall timeout for debrief
+    });
+    const debriefOutput = await _getLastAssistantMessage(opts.server.client, sessionId);
+    if (debriefOutput) {
+      process.stdout.write("\n\x1B[1m\u2500\u2500\u2500 Autopilot Debrief \u2500\u2500\u2500\x1B[0m\n\n");
+      process.stdout.write(debriefOutput);
+      process.stdout.write("\n\n");
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`\x1B[33m\u26A0 Debrief failed (non-fatal): ${msg}\x1B[0m
+`);
   }
 }
 
+// src/autopilot/cli.ts
+var loopCmd = command({
+  name: "loop",
+  description: "Run the Ralph loop: send a prompt to PRIME repeatedly until it emits <autopilot-done> or a budget is exhausted.",
+  args: {
+    prompt: positional({
+      type: stringType,
+      displayName: "prompt",
+      description: "The prompt to send to PRIME each iteration (e.g. a Linear issue ref or free-form task)."
+    }),
+    maxIterations: option({
+      long: "max-iterations",
+      type: optional(numberType),
+      description: `Maximum number of loop iterations (default: ${MAX_ITERATIONS}).`
+    }),
+    timeout: option({
+      long: "timeout",
+      type: optional(numberType),
+      description: `Total wall-clock timeout in milliseconds (default: ${TIMEOUT_MS} = 4 hours).`
+    }),
+    noDebrief: flag({
+      long: "no-debrief",
+      description: "Skip the post-run debrief session."
+    })
+  },
+  handler: async ({ prompt, maxIterations, timeout, noDebrief }) => {
+    const cwd = process.cwd();
+    process.stdout.write("\n\x1B[1mAutopilot \u2014 Ralph loop\x1B[0m\n");
+    process.stdout.write(`Prompt: ${prompt.slice(0, 80)}${prompt.length > 80 ? "..." : ""}
+`);
+    process.stdout.write(`Max iterations: ${maxIterations ?? MAX_ITERATIONS}
+`);
+    process.stdout.write(`Timeout: ${((timeout ?? TIMEOUT_MS) / 36e5).toFixed(1)}h
+
+`);
+    const result = await runRalphLoop({
+      prompt,
+      cwd,
+      maxIterations: maxIterations ?? void 0,
+      timeoutMs: timeout ?? void 0
+    });
+    const icon = result.exitReason === "sentinel" ? "\x1B[32m\u2713\x1B[0m" : result.exitReason === "kill-switch" ? "\x1B[33m\u2298\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+    process.stdout.write(`
+${icon} ${result.message}
+`);
+    process.stdout.write(`  Iterations: ${result.iterations}
+
+`);
+    if (shouldRunDebrief({ noDebrief, env: process.env })) {
+      const { startServer } = await import("./opencode-server-KPCDFYAX.js");
+      let debriefServer;
+      try {
+        debriefServer = await startServer({ cwd });
+        await runDebrief({
+          server: debriefServer,
+          loopResult: result,
+          prompt,
+          cwd
+        });
+      } catch {
+        process.stderr.write("\x1B[33m\u26A0 Debrief server failed to start (non-fatal)\x1B[0m\n");
+      } finally {
+        await debriefServer?.shutdown().catch(() => {
+        });
+      }
+    }
+    if (result.exitReason !== "sentinel" && result.exitReason !== "kill-switch") {
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+});
+
+// src/autopilot/autopilot-cmd.ts
+import { command as command2, option as option2, optional as optional2, string as stringType2 } from "cmd-ts";
+
+// src/autopilot/interactive.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
+
 // src/plan-paths.ts
 import { execFile } from "child_process";
 import * as fs6 from "fs/promises";
@@ -1329,429 +1457,295 @@ async function getPlanDir(worktreeDir) {
   await fs6.mkdir(planDir, { recursive: true });
   return planDir;
 }
-async function migratePlans(worktreeDir, planDir) {
-  const oldDir = path6.join(worktreeDir, ".agent", "plans");
-  const marker = path6.join(oldDir, ".migrated");
-  try {
-    await fs6.stat(oldDir);
-  } catch {
-    return;
-  }
-  try {
-    await fs6.stat(marker);
-    return;
-  } catch {
-  }
-  let entries;
-  try {
-    entries = await fs6.readdir(oldDir);
-  } catch {
-    return;
-  }
-  const planFiles = entries.filter(
-    (name) => name.endsWith(".md") && !name.startsWith(".")
-  );
-  await fs6.mkdir(planDir, { recursive: true });
-  for (const name of planFiles) {
-    const src = path6.join(oldDir, name);
-    const dst = path6.join(planDir, name);
-    let dstExists = false;
-    try {
-      await fs6.stat(dst);
-      dstExists = true;
-    } catch {
-      dstExists = false;
-    }
-    if (!dstExists) {
-      await fs6.rename(src, dst);
-      continue;
-    }
-    const [srcBuf, dstBuf] = await Promise.all([
-      fs6.readFile(src),
-      fs6.readFile(dst)
-    ]);
-    if (srcBuf.equals(dstBuf)) {
-      await fs6.unlink(src);
-      continue;
-    }
-    process.stderr.write(
-      `[harness-opencode] migratePlans: conflict on ${name} \u2014 destination ${dst} exists with different content; leaving source ${src} in place. Resolve manually.
-`
-    );
-  }
-  await fs6.writeFile(marker, "");
-}
 
-// src/autopilot/cli.ts
-import { command, option, positional, string as stringType, optional, number as numberType } from "cmd-ts";
-
-// src/autopilot/loop.ts
-import { execFile as execFileCb } from "child_process";
-import { promisify as promisify2 } from "util";
-import { readFileSync as readFileSync6 } from "fs";
-import { join as join8 } from "path";
-
-// src/lib/opencode-server.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify } from "util";
-import {
-  createOpencodeServer,
-  createOpencodeClient
-} from "@opencode-ai/sdk";
-var execFileP2 = promisify(execFile2);
-var DEFAULT_STARTUP_TIMEOUT_MS = 3e4;
-async function ensureOpencodeOnPath() {
-  try {
-    await execFileP2("opencode", ["--version"]);
-  } catch {
-    throw new Error(
-      "opencode CLI not found on PATH.\n  Install: https://opencode.ai\n  Or: bunx opencode upgrade"
-    );
-  }
-}
-async function startServer(opts) {
-  await ensureOpencodeOnPath();
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
-  const port = opts.port ?? 0;
-  const server = await createOpencodeServer({
-    port,
-    timeout: timeoutMs
-  });
-  const client = createOpencodeClient({ url: server.url });
-  let shutdownCalled = false;
-  const shutdown = async () => {
-    if (shutdownCalled) return;
-    shutdownCalled = true;
-    try {
-      await server.close();
-    } catch {
-    }
-  };
-  return { url: server.url, client, shutdown };
+// src/autopilot/interactive.ts
+function defaultBanner(message) {
+  process.stdout.write(`
+${message}
+`);
 }
-async function createSession(client, opts) {
-  const session = await client.session.create({
-    body: {
-      directory: opts.cwd,
-      ...opts.agentName ? { agentID: opts.agentName } : {}
-    }
+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
   });
-  return session.id;
-}
-async function sendAndWait(client, opts) {
-  const stallMs = opts.stallMs ?? 60 * 60 * 1e3;
-  await client.session.chat({
-    sessionID: opts.sessionId,
-    body: { content: [{ type: "text", text: opts.message }] }
+  banner(`\u2713 Scope captured at ${scoperResult.scopePath}`);
+  const actualSlug = path7.basename(path7.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
   });
-  return waitForIdle(client, {
-    sessionId: opts.sessionId,
-    stallMs,
-    abortSignal: opts.abortSignal
+  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
+  };
 }
-async function waitForIdle(client, opts) {
-  const stallMs = opts.stallMs ?? 60 * 60 * 1e3;
-  return new Promise((resolve2) => {
-    let stallTimer = null;
-    let unsubscribe = null;
-    let settled = false;
-    const settle = (result) => {
-      if (settled) return;
-      settled = true;
-      if (stallTimer) clearTimeout(stallTimer);
-      if (unsubscribe) unsubscribe();
-      resolve2(result);
-    };
-    const resetStall = () => {
-      if (stallTimer) clearTimeout(stallTimer);
-      stallTimer = setTimeout(() => settle({ kind: "stall", stallMs }), stallMs);
-    };
-    if (opts.abortSignal) {
-      if (opts.abortSignal.aborted) {
-        settle({ kind: "abort" });
-        return;
-      }
-      opts.abortSignal.addEventListener("abort", () => settle({ kind: "abort" }), { once: true });
+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()}`;
+}
+async function browsePlansDir(planDir, _readdirSync) {
+  const { select: select2 } = await import("@inquirer/prompts");
+  const readdir2 = _readdirSync ?? ((p, o) => fs7.readdirSync(p, o));
+  let currentDir = planDir;
+  while (true) {
+    const entries = readdir2(currentDir, { withFileTypes: true });
+    const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+    const files = entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name).sort();
+    if (dirs.length === 0 && files.length === 0) {
+      process.stderr.write(`
+  No plans found in ${currentDir}
+
+`);
+      return null;
     }
-    resetStall();
-    const stream = client.event.subscribe();
-    let streamDone = false;
-    (async () => {
-      try {
-        for await (const event of stream) {
-          if (settled) break;
-          const props = event.properties ?? {};
-          const eventSessionId = props["sessionID"];
-          if (eventSessionId !== opts.sessionId) continue;
-          resetStall();
-          const type = event.type ?? "";
-          if (type === "session.idle") {
-            settle({ kind: "idle" });
-            break;
-          }
-          if (type === "session.error") {
-            const msg = props["message"] ?? "session error";
-            settle({ kind: "error", message: msg });
-            break;
-          }
-        }
-      } catch (err) {
-        if (!settled) {
-          settle({ kind: "error", message: err instanceof Error ? err.message : String(err) });
+    const choices = [];
+    for (const d of dirs) {
+      const dirPath = path7.join(currentDir, d);
+      const hasMain = fs7.existsSync(path7.join(dirPath, "main.md"));
+      const fileCount = readdir2(dirPath, { withFileTypes: true }).filter((e) => e.isFile()).length;
+      choices.push({
+        name: hasMain ? `${d}/              (multi-file plan \u2014 ${fileCount} files)` : `${d}/              (${fileCount} files)`,
+        value: `dir:${dirPath}`
+      });
+    }
+    for (const f of files) {
+      choices.push({
+        name: `${f}`,
+        value: `file:${path7.join(currentDir, f)}`
+      });
+    }
+    if (currentDir !== planDir) {
+      choices.push({ name: "\u21A9 Back", value: "back" });
+    }
+    choices.push({ name: "\u2715 Cancel (scope a new feature instead)", value: "cancel" });
+    const answer = await select2({
+      message: "Select a plan:",
+      choices
+    });
+    if (answer === "cancel") return null;
+    if (answer === "back") {
+      currentDir = path7.dirname(currentDir);
+      continue;
+    }
+    if (answer.startsWith("file:")) {
+      return answer.slice("file:".length);
+    }
+    if (answer.startsWith("dir:")) {
+      const dirPath = answer.slice("dir:".length);
+      const hasMain = fs7.existsSync(path7.join(dirPath, "main.md"));
+      if (hasMain) {
+        const dirAction = await select2({
+          message: `${path7.basename(dirPath)}/ has a main.md. What do you want?`,
+          choices: [
+            { name: "Select this as a multi-file plan", value: "select" },
+            { name: "Browse files inside", value: "browse" },
+            { name: "\u21A9 Back", value: "back" }
+          ]
+        });
+        if (dirAction === "select") return dirPath;
+        if (dirAction === "browse") {
+          currentDir = dirPath;
+          continue;
         }
-      } finally {
-        streamDone = true;
+        continue;
       }
-    })();
-    unsubscribe = () => {
-    };
-  });
-}
-async function getLastAssistantMessage(client, sessionId) {
-  try {
-    const messages = await client.session.messages({ path: { id: sessionId } });
-    const assistantMessages = messages.filter((m) => m.info.role === "assistant");
-    if (assistantMessages.length === 0) return "";
-    const last = assistantMessages[assistantMessages.length - 1];
-    return last.parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
-  } catch {
-    return "";
-  }
-}
-
-// src/autopilot/config.ts
-var MAX_ITERATIONS = 50;
-var STRUGGLE_THRESHOLD = 3;
-var TIMEOUT_MS = 4 * 60 * 60 * 1e3;
-var STALL_MS = 60 * 60 * 1e3;
-var KILL_SWITCH_PATH = ".agent/autopilot-disable";
-var SENTINEL_TAG = "<autopilot-done>";
-
-// src/autopilot/sentinel.ts
-function detectSentinel(text) {
-  if (!text.includes(SENTINEL_TAG)) {
-    return false;
-  }
-  const withoutFences = text.replace(/```[\s\S]*?```/g, "");
-  const withoutInline = withoutFences.replace(/`[^`\n]*`/g, "");
-  return withoutInline.includes(SENTINEL_TAG);
-}
-
-// src/autopilot/struggle.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
-var StruggleDetector = class {
-  _consecutiveStalls = 0;
-  _threshold;
-  constructor(threshold) {
-    this._threshold = threshold;
-  }
-  /** Number of consecutive stall iterations recorded so far. */
-  get consecutiveStalls() {
-    return this._consecutiveStalls;
-  }
-  /**
-   * Record the result of one iteration.
-   * @param madeProgress - true if the agent made filesystem changes this iteration.
-   */
-  record(madeProgress) {
-    if (madeProgress) {
-      this._consecutiveStalls = 0;
-    } else {
-      this._consecutiveStalls++;
-    }
-  }
-  /**
-   * Returns true if the agent has stalled for `threshold` consecutive
-   * iterations without making progress.
-   */
-  isStruggling() {
-    return this._consecutiveStalls >= this._threshold;
-  }
-};
-function checkKillSwitch(cwd) {
-  const killSwitchFile = path7.join(cwd, KILL_SWITCH_PATH);
-  return fs7.existsSync(killSwitchFile);
-}
-
-// src/autopilot/loop.ts
-var execFile3 = promisify2(execFileCb);
-function buildFullPrompt(userPrompt) {
-  const candidates = [
-    join8(import.meta.dir, "prompt-template.md"),
-    join8(import.meta.dir, "..", "..", "src", "autopilot", "prompt-template.md")
-  ];
-  let template = "";
-  for (const candidate of candidates) {
-    try {
-      const raw = readFileSync6(candidate, "utf8");
-      template = raw.replace(/^---\n[\s\S]*?\n---\n/, "");
-      break;
-    } catch {
+      currentDir = dirPath;
+      continue;
     }
   }
-  const withArgs = template.replace("$ARGUMENTS", userPrompt);
-  return withArgs || userPrompt;
 }
-async function checkProgress(cwd, baseRef) {
-  try {
-    const { stdout } = await execFile3("git", ["diff", "--stat", baseRef], { cwd });
-    return stdout.trim().length > 0;
-  } catch {
-    return true;
-  }
-}
-async function getHeadSha(cwd) {
-  try {
-    const { stdout } = await execFile3("git", ["rev-parse", "HEAD"], { cwd });
-    return stdout.trim();
-  } catch {
-    return "HEAD";
-  }
-}
-async function runRalphLoop(opts) {
-  const maxIterations = opts.maxIterations ?? MAX_ITERATIONS;
-  const timeoutMs = opts.timeoutMs ?? TIMEOUT_MS;
-  const stallMs = opts.stallMs ?? STALL_MS;
-  const struggleThreshold = opts.struggleThreshold ?? STRUGGLE_THRESHOLD;
-  const _startServer = opts._deps?.startServer ?? startServer;
-  const _createSession = opts._deps?.createSession ?? createSession;
-  const _sendAndWait = opts._deps?.sendAndWait ?? sendAndWait;
-  const _getLastAssistantMessage = opts._deps?.getLastAssistantMessage ?? getLastAssistantMessage;
-  const fullPrompt = buildFullPrompt(opts.prompt);
-  const struggle = new StruggleDetector(struggleThreshold);
-  const startTime = Date.now();
-  const server = await _startServer({ cwd: opts.cwd });
-  const abort = new AbortController();
-  const timeoutHandle = setTimeout(() => {
-    abort.abort();
-  }, timeoutMs);
-  try {
-    const sessionId = await _createSession(server.client, {
-      cwd: opts.cwd,
-      agentName: "prime"
+async function runInteractiveAutopilot(cwd, _deps) {
+  const _getPlanDir = _deps?.getPlanDir ?? getPlanDir;
+  const planDir = await _getPlanDir(cwd);
+  let hasExistingPlan;
+  if (_deps?.promptExistingPlan) {
+    hasExistingPlan = await _deps.promptExistingPlan();
+  } else {
+    const { confirm: confirm2 } = await import("@inquirer/prompts");
+    hasExistingPlan = await confirm2({
+      message: "Do you have an existing plan?",
+      default: false
     });
-    for (let iteration = 1; iteration <= maxIterations; iteration++) {
-      if (checkKillSwitch(opts.cwd)) {
-        return {
-          exitReason: "kill-switch",
-          iterations: iteration - 1,
-          message: `Kill switch active (.agent/autopilot-disable exists). Stopping after ${iteration - 1} iteration(s).`
-        };
-      }
-      if (Date.now() - startTime >= timeoutMs) {
-        return {
-          exitReason: "timeout",
-          iterations: iteration - 1,
-          message: `Total timeout (${timeoutMs}ms) exceeded after ${iteration - 1} iteration(s).`
-        };
-      }
-      const headBefore = await getHeadSha(opts.cwd);
-      const result = await _sendAndWait(server.client, {
-        sessionId,
-        message: fullPrompt,
-        stallMs,
-        abortSignal: abort.signal
+  }
+  if (hasExistingPlan) {
+    const repoLocalPlansDir = path7.join(cwd, "plans");
+    const hasRepoLocal = fs7.existsSync(repoLocalPlansDir) && fs7.statSync(repoLocalPlansDir).isDirectory();
+    const hasShared = fs7.existsSync(planDir) && fs7.statSync(planDir).isDirectory();
+    let browseRoot;
+    if (hasRepoLocal && hasShared) {
+      const { select: select2 } = await import("@inquirer/prompts");
+      const which2 = await select2({
+        message: "Where are your plans?",
+        choices: [
+          { name: `./plans/ (repo-local)`, value: repoLocalPlansDir },
+          { name: `${planDir} (harness-shared)`, value: planDir }
+        ]
       });
-      if (result.kind === "abort") {
-        return {
-          exitReason: "timeout",
-          iterations: iteration,
-          message: `Aborted after ${iteration} iteration(s) (total timeout exceeded).`
-        };
-      }
-      if (result.kind === "stall") {
-        return {
-          exitReason: "stall",
-          iterations: iteration,
-          message: `Iteration ${iteration} stalled for ${result.stallMs}ms with no idle signal.`
-        };
-      }
-      if (result.kind === "error") {
-        return {
-          exitReason: "error",
-          iterations: iteration,
-          message: `Error in iteration ${iteration}: ${result.message}`
-        };
-      }
-      const lastMessage = await _getLastAssistantMessage(server.client, sessionId);
-      if (detectSentinel(lastMessage)) {
-        return {
-          exitReason: "sentinel",
-          iterations: iteration,
-          message: `Agent emitted <autopilot-done> at iteration ${iteration}.`
-        };
-      }
-      const madeProgress = await checkProgress(opts.cwd, headBefore);
-      struggle.record(madeProgress);
-      if (struggle.isStruggling()) {
+      browseRoot = which2;
+    } else if (hasRepoLocal) {
+      browseRoot = repoLocalPlansDir;
+    } else {
+      browseRoot = planDir;
+    }
+    let selectedPlan;
+    if (_deps?.browsePlans) {
+      selectedPlan = await _deps.browsePlans(browseRoot);
+    } else {
+      selectedPlan = await browsePlansDir(browseRoot, _deps?.readdirSync);
+    }
+    if (!selectedPlan) {
+      process.stderr.write("\n  No plan selected. Starting new feature scoping.\n\n");
+    } else {
+      const isDir = fs7.statSync(selectedPlan).isDirectory();
+      const planPath = isDir ? selectedPlan : selectedPlan;
+      const { parsePlanState } = await import("./plan-parser-TMHEKT22.js");
+      const planState = parsePlanState(planPath);
+      if (planState.totalItems > 0 && planState.checkedItems === planState.totalItems) {
+        const { select: selectAction } = await import("@inquirer/prompts");
+        const action = await selectAction({
+          message: `All ${planState.totalItems} items in this plan are already checked. What do you want to do?`,
+          choices: [
+            { name: "Uncheck all items and run from scratch", value: "uncheck" },
+            { name: "Run anyway (agent will verify/audit the checked items)", value: "run" },
+            { name: "Cancel and pick a different plan", value: "cancel" }
+          ]
+        });
+        if (action === "cancel") {
+          process.stderr.write("\n  Cancelled. Starting new feature scoping.\n\n");
+        } else {
+          if (action === "uncheck") {
+            const uncheckFiles = isDir ? fs7.readdirSync(planPath).filter((f) => f.endsWith(".md")).map((f) => path7.join(planPath, f)) : [planPath];
+            for (const file of uncheckFiles) {
+              const content = fs7.readFileSync(file, "utf-8");
+              const unchecked = content.replace(/- \[x\]/g, "- [ ]");
+              fs7.writeFileSync(file, unchecked);
+            }
+            process.stderr.write(`
+  \u2713 Unchecked all items in ${uncheckFiles.length} file(s).
+
+`);
+          }
+          const banner = _deps?.onBanner ?? ((msg) => process.stdout.write(`
+${msg}
+`));
+          banner(`\u2192 Running loop against plan: ${planPath}`);
+          const { runLoopSession: runLoopSession2 } = await import("./loop-session-J35NILUZ.js");
+          const _runLoop = _deps?.runLoop ?? runLoopSession2;
+          const loopResult = await _runLoop({ planPath, cwd });
+          return {
+            scopePath: "",
+            planPath,
+            loopResult
+          };
+        }
+      } else {
+        const unchecked = planState.totalItems - planState.checkedItems;
+        process.stderr.write(
+          `
+  Plan: ${planState.totalItems} items, ${unchecked} remaining.
+
+`
+        );
+        const banner = _deps?.onBanner ?? ((msg) => process.stdout.write(`
+${msg}
+`));
+        banner(`\u2192 Running loop against plan: ${planPath}`);
+        const { runLoopSession: runLoopSession2 } = await import("./loop-session-J35NILUZ.js");
+        const _runLoop = _deps?.runLoop ?? runLoopSession2;
+        const loopResult = await _runLoop({ planPath, cwd });
         return {
-          exitReason: "struggle",
-          iterations: iteration,
-          message: `Agent made no filesystem progress for ${struggleThreshold} consecutive iteration(s). Stopping at iteration ${iteration}.`
+          scopePath: "",
+          planPath,
+          loopResult
         };
       }
     }
-    return {
-      exitReason: "max-iterations",
-      iterations: maxIterations,
-      message: `Reached maximum iterations (${maxIterations}). Stopping.`
-    };
-  } finally {
-    clearTimeout(timeoutHandle);
-    await server.shutdown();
   }
+  let goal;
+  let ticketRef;
+  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 = path7.join(planDir, slug);
+  const seedPath = path7.join(seedDir, "scope-seed.md");
+  const _mkdirSync = _deps?.mkdirSync ?? ((p, o) => fs7.mkdirSync(p, o));
+  const _writeFileSync = _deps?.writeFileSync ?? fs7.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-S77SOK7X.js");
+  const { runPlanSession } = await import("./plan-session-7VS32P52.js");
+  const { runLoopSession } = await import("./loop-session-J35NILUZ.js");
+  return orchestrateAutopilot(
+    { slug, planDir, cwd, initialGoal: goal },
+    {
+      runScoper: _deps?.runScoper ?? runScoperSession,
+      runPlan: _deps?.runPlan ?? runPlanSession,
+      runLoop: _deps?.runLoop ?? runLoopSession,
+      onBanner: _deps?.onBanner
+    }
+  );
 }
 
-// src/autopilot/cli.ts
-var autopilotCmd = command({
+// src/autopilot/autopilot-cmd.ts
+var autopilotInteractiveCmd = command2({
   name: "autopilot",
-  description: "Run the Ralph loop: send a prompt to PRIME repeatedly until it emits <autopilot-done> or a budget is exhausted.",
+  description: "Interactive three-phase autopilot: scope with @scoper, plan with @plan, then execute with the Ralph loop. Produces a structured plan before running.",
   args: {
-    prompt: positional({
-      type: stringType,
-      displayName: "prompt",
-      description: "The prompt to send to PRIME each iteration (e.g. a Linear issue ref or free-form task)."
-    }),
-    maxIterations: option({
-      long: "max-iterations",
-      type: optional(numberType),
-      description: `Maximum number of loop iterations (default: ${MAX_ITERATIONS}).`
-    }),
-    timeout: option({
-      long: "timeout",
-      type: optional(numberType),
-      description: `Total wall-clock timeout in milliseconds (default: ${TIMEOUT_MS} = 4 hours).`
+    slug: option2({
+      long: "slug",
+      type: optional2(stringType2),
+      description: "Plan slug (kebab-case, \u22645 words). If omitted, you will be prompted during the scoping session."
     })
   },
-  handler: async ({ prompt, maxIterations, timeout }) => {
-    const cwd = process.cwd();
-    process.stdout.write("\n\x1B[1mAutopilot \u2014 Ralph loop\x1B[0m\n");
-    process.stdout.write(`Prompt: ${prompt.slice(0, 80)}${prompt.length > 80 ? "..." : ""}
-`);
-    process.stdout.write(`Max iterations: ${maxIterations ?? MAX_ITERATIONS}
-`);
-    process.stdout.write(`Timeout: ${((timeout ?? TIMEOUT_MS) / 36e5).toFixed(1)}h
-
-`);
-    const result = await runRalphLoop({
-      prompt,
-      cwd,
-      maxIterations: maxIterations ?? void 0,
-      timeoutMs: timeout ?? void 0
-    });
-    const icon = result.exitReason === "sentinel" ? "\x1B[32m\u2713\x1B[0m" : result.exitReason === "kill-switch" ? "\x1B[33m\u2298\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
-    process.stdout.write(`
-${icon} ${result.message}
-`);
-    process.stdout.write(`  Iterations: ${result.iterations}
-
-`);
-    if (result.exitReason !== "sentinel" && result.exitReason !== "kill-switch") {
-      process.exit(1);
-    }
-    process.exit(0);
+  handler: async ({ slug: _slug }) => {
+    const result = await runInteractiveAutopilot(process.cwd());
+    process.stdout.write(
+      `
+\x1B[1m\u2713 Autopilot complete\x1B[0m
+  Scope:  ${result.scopePath}
+  Plan:   ${result.planPath}
+  Loop:   ${result.loopResult.exitReason} after ${result.loopResult.iterations} iteration(s)
+`
+    );
   }
 });
 
@@ -1760,7 +1754,7 @@ import * as fs8 from "fs";
 import * as path8 from "path";
 import * as os6 from "os";
 import { spawn } from "child_process";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var PACKAGE_NAME = "@glrs-dev/harness-plugin-opencode";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var c2 = {
@@ -1805,7 +1799,7 @@ function writeState(state) {
   }
 }
 function readInstalledVersion() {
-  const here = path8.dirname(fileURLToPath3(import.meta.url));
+  const here = path8.dirname(fileURLToPath2(import.meta.url));
   const candidates = [
     path8.join(here, "..", "package.json"),
     path8.join(here, "..", "..", "package.json"),
@@ -1939,15 +1933,15 @@ Upgrade Node or run via a compatible Bun runtime. See the "engines" field in pac
   }
 }
 var VERSION = "0.1.0";
-var installCmd = command2({
+var installCmd = command3({
   name: "install",
   description: 'Add "@glrs-dev/harness-plugin-opencode" to your opencode.json plugin array.',
   args: {
-    dryRun: flag({
+    dryRun: flag2({
       long: "dry-run",
       description: "Preview changes without writing."
     }),
-    pin: flag({
+    pin: flag2({
       long: "pin",
       description: "Pin to the current exact version (e.g. @0.1.0)."
     })
@@ -1956,11 +1950,11 @@ var installCmd = command2({
     await install({ dryRun, pin });
   }
 });
-var uninstallCmd = command2({
+var uninstallCmd = command3({
   name: "uninstall",
   description: 'Remove "@glrs-dev/harness-plugin-opencode" from your opencode.json plugin array.',
   args: {
-    dryRun: flag({
+    dryRun: flag2({
       long: "dry-run",
       description: "Preview changes without writing."
     })
@@ -1969,7 +1963,7 @@ var uninstallCmd = command2({
     uninstall({ dryRun });
   }
 });
-var doctorCmd = command2({
+var doctorCmd = command3({
   name: "doctor",
   description: "Check installation health (OpenCode CLI, plugin registration, MCP backends).",
   args: {},
@@ -1977,66 +1971,15 @@ var doctorCmd = command2({
     doctor();
   }
 });
-var planCheckCmd = command2({
-  name: "plan-check",
-  description: "Parse a plan file's plan-state fence (legacy markdown plans).",
-  args: {
-    run: option2({
-      long: "run",
-      type: optional2(string),
-      description: "Print verify commands for pending items, one per line."
-    }),
-    check: option2({
-      long: "check",
-      type: optional2(string),
-      description: "Structural validation; exits 1 if any item is invalid."
-    }),
-    rest: restPositionals({
-      type: string,
-      displayName: "plan-path",
-      description: "Path to a plan markdown file. Required unless --run / --check is given."
-    })
-  },
-  handler: ({ run: run2, check, rest }) => {
-    const legacy = [];
-    if (run2 !== void 0) {
-      legacy.push("--run", run2);
-    } else if (check !== void 0) {
-      legacy.push("--check", check);
-    } else {
-      legacy.push(...rest);
-    }
-    planCheck(legacy);
-  }
-});
-var planDirCmd = command2({
-  name: "plan-dir",
-  description: "Print the repo-shared plan directory for the current worktree (resolves + creates + migrates legacy).",
-  args: {},
-  handler: async () => {
-    try {
-      const cwd = process.cwd();
-      const planDir = await getPlanDir(cwd);
-      await migratePlans(cwd, planDir);
-      process.stdout.write(planDir + "\n");
-      process.exit(0);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`plan-dir: ${msg}
-`);
-      process.exit(1);
-    }
-  }
-});
-var installPluginCmd = command2({
+var installPluginCmd = command3({
   name: "install-plugin",
   description: 'Add "@glrs-dev/harness-plugin-opencode" to your opencode.json plugin array.',
   args: {
-    dryRun: flag({
+    dryRun: flag2({
       long: "dry-run",
       description: "Preview changes without writing."
     }),
-    pin: flag({
+    pin: flag2({
       long: "pin",
       description: "Pin to the current exact version (e.g. @0.1.0)."
     })
@@ -2054,9 +1997,11 @@ var cli = subcommands({
     install: installCmd,
     uninstall: uninstallCmd,
     doctor: doctorCmd,
-    "plan-check": planCheckCmd,
-    "plan-dir": planDirCmd,
-    autopilot: autopilotCmd
+    // `loop` is the raw-prompt Ralph loop runner.
+    // `autopilot` is the interactive three-phase orchestrator (scope → plan → loop).
+    // PR 3 diverged them: they are now separate subcommands.
+    loop: loopCmd,
+    autopilot: autopilotInteractiveCmd
   }
 });
 var printUpdate = startUpdateCheck();