@glrs-dev/cli 2.1.0 → 2.3.0

package/dist/vendor/harness-opencode/dist/cli.js

@@ -1,2082 +1,1763 @@
 #!/usr/bin/env bun
 import {
+  getOpenCodeCachePackageDir,
+  inspectCachePin,
+  readOurPackageVersion,
+  refreshPluginCache,
   validateModelOverride
-} from "./chunk-DZG4D3OH.js";
+} from "./chunk-PDMXYZM4.js";
 import {
-  install
-} from "./chunk-6CZPRUMJ.js";
-import "./chunk-VJUETC6A.js";
+  MAX_ITERATIONS,
+  TIMEOUT_MS,
+  runRalphLoop
+} from "./chunk-NIFAVPNN.js";
+import "./chunk-MJSMBY2Y.js";
 import {
-  getCurrentScopePath,
-  getPilotConfigPath,
-  getPilotDir,
-  getPlanArtifactPath,
-  getScopeArtifactPath,
-  getStateDbPath
-} from "./chunk-OYRKOEXK.js";
+  createSession,
+  getLastAssistantMessage,
+  sendAndWait
+} from "./chunk-GCWHRUOK.js";
 
 // src/cli.ts
 import {
   binary,
-  command as command6,
+  command as command3,
   flag as flag2,
-  option as option3,
-  optional as optional3,
-  positional,
-  restPositionals as restPositionals2,
-  string as string2,
-  subcommands as subcommands2,
+  positional as positional2,
+  subcommands,
   run
 } from "cmd-ts";
 
-// src/cli/uninstall.ts
+// src/cli/install.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os2 from "os";
+import { fileURLToPath } from "url";
+
+// src/cli/merge-config.ts
 import * as fs from "fs";
 import * as path from "path";
-import * as os from "os";
-var PLUGIN_NAME = "@glrs-dev/harness-plugin-opencode";
-function getOpencodeConfigPath() {
-  const configHome = process.env["XDG_CONFIG_HOME"] ?? path.join(os.homedir(), ".config");
-  return path.join(configHome, "opencode", "opencode.json");
-}
-function uninstall(opts = {}) {
-  const { dryRun = false } = opts;
-  const configPath = getOpencodeConfigPath();
-  const c2 = {
-    reset: "\x1B[0m",
-    green: "\x1B[32m",
-    yellow: "\x1B[33m",
-    blue: "\x1B[34m"
-  };
-  const ok = (msg) => console.log(`${c2.green}\u2713${c2.reset} ${msg}`);
-  const info = (msg) => console.log(`${c2.blue}\u2022${c2.reset} ${msg}`);
-  const warn = (msg) => console.log(`${c2.yellow}!${c2.reset} ${msg}`);
-  console.log(`
-${c2.blue}Uninstalling ${PLUGIN_NAME}${c2.reset}
-`);
-  if (!fs.existsSync(configPath)) {
-    warn(`No opencode.json found at ${configPath} \u2014 nothing to do`);
-    return;
+var UNION_ALLOWLIST = /* @__PURE__ */ new Set(["plugin"]);
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && Object.prototype.toString.call(v) === "[object Object]";
+}
+function deepClone(v) {
+  if (v === null || typeof v !== "object") return v;
+  if (Array.isArray(v)) return v.map(deepClone);
+  const out = {};
+  for (const k of Object.keys(v)) {
+    out[k] = deepClone(v[k]);
+  }
+  return out;
+}
+function fmtPath(parts) {
+  return parts.map((p) => /^[A-Za-z_$][\w$]*$/.test(p) ? p : `["${p.replace(/"/g, '\\"')}"]`).reduce((acc, part) => {
+    if (acc === "") return part;
+    if (part.startsWith("[")) return acc + part;
+    return acc + "." + part;
+  }, "");
+}
+function pluginName(entry) {
+  if (typeof entry === "string") {
+    const atIdx = entry.indexOf("@", 1);
+    return atIdx > 0 ? entry.slice(0, atIdx) : entry;
+  }
+  if (Array.isArray(entry) && typeof entry[0] === "string") {
+    const name = entry[0];
+    const atIdx = name.indexOf("@", 1);
+    return atIdx > 0 ? name.slice(0, atIdx) : name;
+  }
+  return null;
+}
+function mergeWalk(src, dst, pathParts, additions, warnings) {
+  for (const key of Object.keys(src)) {
+    const sv = src[key];
+    const newPath = pathParts.concat([key]);
+    const pathStr = fmtPath(newPath);
+    if (!Object.prototype.hasOwnProperty.call(dst, key)) {
+      dst[key] = deepClone(sv);
+      additions.push(`added: ${pathStr}`);
+      continue;
+    }
+    const dv = dst[key];
+    if (isPlainObject(sv) && isPlainObject(dv)) {
+      mergeWalk(sv, dv, newPath, additions, warnings);
+      continue;
+    }
+    if (isPlainObject(sv) && !isPlainObject(dv)) {
+      warnings.push(
+        `WARN: scalar-vs-object: user has non-object at ${pathStr} where we ship an object; not migrating. To adopt: ${JSON.stringify(sv)}`
+      );
+      continue;
+    }
+    if (Array.isArray(sv)) {
+      if (!Array.isArray(dv)) {
+        warnings.push(
+          `WARN: scalar-vs-array: user has non-array at ${pathStr} where we ship an array; not migrating. To adopt: ${JSON.stringify(sv)}`
+        );
+        continue;
+      }
+      const joined = newPath.join(".");
+      if (UNION_ALLOWLIST.has(joined)) {
+        for (const item of sv) {
+          const srcName = pluginName(item);
+          if (srcName) {
+            const dstIdx = dv.findIndex(
+              (x) => pluginName(x) === srcName
+            );
+            if (dstIdx >= 0) {
+              const srcIsTuple = Array.isArray(item) && item.length >= 2;
+              const dstIsTuple = Array.isArray(dv[dstIdx]) && dv[dstIdx].length >= 2;
+              if (srcIsTuple && !dstIsTuple) {
+                dv[dstIdx] = deepClone(item);
+                additions.push(`upgraded: ${pathStr}[${JSON.stringify(srcName)}] to tuple form`);
+              }
+            } else {
+              dv.push(deepClone(item));
+              additions.push(`appended: ${pathStr}[${JSON.stringify(item)}]`);
+            }
+          } else {
+            const needle = JSON.stringify(item);
+            const alreadyPresent = dv.some(
+              (x) => JSON.stringify(x) === needle
+            );
+            if (!alreadyPresent) {
+              dv.push(deepClone(item));
+              additions.push(`appended: ${pathStr}[${JSON.stringify(item)}]`);
+            }
+          }
+        }
+      }
+      continue;
+    }
   }
-  let raw;
+}
+function mergeConfig(srcJson, dstPath, dryRun = false) {
+  let dstText;
   try {
-    raw = fs.readFileSync(configPath, "utf8");
+    dstText = fs.readFileSync(dstPath, "utf8");
   } catch (e) {
-    console.error(`\x1B[31m\u2717\x1B[0m Failed to read ${configPath}: ${e.message}`);
-    process.exit(1);
+    throw new Error(`Failed to read dst ${dstPath}: ${e.message}`);
   }
-  let config;
+  let dst;
   try {
-    config = JSON.parse(raw);
+    dst = JSON.parse(dstText);
   } catch (e) {
-    console.error(`\x1B[31m\u2717\x1B[0m Invalid JSON in ${configPath}: ${e.message}`);
-    process.exit(1);
+    throw new Error(
+      `User config at ${dstPath} has invalid JSON: ${e.message}. Not touching the file.`
+    );
   }
-  const plugins = Array.isArray(config.plugin) ? config.plugin : [];
-  const filtered = plugins.filter((p) => {
-    const name = typeof p === "string" ? p : Array.isArray(p) ? p[0] : null;
-    return name !== PLUGIN_NAME && !String(name ?? "").startsWith(`${PLUGIN_NAME}@`);
-  });
-  if (filtered.length === plugins.length) {
-    warn(`"${PLUGIN_NAME}" not found in plugin array \u2014 nothing to remove`);
-    return;
+  if (!isPlainObject(dst)) {
+    throw new Error(
+      `User config at ${dstPath} is not a JSON object at the top level.`
+    );
+  }
+  const additions = [];
+  const warnings = [];
+  mergeWalk(srcJson, dst, [], additions, warnings);
+  if (additions.length === 0) {
+    return { changed: false, warnings };
   }
   if (dryRun) {
-    info(`[dry-run] Would remove "${PLUGIN_NAME}" from plugin array in ${configPath}`);
-    return;
+    return { changed: true, bakPath: "(dry-run)", additions, warnings };
   }
-  const bakPath = `${configPath}.bak.${Date.now()}-${process.pid}`;
+  const suffix = `${Date.now()}-${process.pid}`;
+  const bakPath = `${dstPath}.bak.${suffix}`;
+  const tmpPath = `${dstPath}.merge.tmp.${suffix}`;
   try {
-    fs.copyFileSync(configPath, bakPath);
+    fs.copyFileSync(dstPath, bakPath);
   } catch (e) {
-    console.error(`\x1B[31m\u2717\x1B[0m Failed to write backup: ${e.message}`);
-    process.exit(1);
+    throw new Error(`Failed to write backup ${bakPath}: ${e.message}`);
+  }
+  const serialized = JSON.stringify(dst, null, 2) + "\n";
+  try {
+    fs.writeFileSync(tmpPath, serialized);
+  } catch (e) {
+    try {
+      fs.unlinkSync(bakPath);
+    } catch {
+    }
+    throw new Error(`Failed to write tempfile ${tmpPath}: ${e.message}`);
   }
-  config.plugin = filtered;
-  const tmpPath = `${configPath}.uninstall.tmp.${Date.now()}-${process.pid}`;
   try {
-    fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2) + "\n");
-    fs.renameSync(tmpPath, configPath);
+    fs.renameSync(tmpPath, dstPath);
   } catch (e) {
     try {
       fs.unlinkSync(tmpPath);
     } catch {
     }
-    console.error(`\x1B[31m\u2717\x1B[0m Failed to write config: ${e.message}`);
-    process.exit(1);
+    try {
+      fs.unlinkSync(bakPath);
+    } catch {
+    }
+    throw new Error(`Failed to rename ${tmpPath} \u2192 ${dstPath}: ${e.message}`);
   }
-  ok(`Removed "${PLUGIN_NAME}" from ${configPath}`);
-  info(`Backup: ${bakPath}`);
-  console.log(`
-To fully remove the package: bun remove @glrs-dev/harness-plugin-opencode
-`);
+  return { changed: true, bakPath, additions, warnings };
+}
+function seedConfig(srcJson, dstPath) {
+  fs.mkdirSync(path.dirname(dstPath), { recursive: true });
+  fs.writeFileSync(dstPath, JSON.stringify(srcJson, null, 2) + "\n");
 }
 
-// src/cli/doctor.ts
+// src/cli/plugin-check.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
-import * as os2 from "os";
-import { execSync } from "child_process";
-var PLUGIN_NAME2 = "@glrs-dev/harness-plugin-opencode";
-function getOpencodeConfigPath2() {
-  const configHome = process.env["XDG_CONFIG_HOME"] ?? path2.join(os2.homedir(), ".config");
-  return path2.join(configHome, "opencode", "opencode.json");
+import * as os from "os";
+import { select, checkbox, confirm } from "@inquirer/prompts";
+async function promptChoice(question, choices, defaultIndex = 0) {
+  if (!process.stdin.isTTY) return defaultIndex;
+  const answer = await select({
+    message: question,
+    choices: choices.map((label, i) => ({
+      name: label,
+      value: i
+    })),
+    default: defaultIndex
+  });
+  return answer;
 }
-function cmd(command7) {
-  try {
-    return execSync(command7, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-  } catch {
-    return null;
-  }
+async function promptMulti(question, choices) {
+  if (!process.stdin.isTTY) {
+    const defaults = /* @__PURE__ */ new Set();
+    choices.forEach((c3, i) => {
+      if (c3.defaultOn) defaults.add(i);
+    });
+    return defaults;
+  }
+  const answers = await checkbox({
+    message: question,
+    choices: choices.map((c3, i) => ({
+      name: c3.label,
+      value: i,
+      checked: c3.defaultOn
+    }))
+  });
+  return new Set(answers);
 }
-function which(bin) {
-  return cmd(`which ${bin}`) !== null;
+
+// src/cli/models-dev.ts
+var MODELS_DEV_URL = "https://models.dev/api.json";
+var FETCH_TIMEOUT_MS = 5e3;
+function combinedCost(m) {
+  const input = m.cost?.input ?? 0;
+  const output = m.cost?.output ?? 0;
+  return input + output;
+}
+function suggestTiersFromModelsDev(provider) {
+  const models = Object.values(provider.models).sort(
+    (a, b) => combinedCost(b) - combinedCost(a)
+  );
+  if (models.length === 0) {
+    throw new Error(`Provider "${provider.id}" has no models`);
+  }
+  const deep = models[0];
+  const fast = models[models.length - 1];
+  let mid;
+  if (models.length <= 2) {
+    mid = models.length === 1 ? deep : fast;
+  } else {
+    const midCost = (combinedCost(deep) + combinedCost(fast)) / 2;
+    const candidates = models.filter(
+      (m) => m.id !== deep.id && m.id !== fast.id
+    );
+    mid = candidates.reduce(
+      (best, m) => Math.abs(combinedCost(m) - midCost) < Math.abs(combinedCost(best) - midCost) ? m : best
+    );
+  }
+  const ref = (m) => `${provider.id}/${m.id}`;
+  return {
+    deep: ref(deep),
+    mid: ref(mid),
+    fast: ref(fast)
+  };
 }
-function doctor() {
-  const c2 = {
-    reset: "\x1B[0m",
-    green: "\x1B[32m",
-    yellow: "\x1B[33m",
-    red: "\x1B[31m",
-    bold: "\x1B[1m"
+function pickBedrockTierIds(provider) {
+  const models = Object.values(provider.models);
+  const mostRecent = (candidates) => {
+    if (candidates.length === 0) return null;
+    return [...candidates].sort((a, b) => {
+      const aDate = a.last_updated ?? "";
+      const bDate = b.last_updated ?? "";
+      if (aDate !== bDate) return bDate.localeCompare(aDate);
+      return b.id.localeCompare(a.id);
+    })[0];
   };
-  const ok = (msg) => console.log(`${c2.green}\u2713${c2.reset} ${msg}`);
-  const warn = (msg) => console.log(`${c2.yellow}!${c2.reset} ${msg}`);
-  const fail = (msg) => console.log(`${c2.red}\u2717${c2.reset} ${msg}`);
-  console.log(`
-${c2.bold}Doctor \u2014 ${PLUGIN_NAME2}${c2.reset}
-`);
-  const ocVersion = cmd("opencode --version 2>/dev/null | head -1");
-  if (ocVersion) {
-    ok(`opencode ${ocVersion}`);
-  } else {
-    fail("opencode CLI not found \u2014 install from https://opencode.ai");
+  const pickFamily = (familyKeyword) => {
+    const globalCandidates = models.filter(
+      (m) => m.id.startsWith(`global.anthropic.claude-${familyKeyword}-`)
+    );
+    const globalPick = mostRecent(globalCandidates);
+    if (globalPick) return globalPick;
+    const nonPrefixedCandidates = models.filter(
+      (m) => m.id.startsWith(`anthropic.claude-${familyKeyword}-`)
+    );
+    return mostRecent(nonPrefixedCandidates);
+  };
+  const opus = pickFamily("opus");
+  const sonnet = pickFamily("sonnet");
+  const haiku = pickFamily("haiku");
+  if (!opus || !sonnet || !haiku) {
+    return suggestTiersFromModelsDev(provider);
   }
-  const configPath = getOpencodeConfigPath2();
-  if (fs2.existsSync(configPath)) {
-    try {
-      const config = JSON.parse(fs2.readFileSync(configPath, "utf8"));
-      const plugins = Array.isArray(config.plugin) ? config.plugin : [];
-      let pluginOptions = null;
-      const hasPlugin = plugins.some((p) => {
-        if (typeof p === "string") {
-          return p === PLUGIN_NAME2 || p.startsWith(`${PLUGIN_NAME2}@`);
-        }
-        if (Array.isArray(p)) {
-          const [name, opts] = p;
-          const match = name === PLUGIN_NAME2 || String(name ?? "").startsWith(`${PLUGIN_NAME2}@`);
-          if (match && opts && typeof opts === "object") {
-            pluginOptions = opts;
-          }
-          return match;
-        }
-        return false;
-      });
-      if (hasPlugin) {
-        ok(`"${PLUGIN_NAME2}" present in opencode.json plugin array`);
-      } else {
-        warn(`"${PLUGIN_NAME2}" NOT in opencode.json plugin array \u2014 run: bunx ${PLUGIN_NAME2} install`);
-      }
-      const modelSources = [];
-      if (pluginOptions && typeof pluginOptions.models === "object") {
-        modelSources.push({
-          label: "plugin options.models",
-          block: pluginOptions.models
-        });
-      }
-      const legacyHarness = config.harness;
-      if (legacyHarness && typeof legacyHarness.models === "object") {
-        modelSources.push({
-          label: "harness.models (legacy)",
-          block: legacyHarness.models
-        });
-      }
-      if (modelSources.length > 0) {
-        const invalid = [];
-        for (const { label, block } of modelSources) {
-          if (!block || typeof block !== "object") continue;
-          for (const [key, rawValue] of Object.entries(block)) {
-            const candidate = Array.isArray(rawValue) ? rawValue[0] : rawValue;
-            if (typeof candidate !== "string") continue;
-            const result = validateModelOverride(candidate);
-            if (!result.valid) {
-              invalid.push({
-                keyPath: `${label}.${key}`,
-                value: candidate,
-                suggestion: result.suggestion,
-                reason: result.reason
-              });
-            }
-          }
-        }
-        if (invalid.length === 0) {
-          ok("model overrides look valid");
-        } else {
-          for (const entry of invalid) {
-            fail(`invalid model override at ${entry.keyPath}: "${entry.value}"`);
-            if (entry.reason) {
-              console.log(`    ${c2.yellow}reason:${c2.reset} ${entry.reason}`);
-            }
-            if (entry.suggestion) {
-              console.log(
-                `    ${c2.yellow}fix:${c2.reset}    remove this key, or replace with \`${entry.suggestion}\``
-              );
-            } else {
-              console.log(
-                `    ${c2.yellow}fix:${c2.reset}    remove this key, or run \`bunx ${PLUGIN_NAME2} install\` to pick a current preset`
-              );
-            }
-          }
-        }
-      }
-    } catch {
-      fail(`opencode.json at ${configPath} has invalid JSON`);
+  const ref = (m) => `${provider.id}/${m.id}`;
+  return {
+    deep: ref(opus),
+    mid: ref(sonnet),
+    fast: ref(haiku)
+  };
+}
+async function fetchModelsDevProviders() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(MODELS_DEV_URL, { signal: controller.signal });
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+    const providers = [];
+    for (const [key, rawValue] of Object.entries(
+      data
+    )) {
+      if (!rawValue || typeof rawValue !== "object") continue;
+      const value = rawValue;
+      if (typeof value.id !== "string" || value.id !== key) continue;
+      if (typeof value.name !== "string") continue;
+      if (!value.models || typeof value.models !== "object") continue;
+      providers.push(value);
     }
-  } else {
-    warn(`No opencode.json at ${configPath} \u2014 run: bunx ${PLUGIN_NAME2} install`);
-  }
-  if (which("uvx")) {
-    ok("uvx (serena + git MCPs)");
-  } else {
-    warn("uvx not found \u2014 serena and git MCPs won't work. Install: brew install uv");
-  }
-  if (which("node") && which("npx")) {
-    ok(`node ${cmd("node --version") ?? ""} + npx (memory MCP)`);
-  } else {
-    warn("node/npx not found \u2014 memory MCP won't work");
-  }
-  const planCheckResult = cmd(`bunx ${PLUGIN_NAME2} plan-check --help 2>/dev/null`);
-  if (planCheckResult !== null) {
-    ok("plan-check CLI invokable");
-  } else {
-    warn("plan-check CLI not invokable \u2014 try: bun install");
-  }
-  if (which("bun")) {
-    ok(`bun ${cmd("bun --version") ?? ""}`);
-  } else if (which("npm")) {
-    ok(`npm ${cmd("npm --version") ?? ""} (install bun for faster installs)`);
-  } else {
-    fail("Neither bun nor npm found \u2014 cannot install plugins");
+    if (providers.length === 0) return null;
+    return providers;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
   }
-  console.log();
-  console.log(`${c2.bold}Pilot subsystem${c2.reset}`);
-  if (which("git")) {
-    const gitVer = cmd("git --version") ?? "";
-    ok(`git ${gitVer}`);
-  } else {
-    fail("git not found \u2014 pilot subsystem requires git");
+}
+
+// src/cli/install.ts
+var PLUGIN_NAME = "@glrs-dev/harness-plugin-opencode";
+var c = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m"
+};
+var ok = (msg) => console.log(`${c.green}\u2713${c.reset} ${msg}`);
+var info = (msg) => console.log(`${c.blue}\u2022${c.reset} ${msg}`);
+var warn = (msg) => console.log(`${c.yellow}!${c.reset} ${msg}`);
+var MODEL_PRESETS = [
+  {
+    label: "Anthropic API (direct)",
+    providerId: "anthropic",
+    deep: "anthropic/claude-opus-4-7",
+    mid: "anthropic/claude-sonnet-4-6",
+    fast: "anthropic/claude-haiku-4-5-20251001"
+  },
+  {
+    label: "AWS Bedrock",
+    providerId: "amazon-bedrock",
+    deep: "amazon-bedrock/global.anthropic.claude-opus-4-7",
+    mid: "amazon-bedrock/global.anthropic.claude-sonnet-4-6",
+    fast: "amazon-bedrock/global.anthropic.claude-haiku-4-5-20251001-v1:0"
+  },
+  {
+    label: "Google Vertex AI (Claude)",
+    providerId: "google-vertex-anthropic",
+    deep: "google-vertex-anthropic/claude-opus-4-7@default",
+    mid: "google-vertex-anthropic/claude-sonnet-4-6@default",
+    fast: "google-vertex-anthropic/claude-haiku-4-5@20251001"
   }
-  if (which("bash")) {
-    ok("bash (verify-runner shell)");
-  } else {
-    fail("bash not found \u2014 pilot's verify commands run via `bash -c`");
+];
+var MCP_TOGGLES = [
+  { name: "playwright", label: "Playwright \u2014 browser automation + visual UI verification (requires Chromium)", defaultOn: false },
+  { name: "linear", label: "Linear \u2014 issue tracker integration", defaultOn: false }
+];
+var PLUGIN_TOGGLES = [
+  {
+    name: "opencode-snip",
+    label: "Token reduction \u2014 opencode-snip (requires Go snip binary)",
+    defaultOn: false
   }
-  const agentList = cmd("opencode agent list 2>/dev/null");
-  if (agentList !== null) {
-    for (const agentName of ["pilot-scoper", "pilot-planner", "pilot-builder", "pilot-assessor"]) {
-      if (agentList.includes(agentName)) {
-        ok(`${agentName} agent registered`);
-      } else {
-        warn(
-          `${agentName} agent NOT in \`opencode agent list\` \u2014 plugin may not be loaded; run: bunx ` + PLUGIN_NAME2 + " install"
-        );
-      }
+];
+function extractPluginOptions(config) {
+  if (!config) return null;
+  const plugins = config.plugin;
+  if (!Array.isArray(plugins)) return null;
+  for (const entry of plugins) {
+    if (Array.isArray(entry) && entry.length >= 2 && (entry[0] === PLUGIN_NAME || String(entry[0]).startsWith(`${PLUGIN_NAME}@`))) {
+      return entry[1];
     }
-  } else {
-    warn(
-      "could not run `opencode agent list` \u2014 skipping pilot agent registration check"
-    );
   }
-  console.log();
+  return null;
 }
-
-// src/bin/plan-check.ts
-import { execFileSync } from "child_process";
-import { fileURLToPath } from "url";
-import { dirname, join as join3 } from "path";
-function planCheck(args) {
-  const here = dirname(fileURLToPath(import.meta.url));
+function readPackageVersion() {
+  const here = path3.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    join3(here, "plan-check.sh"),
-    // dev: src/bin/plan-check.sh
-    join3(here, "bin", "plan-check.sh")
-    // dist: dist/ → dist/bin/plan-check.sh
+    path3.join(here, "..", "package.json"),
+    path3.join(here, "..", "..", "package.json")
   ];
-  let scriptPath;
-  for (const p of candidates) {
+  for (const candidate of candidates) {
     try {
-      execFileSync("test", ["-f", p]);
-      scriptPath = p;
-      break;
+      const raw = fs3.readFileSync(candidate, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.name === PLUGIN_NAME && typeof parsed.version === "string") {
+        return parsed.version;
+      }
     } catch {
     }
   }
-  if (!scriptPath) {
-    console.error("plan-check: could not find plan-check.sh");
-    process.exit(2);
+  throw new Error(
+    `Could not locate ${PLUGIN_NAME}'s package.json to read version`
+  );
+}
+function getOpencodeConfigPath() {
+  const configHome = process.env["XDG_CONFIG_HOME"] ?? path3.join(os2.homedir(), ".config");
+  return path3.join(configHome, "opencode", "opencode.json");
+}
+async function refreshPluginCacheIfStale() {
+  try {
+    const cacheDir = getOpenCodeCachePackageDir();
+    const pin = await inspectCachePin(cacheDir);
+    if (pin.kind !== "exact") return;
+    const ourVersion = readOurPackageVersion(import.meta.url);
+    if (pin.version === ourVersion) return;
+    const result = await refreshPluginCache(pin.version, ourVersion);
+    if (result.outcome === "refreshed") {
+      ok(`Plugin cache updated: ${result.fromVersion} \u2192 ${result.toVersion}`);
+    }
+  } catch {
   }
+}
+function readExistingConfig(configPath) {
+  if (!fs3.existsSync(configPath)) return null;
   try {
-    execFileSync("bash", [scriptPath, ...args], {
-      stdio: "inherit",
-      encoding: "utf8"
-    });
-  } catch (e) {
-    process.exit(e.status ?? 1);
+    return JSON.parse(fs3.readFileSync(configPath, "utf8"));
+  } catch {
+    return null;
   }
 }
-
-// src/plan-paths.ts
-import { execFile } from "child_process";
-import * as fs3 from "fs/promises";
-import * as os3 from "os";
-import * as path3 from "path";
-function execFileP(file, args, opts = {}) {
-  const { cwd, timeoutMs = 5e3 } = opts;
-  return new Promise((resolve2, 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;
-        }
-        resolve2(stdout ?? "");
-      }
-    );
-  });
-}
-function expandTilde(p) {
-  if (p === "~") return os3.homedir();
-  if (p.startsWith("~/")) return path3.join(os3.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}`
-    );
+function detectModelProvider(existing) {
+  const opts = extractPluginOptions(existing);
+  const models = opts?.models ?? existing?.harness?.models;
+  if (!models) return null;
+  const deep = Array.isArray(models.deep) ? models.deep[0] : models.deep;
+  if (typeof deep !== "string") return null;
+  for (const preset of MODEL_PRESETS) {
+    if (deep === preset.deep) return preset.label;
+  }
+  return `custom (${deep})`;
+}
+function detectEnabledMcps(existing) {
+  const enabled = /* @__PURE__ */ new Set();
+  const mcp = existing?.mcp;
+  if (!mcp || typeof mcp !== "object") return enabled;
+  for (const toggle of MCP_TOGGLES) {
+    if (mcp[toggle.name]?.enabled === true) {
+      enabled.add(toggle.name);
+    }
   }
-  const absCommonDir = path3.isAbsolute(gitCommonDir) ? gitCommonDir : path3.resolve(worktreeDir, gitCommonDir);
-  const repoRoot = path3.dirname(absCommonDir);
-  return path3.basename(repoRoot);
-}
-async function getPlanDir(worktreeDir) {
-  const override = process.env.GLORIOUS_PLAN_DIR;
-  const base = override ? expandTilde(override) : path3.join(os3.homedir(), ".glorious", "opencode");
-  const repoFolder = await getRepoFolder(worktreeDir);
-  const planDir = path3.join(base, repoFolder, "plans");
-  await fs3.mkdir(planDir, { recursive: true });
-  return planDir;
+  return enabled;
 }
-async function migratePlans(worktreeDir, planDir) {
-  const oldDir = path3.join(worktreeDir, ".agent", "plans");
-  const marker = path3.join(oldDir, ".migrated");
-  try {
-    await fs3.stat(oldDir);
-  } catch {
-    return;
-  }
-  try {
-    await fs3.stat(marker);
-    return;
-  } catch {
-  }
-  let entries;
-  try {
-    entries = await fs3.readdir(oldDir);
-  } catch {
-    return;
-  }
-  const planFiles = entries.filter(
-    (name) => name.endsWith(".md") && !name.startsWith(".")
-  );
-  await fs3.mkdir(planDir, { recursive: true });
-  for (const name of planFiles) {
-    const src = path3.join(oldDir, name);
-    const dst = path3.join(planDir, name);
-    let dstExists = false;
-    try {
-      await fs3.stat(dst);
-      dstExists = true;
-    } catch {
-      dstExists = false;
-    }
-    if (!dstExists) {
-      await fs3.rename(src, dst);
-      continue;
-    }
-    const [srcBuf, dstBuf] = await Promise.all([
-      fs3.readFile(src),
-      fs3.readFile(dst)
-    ]);
-    if (srcBuf.equals(dstBuf)) {
-      await fs3.unlink(src);
-      continue;
+function detectEnabledPluginToggles(existing) {
+  const enabled = /* @__PURE__ */ new Set();
+  const plugins = Array.isArray(existing?.plugin) ? existing.plugin : [];
+  const toggleNames = new Set(PLUGIN_TOGGLES.map((t) => t.name));
+  for (const entry of plugins) {
+    const name = typeof entry === "string" ? entry : Array.isArray(entry) ? entry[0] : null;
+    if (typeof name === "string" && toggleNames.has(name)) {
+      enabled.add(name);
     }
-    process.stderr.write(
-      `[harness-opencode] migratePlans: conflict on ${name} \u2014 destination ${dst} exists with different content; leaving source ${src} in place. Resolve manually.
-`
-    );
   }
-  await fs3.writeFile(marker, "");
+  return enabled;
 }
-
-// src/pilot/cli/index.ts
-import { subcommands } from "cmd-ts";
-
-// src/pilot/cli/configure.ts
-import { command } from "cmd-ts";
-import { input, select, confirm, number } from "@inquirer/prompts";
-
-// src/pilot/config.ts
-import * as fs4 from "fs";
-var DEFAULT_MODEL = "anthropic/claude-sonnet-4-6";
-var DEFAULT_CONFIG = {
-  models: {
-    scope: DEFAULT_MODEL,
-    plan: DEFAULT_MODEL,
-    execute: DEFAULT_MODEL,
-    assess: DEFAULT_MODEL
-  },
-  verify: {
-    baseline: [],
-    after_each: []
-  },
-  max_assess_cycles: 3,
-  playwright: {
-    enabled: false,
-    base_url: "http://localhost:3000"
-  }
-};
-function loadPilotConfig(cwd) {
-  const configPath = getPilotConfigPath(cwd);
-  if (!fs4.existsSync(configPath)) {
-    return { ...DEFAULT_CONFIG };
-  }
-  let raw;
+function migrateHarnessKeyToPluginOptions(configPath) {
   try {
-    raw = JSON.parse(fs4.readFileSync(configPath, "utf8"));
+    if (!fs3.existsSync(configPath)) return;
+    const raw = fs3.readFileSync(configPath, "utf8");
+    const config = JSON.parse(raw);
+    if (!config.harness || typeof config.harness !== "object") return;
+    const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+    const pluginIdx = plugins.findIndex((entry) => {
+      const name = typeof entry === "string" ? entry : Array.isArray(entry) ? entry[0] : null;
+      return name === PLUGIN_NAME || String(name ?? "").startsWith(`${PLUGIN_NAME}@`);
+    });
+    if (pluginIdx < 0) return;
+    const current = plugins[pluginIdx];
+    const existingName = typeof current === "string" ? current : Array.isArray(current) ? current[0] : PLUGIN_NAME;
+    const existingOpts = Array.isArray(current) && current.length >= 2 ? current[1] : {};
+    const merged = { ...config.harness, ...existingOpts };
+    plugins[pluginIdx] = [existingName, merged];
+    delete config.harness;
+    const bakPath = `${configPath}.bak.${Date.now()}-${process.pid}`;
+    fs3.copyFileSync(configPath, bakPath);
+    fs3.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    ok("Migrated legacy `harness` config into plugin options");
+    info(`Backup: ${bakPath}`);
   } catch {
-    process.stderr.write(
-      `[pilot] Warning: .glrs/pilot.json has invalid JSON \u2014 using defaults
-`
-    );
-    return { ...DEFAULT_CONFIG };
-  }
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    return { ...DEFAULT_CONFIG };
-  }
-  const obj = raw;
-  if ("baseline" in obj || "after_each" in obj) {
-    process.stderr.write(
-      `[pilot] Warning: .glrs/pilot.json appears to be in the old pilot v1 format.
-  Run \`pilot configure\` to set up the new v2 configuration.
-  Using defaults for now.
-`
-    );
-    return { ...DEFAULT_CONFIG };
   }
-  const models = mergeModels(obj["models"]);
-  const verify = mergeVerify(obj["verify"]);
-  const playwright = mergePlaywright(obj["playwright"]);
-  const max_assess_cycles = typeof obj["max_assess_cycles"] === "number" && obj["max_assess_cycles"] > 0 ? obj["max_assess_cycles"] : DEFAULT_CONFIG.max_assess_cycles;
-  return { models, verify, max_assess_cycles, playwright };
-}
-function mergeModels(raw) {
-  const d = DEFAULT_CONFIG.models;
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { ...d };
-  const obj = raw;
-  return {
-    scope: typeof obj["scope"] === "string" ? obj["scope"] : d.scope,
-    plan: typeof obj["plan"] === "string" ? obj["plan"] : d.plan,
-    execute: typeof obj["execute"] === "string" ? obj["execute"] : d.execute,
-    assess: typeof obj["assess"] === "string" ? obj["assess"] : d.assess
-  };
-}
-function mergeVerify(raw) {
-  const d = DEFAULT_CONFIG.verify;
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { ...d };
-  const obj = raw;
-  return {
-    baseline: Array.isArray(obj["baseline"]) ? obj["baseline"].filter((x) => typeof x === "string") : d.baseline,
-    after_each: Array.isArray(obj["after_each"]) ? obj["after_each"].filter((x) => typeof x === "string") : d.after_each
-  };
 }
-function mergePlaywright(raw) {
-  const d = DEFAULT_CONFIG.playwright;
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { ...d };
-  const obj = raw;
-  return {
-    enabled: typeof obj["enabled"] === "boolean" ? obj["enabled"] : d.enabled,
-    base_url: typeof obj["base_url"] === "string" ? obj["base_url"] : d.base_url
-  };
-}
-function writePilotConfig(cwd, config) {
-  const configPath = getPilotConfigPath(cwd);
-  const dir = configPath.slice(0, configPath.lastIndexOf("/"));
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return a === b;
+  if (typeof a !== "object") return false;
+  const aObj = a;
+  const bObj = b;
+  const aKeys = Object.keys(aObj);
+  const bKeys = Object.keys(bObj);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const key of aKeys) {
+    if (!bKeys.includes(key)) return false;
+    if (!deepEqual(aObj[key], bObj[key])) return false;
   }
-  fs4.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
-}
-
-// src/pilot/cli/configure.ts
-var MODEL_SUGGESTIONS = [
-  // Anthropic
-  "anthropic/claude-opus-4-7",
-  "anthropic/claude-sonnet-4-6",
-  "anthropic/claude-haiku-4-5",
-  // Amazon Bedrock
-  "amazon-bedrock/global.anthropic.claude-opus-4-7",
-  "amazon-bedrock/global.anthropic.claude-sonnet-4-6",
-  "amazon-bedrock/global.anthropic.claude-haiku-4-5",
-  // OpenAI
-  "openai/gpt-4o",
-  "openai/gpt-4o-mini",
-  "openai/o3",
-  "openai/o4-mini",
-  // Google
-  "google/gemini-2.5-pro",
-  "google/gemini-2.5-flash",
-  // DeepSeek
-  "deepseek/deepseek-chat",
-  // Qwen
-  "qwen/qwen3-coder"
-];
-async function promptModel(phase, current) {
-  const choices = MODEL_SUGGESTIONS.includes(current) ? MODEL_SUGGESTIONS.map((m) => ({ name: m, value: m })) : [
-    { name: `${current} (current)`, value: current },
-    ...MODEL_SUGGESTIONS.map((m) => ({ name: m, value: m }))
-  ];
-  return select({
-    message: `Model for ${phase} phase:`,
-    choices,
-    default: current
-  });
+  return true;
 }
-async function promptVerifyCommands(label, current) {
-  const currentStr = current.join(", ");
-  const raw = await input({
-    message: `${label} commands (comma-separated, empty to clear):`,
-    default: currentStr
-  });
-  if (!raw.trim()) return [];
-  return raw.split(",").map((s) => s.trim()).filter(Boolean);
-}
-var configureCmd = command({
-  name: "configure",
-  description: "Interactively configure pilot v2 for this repo (.glrs/pilot.json).",
-  args: {},
-  handler: async () => {
-    const cwd = process.cwd();
-    if (!process.stdin.isTTY) {
-      process.stderr.write(
-        "pilot configure: requires an interactive terminal (TTY).\n  Edit .glrs/pilot.json directly for non-interactive configuration.\n"
-      );
-      process.exit(1);
+function writePluginOption(configPath, subKey, value, opts) {
+  try {
+    if (!fs3.existsSync(configPath)) {
+      return { changed: false };
+    }
+    const raw = fs3.readFileSync(configPath, "utf8");
+    const config = JSON.parse(raw);
+    if (!Array.isArray(config.plugin)) {
+      return { changed: false };
     }
-    const current = loadPilotConfig(cwd);
-    console.log("\n\x1B[1mPilot v2 Configuration\x1B[0m");
-    console.log("Configure per-phase models, verify commands, and behavior.\n");
-    console.log("\x1B[2m\u2500\u2500 Models \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\x1B[0m");
-    const scopeModel = await promptModel("scope", current.models.scope);
-    const planModel = await promptModel("plan", current.models.plan);
-    const executeModel = await promptModel("execute", current.models.execute);
-    const assessModel = await promptModel("assess", current.models.assess);
-    console.log("\n\x1B[2m\u2500\u2500 Verify commands \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\x1B[0m");
-    const baseline = await promptVerifyCommands("Baseline (run before execution)", current.verify.baseline);
-    const after_each = await promptVerifyCommands("After-each (run after each task)", current.verify.after_each);
-    console.log("\n\x1B[2m\u2500\u2500 Assess loop \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\x1B[0m");
-    const max_assess_cycles = await number({
-      message: "Max assess cycles (how many times to re-plan on failure):",
-      default: current.max_assess_cycles,
-      min: 1,
-      max: 10
-    }) ?? current.max_assess_cycles;
-    console.log("\n\x1B[2m\u2500\u2500 Playwright (optional visual testing) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\x1B[0m");
-    const playwrightEnabled = await confirm({
-      message: "Enable Playwright MCP for visual verification in Assess?",
-      default: current.playwright.enabled
+    const pluginIdx = config.plugin.findIndex((entry) => {
+      const name = typeof entry === "string" ? entry : Array.isArray(entry) ? entry[0] : null;
+      return name === PLUGIN_NAME || String(name ?? "").startsWith(`${PLUGIN_NAME}@`);
     });
-    let playwrightBaseUrl = current.playwright.base_url;
-    if (playwrightEnabled) {
-      playwrightBaseUrl = await input({
-        message: "Playwright base URL:",
-        default: current.playwright.base_url
-      });
+    if (pluginIdx < 0) {
+      return { changed: false };
     }
-    const config = {
-      models: {
-        scope: scopeModel,
-        plan: planModel,
-        execute: executeModel,
-        assess: assessModel
-      },
-      verify: { baseline, after_each },
-      max_assess_cycles,
-      playwright: { enabled: playwrightEnabled, base_url: playwrightBaseUrl }
-    };
-    writePilotConfig(cwd, config);
-    console.log("\n\x1B[32m\u2713\x1B[0m Configuration saved to .glrs/pilot.json");
-    console.log('  Run \x1B[1mpilot scope "<goal>"\x1B[0m to start a new workflow.\n');
-    process.exit(0);
-  }
-});
-
-// src/pilot/cli/scope.ts
-import { command as command2, restPositionals, string } from "cmd-ts";
-import { input as input2 } from "@inquirer/prompts";
-
-// src/pilot/scope.ts
-import * as fs5 from "fs";
-
-// src/pilot/state.ts
-import { Database } from "bun:sqlite";
-import { ulid } from "ulid";
-var SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS workflows (
-  id          TEXT    NOT NULL PRIMARY KEY,
-  goal        TEXT    NOT NULL,
-  scope_path  TEXT,
-  plan_path   TEXT,
-  status      TEXT    NOT NULL CHECK (status IN (
-    'pending','scoped','planned','executing','assessing','completed','failed'
-  )),
-  started_at  INTEGER NOT NULL,
-  finished_at INTEGER,
-  config      TEXT
-);
-
-CREATE TABLE IF NOT EXISTS events (
-  id          INTEGER PRIMARY KEY AUTOINCREMENT,
-  workflow_id TEXT    NOT NULL REFERENCES workflows(id) ON DELETE CASCADE,
-  ts          INTEGER NOT NULL,
-  phase       TEXT    NOT NULL,
-  kind        TEXT    NOT NULL,
-  task_id     TEXT,
-  payload     TEXT    NOT NULL,
-  session_id  TEXT
-);
-
-CREATE INDEX IF NOT EXISTS idx_events_workflow ON events(workflow_id, id);
-CREATE INDEX IF NOT EXISTS idx_events_workflow_phase ON events(workflow_id, phase, id);
-`.trim();
-function openStateDb(dbPath) {
-  const db = new Database(dbPath, { create: true });
-  try {
-    db.run("PRAGMA foreign_keys = ON");
-    if (dbPath !== ":memory:") {
-      db.run("PRAGMA journal_mode = WAL");
-      db.run("PRAGMA synchronous = NORMAL");
+    const current = config.plugin[pluginIdx];
+    const existingName = typeof current === "string" ? current : Array.isArray(current) ? current[0] : PLUGIN_NAME;
+    const existingOpts = Array.isArray(current) && current.length >= 2 ? current[1] : {};
+    if (deepEqual(existingOpts[subKey], value)) {
+      return { changed: false };
     }
-  } catch (err) {
-    db.close();
-    throw new Error(
-      `openStateDb: failed to set PRAGMAs on ${JSON.stringify(dbPath)}: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  try {
-    db.exec(SCHEMA_SQL);
-  } catch (err) {
-    db.close();
-    throw err;
-  }
-  return { db, close: () => db.close() };
-}
-function createWorkflow(db, opts) {
-  const id = ulid();
-  const now = opts.now ?? Date.now();
-  db.prepare(
-    `INSERT INTO workflows (id, goal, status, started_at, config)
-     VALUES (?, ?, 'pending', ?, ?)`
-  ).run(id, opts.goal, now, opts.config ?? null);
-  return id;
-}
-function getWorkflow(db, id) {
-  return db.prepare(
-    `SELECT * FROM workflows WHERE id = ?`
-  ).get(id);
-}
-function latestWorkflow(db) {
-  return db.prepare(
-    `SELECT * FROM workflows ORDER BY started_at DESC LIMIT 1`
-  ).get();
-}
-function updateWorkflowStatus(db, id, status, opts = {}) {
-  const now = opts.now ?? Date.now();
-  const terminal = status === "completed" || status === "failed";
-  db.prepare(
-    `UPDATE workflows
-     SET status = ?,
-         scope_path = COALESCE(?, scope_path),
-         plan_path  = COALESCE(?, plan_path),
-         finished_at = CASE WHEN ? THEN ? ELSE finished_at END
-     WHERE id = ?`
-  ).run(
-    status,
-    opts.scopePath ?? null,
-    opts.planPath ?? null,
-    terminal ? 1 : 0,
-    terminal ? now : null,
-    id
-  );
-}
-function appendEvent(db, opts) {
-  const ts = opts.now ?? Date.now();
-  let payloadStr;
-  try {
-    payloadStr = JSON.stringify(opts.payload);
-  } catch {
-    payloadStr = JSON.stringify({ _serializationError: true });
-  }
-  db.prepare(
-    `INSERT INTO events (workflow_id, ts, phase, kind, task_id, payload, session_id)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`
-  ).run(
-    opts.workflowId,
-    ts,
-    opts.phase,
-    opts.kind,
-    opts.taskId ?? null,
-    payloadStr,
-    opts.sessionId ?? null
-  );
-}
-function readEvents(db, opts) {
-  if (opts.phase) {
-    return db.prepare(
-      `SELECT * FROM events WHERE workflow_id = ? AND phase = ? ORDER BY id LIMIT ?`
-    ).all(opts.workflowId, opts.phase, opts.limit ?? 1e3);
-  }
-  return db.prepare(
-    `SELECT * FROM events WHERE workflow_id = ? ORDER BY id LIMIT ?`
-  ).all(opts.workflowId, opts.limit ?? 1e3);
-}
-function logEvent(db, opts) {
-  appendEvent(db, opts);
-  const indent = "  ".repeat(opts.indent ?? 0);
-  const kvPairs = Object.entries(opts.payload).map(([k, v]) => {
-    const val = typeof v === "string" && v.includes(" ") ? `"${v}"` : String(v);
-    return `${k}=${val}`;
-  }).join(" ");
-  const line = `${indent}[pilot] ${opts.kind.padEnd(32)} ${kvPairs}
-`;
-  process.stderr.write(line);
-}
-
-// src/pilot/safety.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify } from "util";
-var execFileP2 = promisify(execFile2);
-var PROTECTED_BRANCHES = /* @__PURE__ */ new Set(["main", "master", "develop", "trunk"]);
-async function checkSafety(cwd) {
-  try {
-    await execFileP2("git", ["rev-parse", "--is-inside-work-tree"], { cwd });
-  } catch {
-    return { ok: false, reason: "Not inside a git repository." };
-  }
-  let branch;
-  try {
-    const { stdout } = await execFileP2("git", ["branch", "--show-current"], { cwd });
-    branch = stdout.trim();
-  } catch {
-    return { ok: false, reason: "Could not determine current branch." };
-  }
-  if (PROTECTED_BRANCHES.has(branch)) {
-    return {
-      ok: false,
-      reason: `Refusing to run pilot on protected branch "${branch}". Create a feature branch first (e.g. git checkout -b feat/my-feature).`
-    };
-  }
-  let status;
-  try {
-    const { stdout } = await execFileP2("git", ["status", "--porcelain"], { cwd });
-    status = stdout.trim();
+    const newOpts = { ...existingOpts, [subKey]: value };
+    if (opts.dryRun) {
+      info(`[dry-run] Would reconfigure ${subKey} in plugin options`);
+      return { changed: true };
+    }
+    const bakPath = `${configPath}.bak.${Date.now()}-${process.pid}`;
+    fs3.copyFileSync(configPath, bakPath);
+    config.plugin[pluginIdx] = [existingName, newOpts];
+    fs3.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    ok(`Reconfigured ${subKey}`);
+    info(`Backup: ${bakPath}`);
+    return { changed: true, bakPath };
   } catch {
-    return { ok: false, reason: "Could not check working tree status." };
-  }
-  if (status.length > 0) {
-    const lines = status.split("\n").slice(0, 5);
-    const preview = lines.join("\n  ");
-    return {
-      ok: false,
-      reason: `Working tree is dirty. Commit or stash changes before running pilot.
-  ${preview}`
-    };
-  }
-  return { ok: true };
-}
-
-// src/pilot/scope.ts
-function parseScopeArtifact(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-  const obj = raw;
-  if (typeof obj["workflow_id"] !== "string") return null;
-  if (typeof obj["goal"] !== "string") return null;
-  if (typeof obj["framing"] !== "string") return null;
-  if (!Array.isArray(obj["acceptance_criteria"])) return null;
-  const acs = [];
-  for (const ac of obj["acceptance_criteria"]) {
-    if (!ac || typeof ac !== "object") return null;
-    const a = ac;
-    if (typeof a["id"] !== "string") return null;
-    if (typeof a["description"] !== "string") return null;
-    const verifiable = a["verifiable"];
-    if (verifiable !== "shell" && verifiable !== "llm" && verifiable !== "manual") return null;
-    acs.push({ id: a["id"], description: a["description"], verifiable });
+    return { changed: false };
   }
-  return {
-    workflow_id: obj["workflow_id"],
-    goal: obj["goal"],
-    framing: obj["framing"],
-    acceptance_criteria: acs,
-    non_goals: Array.isArray(obj["non_goals"]) ? obj["non_goals"].filter((x) => typeof x === "string") : [],
-    context: typeof obj["context"] === "string" ? obj["context"] : void 0
-  };
 }
-async function runScopePhase(opts) {
-  const { goal, cwd } = opts;
-  const safety = await checkSafety(cwd);
-  if (!safety.ok) {
-    return { ok: false, reason: safety.reason };
-  }
-  const config = loadPilotConfig(cwd);
-  const dbPath = await getStateDbPath(cwd);
-  const { db, close: closeDb } = openStateDb(dbPath);
-  const workflowId = createWorkflow(db, {
-    goal,
-    config: JSON.stringify(config)
-  });
-  const scopePath = await getScopeArtifactPath(cwd, workflowId);
-  logEvent(db, {
-    workflowId,
-    phase: "scope",
-    kind: "workflow.started",
-    payload: { id: workflowId, goal }
-  });
-  logEvent(db, {
-    workflowId,
-    phase: "scope",
-    kind: "task.scope.started",
-    payload: { scopePath }
-  });
-  const scoperPrompt = buildScopePrompt({ goal, scopePath, workflowId });
-  logEvent(db, {
-    workflowId,
-    phase: "scope",
-    kind: "task.scope.tui.spawning",
-    payload: { agent: "pilot-scoper" }
-  });
-  closeDb();
+function writeMcpToggles(configPath, enabledSet, opts) {
   try {
-    const { spawn: spawn2 } = await import("child_process");
-    const scoperPrompt2 = buildScopePrompt({ goal, scopePath, workflowId });
-    const child = spawn2(
-      "opencode",
-      ["--agent", "pilot-scoper", "--prompt", scoperPrompt2],
-      {
-        stdio: "inherit",
-        // TUI takes over the terminal
-        cwd,
-        env: { ...process.env }
+    if (!fs3.existsSync(configPath)) {
+      return { changed: false };
+    }
+    const raw = fs3.readFileSync(configPath, "utf8");
+    const config = JSON.parse(raw);
+    const toggleNames = new Set(MCP_TOGGLES.map((t) => t.name));
+    const existingMcp = config.mcp && typeof config.mcp === "object" ? { ...config.mcp } : {};
+    const newMcp = {};
+    let hasChanges = false;
+    for (const [key, val] of Object.entries(existingMcp)) {
+      if (!toggleNames.has(key)) {
+        newMcp[key] = val;
       }
-    );
-    const exitCode = await new Promise((resolve2) => {
-      child.on("close", (code) => resolve2(code ?? 1));
-      child.on("error", () => resolve2(1));
-    });
-    if (exitCode !== 0) {
-      return {
-        ok: false,
-        reason: `OpenCode TUI exited with code ${exitCode}. Scope session may have been interrupted.`
-      };
     }
-  } catch (err) {
-    return {
-      ok: false,
-      reason: `Failed to spawn OpenCode TUI: ${err instanceof Error ? err.message : String(err)}`
-    };
-  }
-  const { db: db2, close: closeDb2 } = openStateDb(dbPath);
-  try {
-    if (!fs5.existsSync(scopePath)) {
-      logEvent(db2, {
-        workflowId,
-        phase: "scope",
-        kind: "task.scope.failed",
-        payload: { reason: "scope.json not produced" }
-      });
-      closeDb2();
-      return {
-        ok: false,
-        reason: `Scoper did not produce scope.json at ${scopePath}. The session may have ended without completing.`
-      };
+    for (const toggleName of toggleNames) {
+      if (enabledSet.has(toggleName)) {
+        newMcp[toggleName] = { enabled: true };
+        if (!deepEqual(existingMcp[toggleName], { enabled: true })) {
+          hasChanges = true;
+        }
+      } else {
+        if (existingMcp[toggleName] !== void 0) {
+          hasChanges = true;
+        }
+      }
     }
-    let artifact;
-    try {
-      const raw = JSON.parse(fs5.readFileSync(scopePath, "utf8"));
-      artifact = parseScopeArtifact(raw);
-    } catch {
-      closeDb2();
-      return { ok: false, reason: `scope.json at ${scopePath} has invalid JSON` };
+    if (!hasChanges && Object.keys(newMcp).length === Object.keys(existingMcp).length) {
+      const allKeysMatch = Object.keys(newMcp).every(
+        (k) => deepEqual(newMcp[k], existingMcp[k])
+      );
+      if (allKeysMatch) {
+        return { changed: false };
+      }
     }
-    if (!artifact) {
-      closeDb2();
-      return { ok: false, reason: `scope.json at ${scopePath} has invalid schema` };
+    if (opts.dryRun) {
+      info(`[dry-run] Would reconfigure MCP toggles`);
+      return { changed: true };
     }
-    updateWorkflowStatus(db2, workflowId, "scoped", { scopePath });
-    const currentScopePath = await getCurrentScopePath(cwd);
-    fs5.writeFileSync(
-      currentScopePath,
-      JSON.stringify({ workflowId, scopePath }, null, 2) + "\n",
-      "utf8"
-    );
-    logEvent(db2, {
-      workflowId,
-      phase: "scope",
-      kind: "task.scope.completed",
-      payload: {
-        scopePath,
-        goal: artifact.goal,
-        ac_count: artifact.acceptance_criteria.length
-      }
-    });
-    return { ok: true, workflowId, scopePath, artifact };
-  } finally {
-    closeDb2();
+    const bakPath = `${configPath}.bak.${Date.now()}-${process.pid}`;
+    fs3.copyFileSync(configPath, bakPath);
+    if (Object.keys(newMcp).length > 0) {
+      config.mcp = newMcp;
+    } else {
+      delete config.mcp;
+    }
+    fs3.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    ok("Reconfigured MCPs");
+    info(`Backup: ${bakPath}`);
+    return { changed: true, bakPath };
+  } catch {
+    return { changed: false };
   }
 }
-function buildScopePrompt(opts) {
-  return `You are starting a new pilot workflow.
-
-Workflow ID: ${opts.workflowId}
-User's goal: ${opts.goal}
-
-Your job:
-1. Understand what the user wants to build through conversation.
-2. Explore the codebase to understand the current state.
-3. Produce a scope.json artifact at: ${opts.scopePath}
-
-The scope.json must follow this schema:
-{
-  "workflow_id": "${opts.workflowId}",
-  "goal": "one sentence",
-  "framing": "2-4 sentences: why this matters, what success looks like",
-  "acceptance_criteria": [
-    { "id": "AC-001", "description": "behavioral, verifiable statement", "verifiable": "shell|llm|manual" }
-  ],
-  "non_goals": ["what we are NOT doing"],
-  "context": "optional: key patterns, constraints, background for the planner"
-}
-
-Start by asking the user to tell you more about their goal. Then explore the codebase. Then draft acceptance criteria and confirm with the user before writing scope.json.`;
-}
-
-// src/pilot/cli/scope.ts
-var scopeCmd = command2({
-  name: "scope",
-  description: "Start a new pilot workflow with interactive scoping. Produces scope.json for `pilot go`.",
-  args: {
-    goalWords: restPositionals({
-      type: string,
-      displayName: "goal",
-      description: "What you want to build (optional \u2014 will prompt if not provided)"
-    })
-  },
-  handler: async ({ goalWords }) => {
-    const cwd = process.cwd();
-    let goal = goalWords.join(" ").trim();
-    if (!goal) {
-      if (!process.stdin.isTTY) {
-        process.stderr.write("pilot scope: no goal provided and not running in a TTY.\n");
-        process.stderr.write('  Usage: pilot scope "<what you want to build>"\n');
-        process.exit(1);
+function writePluginToggles(configPath, enabledSet, opts) {
+  try {
+    if (!fs3.existsSync(configPath)) {
+      return { changed: false };
+    }
+    const raw = fs3.readFileSync(configPath, "utf8");
+    const config = JSON.parse(raw);
+    const toggleNames = new Set(PLUGIN_TOGGLES.map((t) => t.name));
+    const existingPlugins = Array.isArray(config.plugin) ? config.plugin : [];
+    const currentlyPresent = /* @__PURE__ */ new Set();
+    for (const entry of existingPlugins) {
+      const name = typeof entry === "string" ? entry : Array.isArray(entry) ? entry[0] : null;
+      if (typeof name === "string" && toggleNames.has(name)) {
+        currentlyPresent.add(name);
       }
-      goal = await input2({
-        message: "What do you want to build?"
-      });
-      if (!goal.trim()) {
-        process.stderr.write("pilot scope: goal cannot be empty.\n");
-        process.exit(1);
+    }
+    const toAdd = [];
+    const toRemove = /* @__PURE__ */ new Set();
+    for (const toggleName of toggleNames) {
+      if (enabledSet.has(toggleName) && !currentlyPresent.has(toggleName)) {
+        toAdd.push(toggleName);
+      } else if (!enabledSet.has(toggleName) && currentlyPresent.has(toggleName)) {
+        toRemove.add(toggleName);
       }
     }
-    console.log(`
-\x1B[1mPilot v2 \u2014 Scope phase\x1B[0m`);
-    console.log(`Goal: ${goal}
-`);
-    console.log("Starting interactive scoping session...");
-    console.log("The scoper will interview you and explore the codebase.");
-    console.log("When done, it will produce scope.json for `pilot go`.\n");
-    const result = await runScopePhase({ goal, cwd });
-    if (!result.ok) {
-      process.stderr.write(`
-\x1B[31m\u2717\x1B[0m Scope phase failed: ${result.reason}
-`);
-      process.exit(1);
+    if (toAdd.length === 0 && toRemove.size === 0) {
+      return { changed: false };
     }
-    console.log(`
-\x1B[32m\u2713\x1B[0m Scope complete`);
-    console.log(`  Workflow: ${result.workflowId}`);
-    console.log(`  Goal: ${result.artifact.goal}`);
-    console.log(`  Acceptance criteria: ${result.artifact.acceptance_criteria.length}`);
-    console.log(`  Scope: ${result.scopePath}`);
-    console.log(`
-Run \x1B[1mpilot go\x1B[0m to start autonomous execution.
-`);
-    process.exit(0);
-  }
-});
-
-// src/pilot/cli/go.ts
-import { command as command3, option, string as stringType, optional } from "cmd-ts";
-
-// src/pilot/orchestrator.ts
-import * as fs8 from "fs";
-
-// src/pilot/server.ts
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify2 } from "util";
-import {
-  createOpencodeServer,
-  createOpencodeClient
-} from "@opencode-ai/sdk";
-var execFileP3 = promisify2(execFile3);
-var DEFAULT_STARTUP_TIMEOUT_MS = 3e4;
-async function ensureOpencodeOnPath() {
-  try {
-    await execFileP3("opencode", ["--version"]);
+    if (opts.dryRun) {
+      info(`[dry-run] Would reconfigure plugin toggles`);
+      return { changed: true };
+    }
+    const bakPath = `${configPath}.bak.${Date.now()}-${process.pid}`;
+    fs3.copyFileSync(configPath, bakPath);
+    const newPlugins = existingPlugins.filter((entry) => {
+      const name = typeof entry === "string" ? entry : Array.isArray(entry) ? entry[0] : null;
+      return !(typeof name === "string" && toRemove.has(name));
+    });
+    for (const name of toAdd) {
+      newPlugins.push(name);
+    }
+    config.plugin = newPlugins;
+    fs3.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    ok("Reconfigured plugin add-ons");
+    info(`Backup: ${bakPath}`);
+    return { changed: true, bakPath };
   } catch {
-    throw new Error(
-      "opencode CLI not found on PATH.\n  Install: https://opencode.ai\n  Or: bunx opencode upgrade"
-    );
+    return { changed: false };
   }
 }
-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 {
+async function install(opts = {}) {
+  const { dryRun = false, pin = false, nonInteractive = false } = opts;
+  const configPath = getOpencodeConfigPath();
+  const pluginEntry = pin ? `${PLUGIN_NAME}@${readPackageVersion()}` : PLUGIN_NAME;
+  const interactive = !nonInteractive && process.stdin.isTTY === true;
+  const existing = readExistingConfig(configPath);
+  const hasPlugin = existing ? (Array.isArray(existing.plugin) ? existing.plugin : []).some(
+    (p) => {
+      const name = typeof p === "string" ? p : Array.isArray(p) ? p[0] : null;
+      return name === PLUGIN_NAME || String(name ?? "").startsWith(`${PLUGIN_NAME}@`);
     }
-  };
-  return { url: server.url, client, shutdown };
-}
-async function selfTest(client) {
-  try {
-    await client.session.list();
-  } catch (err) {
-    throw new Error(
-      `OpenCode server self-test failed \u2014 the server started but isn't responding to API calls.
-  Error: ${err instanceof Error ? err.message : String(err)}
-  Run \`opencode --version\` to verify your installation.`
+  ) : false;
+  const existingProvider = detectModelProvider(existing);
+  const existingMcps = detectEnabledMcps(existing);
+  const existingPluginToggles = detectEnabledPluginToggles(existing);
+  const existingOpts = extractPluginOptions(existing);
+  let hasModels = !!(existingOpts?.models ?? existing?.harness?.models);
+  console.log(`
+${c.bold}${c.blue}@glrs-dev/harness-plugin-opencode${c.reset} setup
+`);
+  if (hasPlugin) {
+    ok("Plugin already registered");
+  }
+  if (existingProvider) {
+    ok(`Models: ${existingProvider}`);
+  }
+  if (existingMcps.size > 0) {
+    ok(`MCPs: ${[...existingMcps].join(", ")} enabled`);
+  }
+  let reconfigureModels = false;
+  let reconfigureMcps = false;
+  let reconfigurePluginToggles = false;
+  let newModelsValue = null;
+  let newMcpEnabledSet = /* @__PURE__ */ new Set();
+  let newPluginToggleEnabledSet = new Set(existingPluginToggles);
+  if (hasPlugin && (existingProvider || hasModels)) {
+    const unconfiguredMcps = MCP_TOGGLES.filter(
+      (t) => !existingMcps.has(t.name) && !existing?.mcp?.[t.name]
     );
-  }
-}
-async function createSession(client, opts) {
-  const session = await client.session.create({
-    body: {
-      directory: opts.cwd,
-      ...opts.agentName ? { agentID: opts.agentName } : {}
-    }
-  });
-  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 }] }
-  });
-  return waitForIdle(client, {
-    sessionId: opts.sessionId,
-    stallMs,
-    abortSignal: opts.abortSignal
-  });
-}
-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;
+    if (interactive) {
+      const reconfigure = await promptChoice(
+        "  Reconfigure models?",
+        ["No, keep current config", "Yes, reconfigure models"],
+        0
+      );
+      if (reconfigure === 1) {
+        reconfigureModels = true;
+        hasModels = false;
       }
-      opts.abortSignal.addEventListener("abort", () => settle({ kind: "abort" }), { once: true });
-    }
-    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) });
+      if (existingMcps.size > 0) {
+        const reconfigureMcpChoice = await promptChoice(
+          "  Reconfigure MCPs?",
+          ["No, keep current config", "Yes, reconfigure MCPs"],
+          0
+        );
+        if (reconfigureMcpChoice === 1) {
+          reconfigureMcps = true;
         }
-      } finally {
-        streamDone = true;
       }
-    })();
-    unsubscribe = () => {
-    };
-  });
-}
-
-// src/pilot/plan.ts
-import * as fs6 from "fs";
-function parsePlanArtifact(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-  const obj = raw;
-  if (typeof obj["workflow_id"] !== "string") return null;
-  if (!Array.isArray(obj["tasks"])) return null;
-  const tasks = [];
-  for (const t of obj["tasks"]) {
-    if (!t || typeof t !== "object") return null;
-    const task = t;
-    if (typeof task["id"] !== "string") return null;
-    if (typeof task["title"] !== "string") return null;
-    if (typeof task["prompt"] !== "string") return null;
-    tasks.push({
-      id: task["id"],
-      title: task["title"],
-      prompt: task["prompt"],
-      addresses: Array.isArray(task["addresses"]) ? task["addresses"].filter((x) => typeof x === "string") : [],
-      verify: Array.isArray(task["verify"]) ? task["verify"].filter((x) => typeof x === "string") : []
-    });
+      const reconfigurePluginToggleChoice = await promptChoice(
+        "  Reconfigure plugin add-ons?",
+        ["No, keep current config", "Yes, reconfigure plugin add-ons"],
+        0
+      );
+      if (reconfigurePluginToggleChoice === 1) {
+        reconfigurePluginToggles = true;
+      }
+      if (!reconfigureModels && !reconfigureMcps && !reconfigurePluginToggles && unconfiguredMcps.length === 0) {
+        console.log(`
+${c.bold}Ready.${c.reset} Run ${c.green}opencode${c.reset} to start.
+`);
+        return;
+      }
+    } else if (unconfiguredMcps.length === 0) {
+      console.log(`
+${c.bold}Ready.${c.reset} Run ${c.green}opencode${c.reset} to start.
+`);
+      return;
+    }
   }
-  return { workflow_id: obj["workflow_id"], tasks };
-}
-async function runPlanPhase(opts) {
-  const { workflowId, scope, cwd, server } = opts;
-  const dbPath = await getStateDbPath(cwd);
-  const { db, close: closeDb } = openStateDb(dbPath);
-  const planPath = await getPlanArtifactPath(cwd, workflowId);
-  logEvent(db, {
-    workflowId,
-    phase: "plan",
-    kind: "task.plan.started",
-    payload: { planPath }
-  });
-  try {
-    const sessionId = await createSession(server.client, {
-      cwd,
-      agentName: "pilot-planner"
-    });
-    logEvent(db, {
-      workflowId,
-      phase: "plan",
-      kind: "task.plan.session.created",
-      payload: { sessionId },
-      sessionId
-    });
-    const plannerPrompt = buildPlannerPrompt({ workflowId, scope, planPath });
-    const result = await sendAndWait(server.client, {
-      sessionId,
-      message: plannerPrompt,
-      stallMs: 10 * 60 * 1e3
-      // 10 min
-    });
-    if (result.kind !== "idle") {
-      logEvent(db, {
-        workflowId,
-        phase: "plan",
-        kind: "task.plan.failed",
-        payload: { reason: result.kind },
-        sessionId
-      });
-      return { ok: false, reason: `Planner session ended unexpectedly: ${result.kind}` };
+  const pluginOpts = {};
+  if (interactive && !hasModels) {
+    console.log();
+    console.log(`${c.dim}Models${c.reset}`);
+    info("Fetching available providers\u2026");
+    const modelsDevProviders = await fetchModelsDevProviders();
+    let preset = null;
+    if (modelsDevProviders && modelsDevProviders.length > 0) {
+      const providerChoices = modelsDevProviders.map((p) => p.name);
+      providerChoices.push("Keep defaults (no model config)");
+      providerChoices.push("Custom (enter model IDs manually)");
+      const keepDefaultsIdx = providerChoices.length - 2;
+      const providerIdx = await promptChoice(
+        "  Which model provider?",
+        providerChoices,
+        keepDefaultsIdx
+      );
+      if (providerIdx < modelsDevProviders.length) {
+        const provider = modelsDevProviders[providerIdx];
+        ok(`Provider: ${provider.name}`);
+        const suggested = provider.id === "amazon-bedrock" ? pickBedrockTierIds(provider) : suggestTiersFromModelsDev(provider);
+        const modelChoices = Object.keys(provider.models).map(
+          (modelId) => `${provider.id}/${modelId}`
+        );
+        const tiers = [
+          { tier: "deep", suggested: suggested.deep },
+          { tier: "mid", suggested: suggested.mid },
+          { tier: "fast", suggested: suggested.fast }
+        ];
+        const picked = {};
+        for (const { tier, suggested: suggestedModel } of tiers) {
+          const defaultIdx = modelChoices.indexOf(suggestedModel);
+          const idx = await promptChoice(
+            `  ${tier} model?`,
+            modelChoices,
+            defaultIdx >= 0 ? defaultIdx : 0
+          );
+          picked[tier] = modelChoices[idx];
+          info(`  ${tier} \u2192 ${picked[tier]}`);
+        }
+        preset = {
+          label: provider.name,
+          providerId: provider.id,
+          deep: picked["deep"],
+          mid: picked["mid"],
+          fast: picked["fast"]
+        };
+      } else if (providerIdx === modelsDevProviders.length) {
+        ok("Models: OpenCode defaults");
+        pluginOpts._skipModels = true;
+      }
+    } else {
+      warn("Could not reach Models.dev API \u2014 using built-in presets");
+      const presetLabels = [...MODEL_PRESETS.map((p) => p.label), "Keep defaults (no model config)", "Custom (enter model IDs manually)"];
+      const keepDefaultsOfflineIdx = presetLabels.length - 2;
+      const choice = await promptChoice(
+        "  Which model provider?",
+        presetLabels,
+        keepDefaultsOfflineIdx
+      );
+      if (choice < MODEL_PRESETS.length) {
+        preset = MODEL_PRESETS[choice];
+        ok(`Provider: ${preset.label}`);
+      } else if (choice === MODEL_PRESETS.length) {
+        ok("Models: OpenCode defaults");
+        pluginOpts._skipModels = true;
+      }
     }
-    if (!fs6.existsSync(planPath)) {
-      return { ok: false, reason: `Planner did not produce plan.json at ${planPath}` };
+    if (preset) {
+      pluginOpts.models = {
+        deep: [preset.deep],
+        mid: [preset.mid],
+        fast: [preset.fast]
+      };
+      newModelsValue = {
+        deep: [preset.deep],
+        mid: [preset.mid],
+        fast: [preset.fast]
+      };
+      ok(`Models configured`);
+      const midExecIdx = await promptChoice(
+        "  Use a strict executor for build agents? (recommended for Kimi/Qwen/DeepSeek)",
+        ["No (use mid model as reasoning builder)", "Yes (configure mid-execute model)"],
+        0
+      );
+      if (midExecIdx === 1) {
+        const { input } = await import("@inquirer/prompts");
+        const midExecModel = await input({
+          message: "  mid-execute model ID:",
+          default: preset.mid
+        });
+        if (midExecModel) {
+          pluginOpts.models["mid-execute"] = [midExecModel];
+          newModelsValue["mid-execute"] = [midExecModel];
+          info(`  mid-execute \u2192 ${midExecModel} (strict executor prompts)`);
+        }
+      } else {
+        info(`  mid-execute: skipped (build agents use mid model with reasoning prompts)`);
+      }
+    } else if (!pluginOpts._skipModels) {
+      info("Enter model IDs in <provider>/<model-id> format (e.g. amazon-bedrock/global.anthropic.claude-opus-4-7)");
+      const { input } = await import("@inquirer/prompts");
+      const deepModel = await input({ message: "  deep (most capable):" });
+      const midModel = await input({ message: "  mid (balanced):" });
+      const fastModel = await input({ message: "  fast (cheapest):" });
+      if (deepModel) {
+        const resolvedMid = midModel || deepModel;
+        pluginOpts.models = {
+          deep: [deepModel],
+          mid: [resolvedMid],
+          fast: [fastModel || midModel || deepModel]
+        };
+        newModelsValue = {
+          deep: [deepModel],
+          mid: [resolvedMid],
+          fast: [fastModel || midModel || deepModel]
+        };
+        ok("Models: custom");
+        const midExecModel = await input({ message: "  mid-execute (optional strict executor, press Enter to skip):" });
+        if (midExecModel) {
+          pluginOpts.models["mid-execute"] = [midExecModel];
+          newModelsValue["mid-execute"] = [midExecModel];
+          info(`  mid-execute \u2192 ${midExecModel} (strict executor prompts)`);
+        } else {
+          info(`  mid-execute: skipped (build agents use mid model with reasoning prompts)`);
+        }
+      } else {
+        ok("Models: OpenCode defaults");
+      }
     }
-    let artifact;
-    try {
-      const raw = JSON.parse(fs6.readFileSync(planPath, "utf8"));
-      artifact = parsePlanArtifact(raw);
-    } catch {
-      return { ok: false, reason: `plan.json at ${planPath} has invalid JSON` };
+    delete pluginOpts._skipModels;
+    console.log();
+  }
+  if (interactive && reconfigureMcps) {
+    console.log(`${c.dim}Reconfigure MCP servers${c.reset}`);
+    const currentEnabled = new Set(existingMcps);
+    const selected = await promptMulti(
+      "  Select MCPs to enable:",
+      MCP_TOGGLES.map((t) => ({ label: t.label, defaultOn: currentEnabled.has(t.name) }))
+    );
+    newMcpEnabledSet = new Set([...selected].map((i) => MCP_TOGGLES[i].name));
+    const names = [...newMcpEnabledSet].join(", ");
+    if (newMcpEnabledSet.size > 0) {
+      ok(`MCPs to enable: ${names}`);
+    } else {
+      ok("MCPs: all disabled");
     }
-    if (!artifact) {
-      return { ok: false, reason: `plan.json at ${planPath} has invalid schema` };
+    console.log();
+  }
+  if (interactive && reconfigurePluginToggles) {
+    console.log(`${c.dim}Plugin add-ons${c.reset}`);
+    const currentEnabled = new Set(existingPluginToggles);
+    const selected = await promptMulti(
+      "  Enable plugin add-ons?",
+      PLUGIN_TOGGLES.map((t) => ({ label: t.label, defaultOn: currentEnabled.has(t.name) }))
+    );
+    newPluginToggleEnabledSet = new Set([...selected].map((i) => PLUGIN_TOGGLES[i].name));
+    const names = [...newPluginToggleEnabledSet].join(", ");
+    if (newPluginToggleEnabledSet.size > 0) {
+      ok(`Plugin add-ons enabled: ${names}`);
+    } else {
+      ok("Plugin add-ons: none");
     }
-    updateWorkflowStatus(db, workflowId, "planned", { planPath });
-    logEvent(db, {
-      workflowId,
-      phase: "plan",
-      kind: "task.plan.completed",
-      payload: { planPath, task_count: artifact.tasks.length },
-      sessionId
-    });
-    return { ok: true, planPath, artifact };
-  } finally {
-    closeDb();
+    console.log();
   }
-}
-function buildPlannerPrompt(opts) {
-  const { workflowId, scope, planPath } = opts;
-  const acsText = scope.acceptance_criteria.map((ac) => `  - ${ac.id}: ${ac.description} (verifiable: ${ac.verifiable})`).join("\n");
-  const nonGoalsText = scope.non_goals.length > 0 ? scope.non_goals.map((ng) => `  - ${ng}`).join("\n") : "  (none specified)";
-  return `You are planning a pilot workflow.
-
-Workflow ID: ${workflowId}
-Goal: ${scope.goal}
-Framing: ${scope.framing}
-
-Acceptance criteria:
-${acsText}
-
-Non-goals:
-${nonGoalsText}
-
-${scope.context ? `Context:
-${scope.context}
-
-` : ""}Your job:
-1. Survey the codebase to understand the current state.
-2. Decompose the work into an ordered list of tasks.
-3. Write plan.json at: ${planPath}
-
-The plan.json must follow this schema:
-{
-  "workflow_id": "${workflowId}",
-  "tasks": [
-    {
-      "id": "TASK-001",
-      "title": "Short title",
-      "prompt": "Detailed self-contained instructions for the builder",
-      "addresses": ["AC-001"],
-      "verify": ["bun test src/specific.test.ts"]
+  const pluginValue = Object.keys(pluginOpts).length > 0 ? [pluginEntry, pluginOpts] : pluginEntry;
+  const config = {
+    $schema: "https://opencode.ai/config.json",
+    plugin: [pluginValue]
+  };
+  if (interactive) {
+    const unconfigured = MCP_TOGGLES.filter(
+      (t) => !existingMcps.has(t.name) && !existing?.mcp?.[t.name]
+    );
+    if (unconfigured.length > 0) {
+      console.log(`${c.dim}Optional MCP servers (serena, memory, git are always on)${c.reset}`);
+      const selected = await promptMulti(
+        "  Enable additional MCPs?",
+        unconfigured.map((t) => ({ label: t.label, defaultOn: t.defaultOn }))
+      );
+      if (selected.size > 0) {
+        const mcp = {};
+        for (const idx of selected) {
+          const toggle = unconfigured[idx];
+          mcp[toggle.name] = { enabled: true };
+        }
+        config.mcp = mcp;
+        const names = [...selected].map((i) => unconfigured[i].name).join(", ");
+        ok(`MCPs enabled: ${names}`);
+      } else {
+        ok("MCPs: defaults only");
+      }
+      console.log();
     }
-  ]
-}
-
-Rules:
-- Each task must be independently executable.
-- Each task's prompt must be self-contained (include relevant context).
-- Every AC must be addressed by at least one task.
-- Tasks are executed sequentially \u2014 order matters.
-- Aim for 3-7 tasks. More than 10 is too many.`;
-}
-
-// src/pilot/execute.ts
-import { execFile as execFile4 } from "child_process";
-import { promisify as promisify3 } from "util";
-var execFileP4 = promisify3(execFile4);
-async function runExecutePhase(opts) {
-  const { workflowId, scope, plan, cwd, server } = opts;
-  const dbPath = await getStateDbPath(cwd);
-  const { db, close: closeDb } = openStateDb(dbPath);
-  updateWorkflowStatus(db, workflowId, "executing");
-  logEvent(db, {
-    workflowId,
-    phase: "execute",
-    kind: "task.execute.phase.started",
-    payload: { task_count: plan.tasks.length }
-  });
-  const taskResults = [];
-  try {
-    for (let i = 0; i < plan.tasks.length; i++) {
-      const task = plan.tasks[i];
-      const taskNum = `${i + 1}/${plan.tasks.length}`;
-      logEvent(db, {
-        workflowId,
-        phase: "execute",
-        kind: "task.execute.started",
-        payload: { task: taskNum, id: task.id, title: task.title },
-        taskId: task.id
-      });
-      const result = await runOneTask({
-        workflowId,
-        task,
-        taskNum,
-        scope,
-        cwd,
-        server,
-        db
-      });
-      taskResults.push(result);
-      if (!result.ok) {
-        logEvent(db, {
-          workflowId,
-          phase: "execute",
-          kind: "task.execute.phase.failed",
-          payload: { failed_task: task.id, reason: result.reason },
-          taskId: task.id
-        });
-        return { ok: false, reason: `Task ${task.id} failed: ${result.reason}`, taskResults };
+    const unconfiguredPluginToggles = PLUGIN_TOGGLES.filter(
+      (t) => !existingPluginToggles.has(t.name)
+    );
+    if (unconfiguredPluginToggles.length > 0) {
+      console.log(`${c.dim}Plugin add-ons${c.reset}`);
+      const selected = await promptMulti(
+        "  Enable plugin add-ons?",
+        unconfiguredPluginToggles.map((t) => ({ label: t.label, defaultOn: t.defaultOn }))
+      );
+      if (selected.size > 0) {
+        for (const idx of selected) {
+          const toggle = unconfiguredPluginToggles[idx];
+          config.plugin.push(toggle.name);
+          newPluginToggleEnabledSet.add(toggle.name);
+        }
+        const names = [...selected].map((i) => unconfiguredPluginToggles[i].name).join(", ");
+        ok(`Plugin add-ons enabled: ${names}`);
+      } else {
+        ok("Plugin add-ons: none");
       }
-      logEvent(db, {
-        workflowId,
-        phase: "execute",
-        kind: "task.execute.completed",
-        payload: { task: taskNum, id: task.id, commit: result.commitSha },
-        taskId: task.id
-      });
+      console.log();
     }
-    logEvent(db, {
-      workflowId,
-      phase: "execute",
-      kind: "task.execute.phase.completed",
-      payload: { task_count: plan.tasks.length }
-    });
-    return { ok: true, taskResults };
-  } finally {
-    closeDb();
   }
+  if (reconfigureModels && newModelsValue) {
+    writePluginOption(configPath, "models", newModelsValue, { dryRun });
+  }
+  if (reconfigureMcps) {
+    writeMcpToggles(configPath, newMcpEnabledSet, { dryRun });
+  }
+  if (reconfigurePluginToggles) {
+    writePluginToggles(configPath, newPluginToggleEnabledSet, { dryRun });
+  }
+  if (!fs3.existsSync(configPath)) {
+    if (dryRun) {
+      info(`[dry-run] Would create ${configPath}`);
+      info(`[dry-run] Config: ${JSON.stringify(config, null, 2)}`);
+    } else {
+      seedConfig(config, configPath);
+      ok(`Created ${configPath}`);
+    }
+  } else {
+    try {
+      const result = mergeConfig(config, configPath, dryRun);
+      if (!result.changed) {
+        ok("opencode.json is up to date");
+        for (const w of result.warnings) warn(w);
+      } else {
+        if (dryRun) {
+          info(`[dry-run] Would merge into ${configPath}:`);
+          for (const a of result.additions) info(`  ${a}`);
+        } else {
+          ok(`Updated ${configPath}`);
+          info(`Backup: ${result.bakPath}`);
+          for (const a of result.additions) info(`  ${a}`);
+        }
+        for (const w of result.warnings) warn(w);
+      }
+    } catch (e) {
+      console.error(`\x1B[31m\u2717\x1B[0m ${e.message}`);
+      process.exit(1);
+    }
+  }
+  if (!dryRun) {
+    migrateHarnessKeyToPluginOptions(configPath);
+  }
+  if (!dryRun) {
+    await refreshPluginCacheIfStale();
+  }
+  if (newPluginToggleEnabledSet.has("opencode-snip")) {
+    warn("opencode-snip requires the Go snip binary. Install: brew install vhardouin/opencode-snip/snip");
+  }
+  console.log(`
+${c.bold}Ready.${c.reset} Run ${c.green}opencode${c.reset} to start.
+`);
 }
-async function runOneTask(opts) {
-  const { workflowId, task, taskNum, scope, cwd, server, db } = opts;
-  let headBefore;
+
+// src/cli/uninstall.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import * as os3 from "os";
+var PLUGIN_NAME2 = "@glrs-dev/harness-plugin-opencode";
+function getOpencodeConfigPath2() {
+  const configHome = process.env["XDG_CONFIG_HOME"] ?? path4.join(os3.homedir(), ".config");
+  return path4.join(configHome, "opencode", "opencode.json");
+}
+function uninstall(opts = {}) {
+  const { dryRun = false } = opts;
+  const configPath = getOpencodeConfigPath2();
+  const c3 = {
+    reset: "\x1B[0m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m",
+    blue: "\x1B[34m"
+  };
+  const ok2 = (msg) => console.log(`${c3.green}\u2713${c3.reset} ${msg}`);
+  const info2 = (msg) => console.log(`${c3.blue}\u2022${c3.reset} ${msg}`);
+  const warn2 = (msg) => console.log(`${c3.yellow}!${c3.reset} ${msg}`);
+  console.log(`
+${c3.blue}Uninstalling ${PLUGIN_NAME2}${c3.reset}
+`);
+  if (!fs4.existsSync(configPath)) {
+    warn2(`No opencode.json found at ${configPath} \u2014 nothing to do`);
+    return;
+  }
+  let raw;
   try {
-    const { stdout } = await execFileP4("git", ["rev-parse", "HEAD"], { cwd });
-    headBefore = stdout.trim();
-  } catch {
-    return { ok: false, taskId: task.id, reason: "Could not get HEAD SHA before task" };
+    raw = fs4.readFileSync(configPath, "utf8");
+  } catch (e) {
+    console.error(`\x1B[31m\u2717\x1B[0m Failed to read ${configPath}: ${e.message}`);
+    process.exit(1);
   }
-  let sessionId;
+  let config;
   try {
-    sessionId = await createSession(server.client, {
-      cwd,
-      agentName: "pilot-builder"
-    });
-  } catch (err) {
-    return {
-      ok: false,
-      taskId: task.id,
-      reason: `Failed to create builder session: ${err instanceof Error ? err.message : String(err)}`
-    };
+    config = JSON.parse(raw);
+  } catch (e) {
+    console.error(`\x1B[31m\u2717\x1B[0m Invalid JSON in ${configPath}: ${e.message}`);
+    process.exit(1);
   }
-  const taskPrompt = buildTaskPrompt({ task, scope, workflowId });
-  const result = await sendAndWait(server.client, {
-    sessionId,
-    message: taskPrompt,
-    stallMs: 15 * 60 * 1e3
-    // 15 min per task
+  const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+  const filtered = plugins.filter((p) => {
+    const name = typeof p === "string" ? p : Array.isArray(p) ? p[0] : null;
+    return name !== PLUGIN_NAME2 && !String(name ?? "").startsWith(`${PLUGIN_NAME2}@`);
   });
-  if (result.kind !== "idle") {
-    await cleanWorkingTree(cwd);
-    return {
-      ok: false,
-      taskId: task.id,
-      reason: `Builder session ended unexpectedly: ${result.kind}`
-    };
+  if (filtered.length === plugins.length) {
+    warn2(`"${PLUGIN_NAME2}" not found in plugin array \u2014 nothing to remove`);
+    return;
   }
-  const verifyResult = await runVerifyCommands(task.verify, cwd);
-  if (!verifyResult.ok) {
-    await cleanWorkingTree(cwd);
-    return {
-      ok: false,
-      taskId: task.id,
-      reason: `Verify failed: ${verifyResult.reason}`
-    };
+  if (dryRun) {
+    info2(`[dry-run] Would remove "${PLUGIN_NAME2}" from plugin array in ${configPath}`);
+    return;
   }
-  let commitSha;
+  const bakPath = `${configPath}.bak.${Date.now()}-${process.pid}`;
   try {
-    const { stdout: diffStat } = await execFileP4("git", ["diff", "--name-only", "HEAD"], { cwd });
-    const { stdout: untrackedRaw } = await execFileP4("git", ["ls-files", "--others", "--exclude-standard"], { cwd });
-    const modifiedFiles = diffStat.trim().split("\n").filter(Boolean);
-    const untrackedFiles = untrackedRaw.trim().split("\n").filter(Boolean);
-    const allFiles = [...modifiedFiles, ...untrackedFiles];
-    if (allFiles.length > 20) {
-      process.stderr.write(
-        `  [pilot] \u26A0\uFE0F  Task ${task.id} modified ${allFiles.length} files \u2014 review the commit carefully
-`
-      );
-    }
-    await execFileP4("git", ["add", "-A"], { cwd });
-    await execFileP4("git", ["commit", "-m", `pilot: ${task.title} (${task.id})`], { cwd });
-    const { stdout } = await execFileP4("git", ["rev-parse", "HEAD"], { cwd });
-    commitSha = stdout.trim();
-  } catch (err) {
-    await cleanWorkingTree(cwd);
-    return {
-      ok: false,
-      taskId: task.id,
-      reason: `Commit failed: ${err instanceof Error ? err.message : String(err)}`
-    };
+    fs4.copyFileSync(configPath, bakPath);
+  } catch (e) {
+    console.error(`\x1B[31m\u2717\x1B[0m Failed to write backup: ${e.message}`);
+    process.exit(1);
   }
-  return { ok: true, taskId: task.id, commitSha };
-}
-async function runVerifyCommands(commands, cwd) {
-  for (const cmd2 of commands) {
+  config.plugin = filtered;
+  const tmpPath = `${configPath}.uninstall.tmp.${Date.now()}-${process.pid}`;
+  try {
+    fs4.writeFileSync(tmpPath, JSON.stringify(config, null, 2) + "\n");
+    fs4.renameSync(tmpPath, configPath);
+  } catch (e) {
     try {
-      await execFileP4("bash", ["-c", cmd2], { cwd });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { ok: false, reason: `Command "${cmd2}" failed: ${msg}` };
+      fs4.unlinkSync(tmpPath);
+    } catch {
     }
+    console.error(`\x1B[31m\u2717\x1B[0m Failed to write config: ${e.message}`);
+    process.exit(1);
   }
-  return { ok: true };
+  ok2(`Removed "${PLUGIN_NAME2}" from ${configPath}`);
+  info2(`Backup: ${bakPath}`);
+  console.log(`
+To fully remove the package: bun remove @glrs-dev/harness-plugin-opencode
+`);
 }
-async function cleanWorkingTree(cwd) {
+
+// src/cli/doctor.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import * as os4 from "os";
+import { execSync } from "child_process";
+var PLUGIN_NAME3 = "@glrs-dev/harness-plugin-opencode";
+function getOpencodeConfigPath3() {
+  const configHome = process.env["XDG_CONFIG_HOME"] ?? path5.join(os4.homedir(), ".config");
+  return path5.join(configHome, "opencode", "opencode.json");
+}
+function cmd(command4) {
   try {
-    await execFileP4("git", ["reset", "--hard", "HEAD"], { cwd });
-    await execFileP4("git", ["clean", "-fd"], { cwd });
+    return execSync(command4, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
+    return null;
+  }
+}
+function which(bin) {
+  return cmd(`which ${bin}`) !== null;
+}
+function doctor() {
+  const c3 = {
+    reset: "\x1B[0m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m",
+    red: "\x1B[31m",
+    bold: "\x1B[1m"
+  };
+  const ok2 = (msg) => console.log(`${c3.green}\u2713${c3.reset} ${msg}`);
+  const warn2 = (msg) => console.log(`${c3.yellow}!${c3.reset} ${msg}`);
+  const fail = (msg) => console.log(`${c3.red}\u2717${c3.reset} ${msg}`);
+  console.log(`
+${c3.bold}Doctor \u2014 ${PLUGIN_NAME3}${c3.reset}
+`);
+  const ocVersion = cmd("opencode --version 2>/dev/null | head -1");
+  if (ocVersion) {
+    ok2(`opencode ${ocVersion}`);
+  } else {
+    fail("opencode CLI not found \u2014 install from https://opencode.ai");
+  }
+  const configPath = getOpencodeConfigPath3();
+  if (fs5.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs5.readFileSync(configPath, "utf8"));
+      const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+      let pluginOptions = null;
+      const hasPlugin = plugins.some((p) => {
+        if (typeof p === "string") {
+          return p === PLUGIN_NAME3 || p.startsWith(`${PLUGIN_NAME3}@`);
+        }
+        if (Array.isArray(p)) {
+          const [name, opts] = p;
+          const match = name === PLUGIN_NAME3 || String(name ?? "").startsWith(`${PLUGIN_NAME3}@`);
+          if (match && opts && typeof opts === "object") {
+            pluginOptions = opts;
+          }
+          return match;
+        }
+        return false;
+      });
+      if (hasPlugin) {
+        ok2(`"${PLUGIN_NAME3}" present in opencode.json plugin array`);
+      } else {
+        warn2(`"${PLUGIN_NAME3}" NOT in opencode.json plugin array \u2014 run: bunx ${PLUGIN_NAME3} install`);
+      }
+      const modelSources = [];
+      if (pluginOptions && typeof pluginOptions.models === "object") {
+        modelSources.push({
+          label: "plugin options.models",
+          block: pluginOptions.models
+        });
+      }
+      const legacyHarness = config.harness;
+      if (legacyHarness && typeof legacyHarness.models === "object") {
+        modelSources.push({
+          label: "harness.models (legacy)",
+          block: legacyHarness.models
+        });
+      }
+      if (modelSources.length > 0) {
+        const invalid = [];
+        for (const { label, block } of modelSources) {
+          if (!block || typeof block !== "object") continue;
+          for (const [key, rawValue] of Object.entries(block)) {
+            const candidate = Array.isArray(rawValue) ? rawValue[0] : rawValue;
+            if (typeof candidate !== "string") continue;
+            const result = validateModelOverride(candidate);
+            if (!result.valid) {
+              invalid.push({
+                keyPath: `${label}.${key}`,
+                value: candidate,
+                suggestion: result.suggestion,
+                reason: result.reason
+              });
+            }
+          }
+        }
+        if (invalid.length === 0) {
+          ok2("model overrides look valid");
+        } else {
+          for (const entry of invalid) {
+            fail(`invalid model override at ${entry.keyPath}: "${entry.value}"`);
+            if (entry.reason) {
+              console.log(`    ${c3.yellow}reason:${c3.reset} ${entry.reason}`);
+            }
+            if (entry.suggestion) {
+              console.log(
+                `    ${c3.yellow}fix:${c3.reset}    remove this key, or replace with \`${entry.suggestion}\``
+              );
+            } else {
+              console.log(
+                `    ${c3.yellow}fix:${c3.reset}    remove this key, or run \`bunx ${PLUGIN_NAME3} install\` to pick a current preset`
+              );
+            }
+          }
+        }
+      }
+    } catch {
+      fail(`opencode.json at ${configPath} has invalid JSON`);
+    }
+  } else {
+    warn2(`No opencode.json at ${configPath} \u2014 run: bunx ${PLUGIN_NAME3} install`);
+  }
+  if (which("uvx")) {
+    ok2("uvx (serena + git MCPs)");
+  } else {
+    warn2("uvx not found \u2014 serena and git MCPs won't work. Install: brew install uv");
+  }
+  if (which("node") && which("npx")) {
+    ok2(`node ${cmd("node --version") ?? ""} + npx (memory MCP)`);
+  } else {
+    warn2("node/npx not found \u2014 memory MCP won't work");
   }
+  if (which("bun")) {
+    ok2(`bun ${cmd("bun --version") ?? ""}`);
+  } else if (which("npm")) {
+    ok2(`npm ${cmd("npm --version") ?? ""} (install bun for faster installs)`);
+  } else {
+    fail("Neither bun nor npm found \u2014 cannot install plugins");
+  }
+  console.log();
 }
-function buildTaskPrompt(opts) {
-  const { task, scope, workflowId } = opts;
-  const verifyText = task.verify.length > 0 ? task.verify.map((v) => `  - ${v}`).join("\n") : "  (no verify commands \u2014 just make the changes)";
-  const addressesText = task.addresses.length > 0 ? task.addresses.join(", ") : "(none specified)";
-  return `You are executing a pilot task.
-
-Workflow: ${workflowId}
-Task: ${task.id} \u2014 ${task.title}
-Addresses: ${addressesText}
-
-${task.prompt}
 
-Verify commands (run these after making changes):
-${verifyText}
+// src/autopilot/cli.ts
+import { command, option, positional, string as stringType, optional, number as numberType, flag } from "cmd-ts";
 
-Rules:
-- DO NOT commit. The orchestrator commits after verify passes.
-- DO NOT push.
-- DO NOT ask questions.
-- If verify fails, fix the issue and re-run.
-- If you cannot proceed after 3 attempts, output: STOP: <reason>`;
-}
-
-// src/pilot/assess.ts
-import * as fs7 from "fs";
-import * as path4 from "path";
-function parseAssessmentArtifact(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-  const obj = raw;
-  if (typeof obj["workflow_id"] !== "string") return null;
-  if (obj["verdict"] !== "pass" && obj["verdict"] !== "fail") return null;
-  if (!Array.isArray(obj["ac_results"])) return null;
-  const acResults = [];
-  for (const r of obj["ac_results"]) {
-    if (!r || typeof r !== "object") return null;
-    const result = r;
-    if (typeof result["id"] !== "string") return null;
-    if (!["met", "unmet", "partial"].includes(result["status"])) return null;
-    if (typeof result["evidence"] !== "string") return null;
-    acResults.push({
-      id: result["id"],
-      status: result["status"],
-      evidence: result["evidence"],
-      gap: typeof result["gap"] === "string" ? result["gap"] : void 0
-    });
-  }
-  const risks = [];
-  if (Array.isArray(obj["deployment_risks"])) {
-    for (const r of obj["deployment_risks"]) {
-      if (!r || typeof r !== "object") continue;
-      const risk = r;
-      if (!["high", "medium", "low"].includes(risk["severity"])) continue;
-      if (typeof risk["description"] !== "string") continue;
-      risks.push({
-        severity: risk["severity"],
-        description: risk["description"],
-        actionable: Boolean(risk["actionable"]),
-        suggested_fix: typeof risk["suggested_fix"] === "string" ? risk["suggested_fix"] : void 0
-      });
+// 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 {
+      const { stdout } = await execFile2("git", ["diff", "--stat"], { cwd });
+      return stdout.trim() || "(no uncommitted changes)";
+    } catch {
+      return "(git diff unavailable)";
     }
   }
-  return {
-    workflow_id: obj["workflow_id"],
-    verdict: obj["verdict"],
-    ac_results: acResults,
-    deployment_risks: risks,
-    replan_guidance: typeof obj["replan_guidance"] === "string" ? obj["replan_guidance"] : void 0
-  };
 }
-async function runAssessPhase(opts) {
-  const { workflowId, scope, plan, cwd, cycle, server } = opts;
-  const dbPath = await getStateDbPath(cwd);
-  const { db, close: closeDb } = openStateDb(dbPath);
-  updateWorkflowStatus(db, workflowId, "assessing");
-  const assessPath = await getAssessArtifactPath(cwd, workflowId, cycle);
-  logEvent(db, {
-    workflowId,
-    phase: "assess",
-    kind: "task.assess.started",
-    payload: { cycle, assessPath }
-  });
+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 {
-    const sessionId = await createSession(server.client, {
-      cwd,
-      agentName: "pilot-assessor"
-    });
-    logEvent(db, {
-      workflowId,
-      phase: "assess",
-      kind: "task.assess.session.created",
-      payload: { sessionId, cycle },
-      sessionId
+    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"
     });
-    const assessorPrompt = buildAssessorPrompt({ workflowId, scope, plan, assessPath, cycle });
-    const result = await sendAndWait(server.client, {
+    await _sendAndWait(opts.server.client, {
       sessionId,
-      message: assessorPrompt,
-      stallMs: 10 * 60 * 1e3
-      // 10 min
+      message: contextMessage,
+      stallMs: 5 * 60 * 1e3
+      // 5 min stall timeout for debrief
     });
-    if (result.kind !== "idle") {
-      logEvent(db, {
-        workflowId,
-        phase: "assess",
-        kind: "task.assess.failed",
-        payload: { reason: result.kind, cycle },
-        sessionId
-      });
-      return { ok: false, reason: `Assessor session ended unexpectedly: ${result.kind}` };
-    }
-    if (!fs7.existsSync(assessPath)) {
-      return { ok: false, reason: `Assessor did not produce assessment report at ${assessPath}` };
-    }
-    let artifact;
-    try {
-      const raw = JSON.parse(fs7.readFileSync(assessPath, "utf8"));
-      artifact = parseAssessmentArtifact(raw);
-    } catch {
-      return { ok: false, reason: `Assessment report has invalid JSON` };
-    }
-    if (!artifact) {
-      return { ok: false, reason: `Assessment report has invalid schema` };
-    }
-    for (const acResult of artifact.ac_results) {
-      const kind = acResult.status === "met" ? "task.assess.gate.passed" : "task.assess.gate.failed";
-      logEvent(db, {
-        workflowId,
-        phase: "assess",
-        kind,
-        payload: {
-          gate: acResult.id,
-          status: acResult.status,
-          ...acResult.gap ? { reason: acResult.gap } : {}
-        },
-        sessionId
-      });
+    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");
     }
-    const highRisks = artifact.deployment_risks.filter((r) => r.severity === "high" && r.actionable);
-    if (highRisks.length > 0) {
-      logEvent(db, {
-        workflowId,
-        phase: "assess",
-        kind: "task.assess.risk_check",
-        payload: { risks: highRisks.map((r) => r.description) },
-        sessionId
-      });
-    }
-    if (artifact.verdict === "pass") {
-      logEvent(db, {
-        workflowId,
-        phase: "assess",
-        kind: "task.assess.passed",
-        payload: { all_acs_met: true, cycle },
-        sessionId
-      });
-      return { ok: true, verdict: "pass", artifact };
-    } else {
-      const unmetAcs = artifact.ac_results.filter((r) => r.status !== "met").map((r) => r.id);
-      logEvent(db, {
-        workflowId,
-        phase: "assess",
-        kind: "task.assess.failed",
-        payload: { unmet: unmetAcs, cycle },
-        sessionId
-      });
-      return {
-        ok: true,
-        verdict: "fail",
-        artifact,
-        replanGuidance: artifact.replan_guidance ?? `Unmet ACs: ${unmetAcs.join(", ")}`
-      };
-    }
-  } finally {
-    closeDb();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`\x1B[33m\u26A0 Debrief failed (non-fatal): ${msg}\x1B[0m
+`);
   }
 }
-async function getAssessArtifactPath(cwd, workflowId, cycle) {
-  const base = await getPilotDir(cwd);
-  const dir = path4.join(base, "scopes", workflowId);
-  fs7.mkdirSync(dir, { recursive: true });
-  return path4.join(dir, `assessment-cycle-${cycle}.json`);
-}
-function buildAssessorPrompt(opts) {
-  const { workflowId, scope, plan, assessPath, cycle } = opts;
-  const acsText = scope.acceptance_criteria.map((ac) => `  - ${ac.id}: ${ac.description} (verifiable: ${ac.verifiable})`).join("\n");
-  return `You are assessing a pilot workflow.
 
-Workflow: ${workflowId}
-Goal: ${scope.goal}
-Assessment cycle: ${cycle}
+// 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
 
-Acceptance criteria to evaluate:
-${acsText}
+`);
+    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}
 
-Your job:
-1. FIRST: Deployment-risk reflection. Ask yourself:
-   - What could break when this deploys?
-   - What unexpected consequences could this change have on existing functionality?
-   - What could go wrong?
+`);
+    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);
+  }
+});
 
-2. THEN: Evaluate each AC against the current state of the codebase.
-   - Run verify commands from the plan.
-   - Check the git diff to see what changed.
-   - For shell-verifiable ACs, run the commands.
-   - For llm-verifiable ACs, use your judgment.
+// src/autopilot/autopilot-cmd.ts
+import { command as command2, option as option2, optional as optional2, string as stringType2 } from "cmd-ts";
 
-3. Write your assessment to: ${assessPath}
+// src/autopilot/interactive.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
 
-The assessment must follow this schema:
-{
-  "workflow_id": "${workflowId}",
-  "verdict": "pass|fail",
-  "ac_results": [
-    { "id": "AC-001", "status": "met|unmet|partial", "evidence": "what you observed", "gap": "if unmet: what's missing" }
-  ],
-  "deployment_risks": [
-    { "severity": "high|medium|low", "description": "what could go wrong", "actionable": true, "suggested_fix": "optional" }
-  ],
-  "replan_guidance": "if verdict=fail: specific guidance for the re-planner"
+// src/plan-paths.ts
+import { execFile } from "child_process";
+import * as fs6 from "fs/promises";
+import * as os5 from "os";
+import * as path6 from "path";
+function execFileP(file, args, opts = {}) {
+  const { cwd, timeoutMs = 5e3 } = opts;
+  return new Promise((resolve2, 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;
+        }
+        resolve2(stdout ?? "");
+      }
+    );
+  });
 }
-
-Verdict is "pass" only if ALL ACs are "met" AND no high-severity actionable risks exist.`;
+function expandTilde(p) {
+  if (p === "~") return os5.homedir();
+  if (p.startsWith("~/")) return path6.join(os5.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 = path6.isAbsolute(gitCommonDir) ? gitCommonDir : path6.resolve(worktreeDir, gitCommonDir);
+  const repoRoot = path6.dirname(absCommonDir);
+  return path6.basename(repoRoot);
+}
+async function getPlanDir(worktreeDir) {
+  const override = process.env.GLORIOUS_PLAN_DIR;
+  const base = override ? expandTilde(override) : path6.join(os5.homedir(), ".glorious", "opencode");
+  const repoFolder = await getRepoFolder(worktreeDir);
+  const planDir = path6.join(base, repoFolder, "plans");
+  await fs6.mkdir(planDir, { recursive: true });
+  return planDir;
 }
 
-// src/pilot/resolve.ts
-async function runResolvePhase(opts) {
-  const { workflowId, scope, assessment, cwd, startedAt } = opts;
-  const dbPath = await getStateDbPath(cwd);
-  const { db, close: closeDb } = openStateDb(dbPath);
-  logEvent(db, {
-    workflowId,
-    phase: "resolve",
-    kind: "task.resolve.started",
-    payload: {}
+// src/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
   });
-  const acknowledgedRisks = assessment.deployment_risks.filter((r) => !r.actionable || r.severity !== "high").map((r) => r.description);
-  if (acknowledgedRisks.length > 0) {
-    logEvent(db, {
-      workflowId,
-      phase: "resolve",
-      kind: "task.resolve.acknowledged_risks",
-      payload: { risks: acknowledgedRisks }
-    });
-  }
-  const durationMs = Date.now() - startedAt;
-  updateWorkflowStatus(db, workflowId, "completed");
-  logEvent(db, {
-    workflowId,
-    phase: "resolve",
-    kind: "task.resolve.completed",
-    payload: { acknowledged_risks: acknowledgedRisks.length }
+  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
   });
-  logEvent(db, {
-    workflowId,
-    phase: "resolve",
-    kind: "workflow.completed",
-    payload: {
-      duration: `${Math.round(durationMs / 1e3)}s`
-    }
+  banner(`\u2713 Plan written at ${planResult.planPath}`);
+  banner("\u2192 Phase 3/3: Executing (headless loop)...");
+  const loopResult = await deps.runLoop({
+    planPath: planResult.planPath,
+    cwd
   });
-  closeDb();
   return {
-    workflowId,
-    goal: scope.goal,
-    durationMs,
-    acknowledgedRisks
+    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()}`;
+}
+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}
 
-// src/pilot/orchestrator.ts
-async function runOrchestrator(opts) {
-  const { cwd } = opts;
-  const startedAt = Date.now();
-  const safety = await checkSafety(cwd);
-  if (!safety.ok) {
-    return { ok: false, reason: safety.reason };
-  }
-  const config = loadPilotConfig(cwd);
-  const { getPilotConfigPath: getPilotConfigPath2 } = await import("./paths-WZ23ZQOV.js");
-  const configPath = getPilotConfigPath2(cwd);
-  if (fs8.existsSync(configPath)) {
-    try {
-      const raw = JSON.parse(fs8.readFileSync(configPath, "utf8"));
-      if (raw && typeof raw === "object" && ("baseline" in raw || "after_each" in raw)) {
-        process.stderr.write(
-          "\n\x1B[33m\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n\u2502  \u26A0\uFE0F  Old pilot v1 config detected (.glrs/pilot.json)             \u2502\n\u2502  Run `pilot configure` to set up v2 configuration.              \u2502\n\u2502  Using defaults until then.                                     \u2502\n\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n\x1B[0m\n"
-        );
+`);
+      return null;
+    }
+    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;
+        }
+        continue;
       }
-    } catch {
+      currentDir = dirPath;
+      continue;
     }
   }
-  const scopePath = opts.scopePath ?? await findCurrentScope(cwd);
-  if (!scopePath) {
-    return {
-      ok: false,
-      reason: 'No scope found. Run `pilot scope "<goal>"` first.'
-    };
+}
+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
+    });
   }
-  let scope;
-  try {
-    const raw = JSON.parse(fs8.readFileSync(scopePath, "utf8"));
-    const parsed = parseScopeArtifact(raw);
-    if (!parsed) {
-      return { ok: false, reason: `scope.json at ${scopePath} has invalid schema` };
+  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 }
+        ]
+      });
+      browseRoot = which2;
+    } else if (hasRepoLocal) {
+      browseRoot = repoLocalPlansDir;
+    } else {
+      browseRoot = planDir;
     }
-    scope = parsed;
-  } catch {
-    return { ok: false, reason: `Could not read scope.json at ${scopePath}` };
-  }
-  const workflowId = scope.workflow_id;
-  const dbPath = await getStateDbPath(cwd);
-  const { db, close: closeDb } = openStateDb(dbPath);
-  logEvent(db, {
-    workflowId,
-    phase: "plan",
-    kind: "workflow.go.started",
-    payload: { goal: scope.goal, scopePath }
-  });
-  closeDb();
-  let server;
-  try {
-    server = await startServer({ cwd });
-    await selfTest(server.client);
-  } catch (err) {
-    return {
-      ok: false,
-      reason: `Failed to start OpenCode server: ${err instanceof Error ? err.message : String(err)}`,
-      workflowId
-    };
-  }
-  try {
-    const planResult = await runPlanPhase({ workflowId, scope, cwd, server });
-    if (!planResult.ok) {
-      return { ok: false, reason: `Plan phase failed: ${planResult.reason}`, workflowId };
+    let selectedPlan;
+    if (_deps?.browsePlans) {
+      selectedPlan = await _deps.browsePlans(browseRoot);
+    } else {
+      selectedPlan = await browsePlansDir(browseRoot, _deps?.readdirSync);
     }
-    let currentPlan = planResult.artifact;
-    const maxCycles = config.max_assess_cycles;
-    for (let cycle = 1; cycle <= maxCycles; cycle++) {
-      const executeResult = await runExecutePhase({
-        workflowId,
-        scope,
-        plan: currentPlan,
-        cwd,
-        server
-      });
-      if (!executeResult.ok) {
-        return { ok: false, reason: `Execute phase failed: ${executeResult.reason}`, workflowId };
-      }
-      const assessResult = await runAssessPhase({
-        workflowId,
-        scope,
-        plan: currentPlan,
-        cwd,
-        cycle,
-        server
-      });
-      if (!assessResult.ok) {
-        return { ok: false, reason: `Assess phase failed: ${assessResult.reason}`, workflowId };
-      }
-      if (assessResult.verdict === "pass") {
-        const resolveResult = await runResolvePhase({
-          workflowId,
-          scope,
-          assessment: assessResult.artifact,
-          cwd,
-          startedAt
+    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" }
+          ]
         });
-        return {
-          ok: true,
-          workflowId,
-          goal: scope.goal,
-          durationMs: resolveResult.durationMs,
-          acknowledgedRisks: resolveResult.acknowledgedRisks
-        };
-      }
-      if (cycle < maxCycles) {
-        const elapsedSec = Math.round((Date.now() - startedAt) / 1e3);
+        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(
           `
-[pilot] \u26A0\uFE0F  Assess cycle ${cycle}/${maxCycles} failed. Re-planning...
-  Gap: ${assessResult.replanGuidance}
-  Elapsed: ${elapsedSec}s
+  Plan: ${planState.totalItems} items, ${unchecked} remaining.
 
 `
         );
-        const { db: replanDb, close: closeReplanDb } = openStateDb(dbPath);
-        logEvent(replanDb, {
-          workflowId,
-          phase: "plan",
-          kind: "task.plan.replan",
-          payload: { gap: assessResult.replanGuidance, cycle }
-        });
-        closeReplanDb();
-        const replanResult = await runPlanPhase({
-          workflowId,
-          scope: {
-            ...scope,
-            context: `${scope.context ?? ""}
-
-Previous attempt failed. Gap to address:
-${assessResult.replanGuidance}`
-          },
-          cwd,
-          server
-        });
-        if (!replanResult.ok) {
-          return { ok: false, reason: `Re-plan failed: ${replanResult.reason}`, workflowId };
-        }
-        currentPlan = replanResult.artifact;
+        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
+        };
       }
     }
-    const { db: failDb, close: closeFailDb } = openStateDb(dbPath);
-    updateWorkflowStatus(failDb, workflowId, "failed");
-    logEvent(failDb, {
-      workflowId,
-      phase: "assess",
-      kind: "task.assess.cycles.exhausted",
-      payload: { max_cycles: maxCycles }
+  }
+  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."
     });
-    closeFailDb();
-    return {
-      ok: false,
-      reason: `Assess failed after ${maxCycles} cycles. Manual intervention required.`,
-      workflowId
-    };
-  } finally {
-    await server.shutdown();
   }
-}
-async function findCurrentScope(cwd) {
-  try {
-    const pointerPath = await getCurrentScopePath(cwd);
-    if (!fs8.existsSync(pointerPath)) return null;
-    const pointer = JSON.parse(fs8.readFileSync(pointerPath, "utf8"));
-    return typeof pointer.scopePath === "string" ? pointer.scopePath : null;
-  } catch {
-    return null;
+  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: ""
+    });
   }
-}
-
-// src/pilot/cli/go.ts
-var goCmd = command3({
-  name: "go",
-  description: "Run the autonomous SPEAR loop (Plan \u2192 Execute \u2192 Assess \u2192 Resolve). Requires a scope from `pilot scope`.",
-  args: {
-    scope: option({
-      long: "scope",
-      type: optional(stringType),
-      description: "Path to scope.json (defaults to the current scope from `pilot scope`)"
-    })
-  },
-  handler: async ({ scope }) => {
-    const cwd = process.cwd();
-    console.log("\n\x1B[1mPilot v2 \u2014 Autonomous execution\x1B[0m");
-    console.log("Running: Plan \u2192 Execute \u2192 Assess \u2192 Resolve\n");
-    const result = await runOrchestrator({ cwd, scopePath: scope });
-    if (!result.ok) {
-      process.stderr.write(`
-\x1B[31m\u2717\x1B[0m Pilot failed: ${result.reason}
-`);
-      if (result.workflowId) {
-        process.stderr.write(`  Workflow: ${result.workflowId}
-`);
-      }
-      process.exit(1);
-    }
-    const durationSec = Math.round(result.durationMs / 1e3);
-    const durationStr = durationSec >= 60 ? `${Math.floor(durationSec / 60)}m ${durationSec % 60}s` : `${durationSec}s`;
-    console.log(`
-\x1B[32m\u2713\x1B[0m Workflow complete`);
-    console.log(`  Goal: ${result.goal}`);
-    console.log(`  Duration: ${durationStr}`);
-    if (result.acknowledgedRisks.length > 0) {
-      console.log(`
-  Acknowledged risks (non-blocking):`);
-      for (const risk of result.acknowledgedRisks) {
-        console.log(`    \u2022 ${risk}`);
-      }
+  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
     }
-    console.log();
-    process.exit(0);
-  }
-});
+  );
+}
 
-// src/pilot/cli/status.ts
-import { command as command4, option as option2, string as stringType2, optional as optional2, flag } from "cmd-ts";
-var statusCmd = command4({
-  name: "status",
-  description: "Show pilot workflow status.",
+// src/autopilot/autopilot-cmd.ts
+var autopilotInteractiveCmd = command2({
+  name: "autopilot",
+  description: "Interactive three-phase autopilot: scope with @scoper, plan with @plan, then execute with the Ralph loop. Produces a structured plan before running.",
   args: {
-    workflow: option2({
-      long: "workflow",
+    slug: option2({
+      long: "slug",
       type: optional2(stringType2),
-      description: "Workflow ID (defaults to the latest)"
-    }),
-    json: flag({
-      long: "json",
-      description: "Output JSON"
+      description: "Plan slug (kebab-case, \u22645 words). If omitted, you will be prompted during the scoping session."
     })
   },
-  handler: async ({ workflow, json }) => {
-    const cwd = process.cwd();
-    const dbPath = await getStateDbPath(cwd);
-    const { db, close } = openStateDb(dbPath);
-    try {
-      const wf = workflow ? getWorkflow(db, workflow) : latestWorkflow(db);
-      if (!wf) {
-        process.stderr.write('No workflows found. Run `pilot scope "<goal>"` to start one.\n');
-        process.exit(1);
-      }
-      const events = readEvents(db, { workflowId: wf.id, limit: 100 });
-      if (json) {
-        process.stdout.write(JSON.stringify({ workflow: wf, events }, null, 2) + "\n");
-        process.exit(0);
-      }
-      const started = new Date(wf.started_at).toLocaleString();
-      const finished = wf.finished_at ? new Date(wf.finished_at).toLocaleString() : "--";
-      const statusColor = wf.status === "completed" ? "\x1B[32m" : wf.status === "failed" ? "\x1B[31m" : "\x1B[33m";
-      console.log(`
-Workflow ${wf.id}`);
-      console.log(`  Goal:    ${wf.goal}`);
-      console.log(`  Status:  ${statusColor}${wf.status}\x1B[0m`);
-      console.log(`  Started: ${started}`);
-      console.log(`  Ended:   ${finished}`);
-      console.log(`
-Recent events (${events.length}):`);
-      for (const event of events.slice(-20)) {
-        const ts = new Date(event.ts).toLocaleTimeString();
-        const payload = (() => {
-          try {
-            const p = JSON.parse(event.payload);
-            return Object.entries(p).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(" ");
-          } catch {
-            return event.payload;
-          }
-        })();
-        console.log(`  ${ts} [${event.phase}] ${event.kind} ${payload}`);
-      }
-      console.log();
-      process.exit(0);
-    } finally {
-      close();
-    }
-  }
-});
-
-// src/pilot/cli/shims.ts
-import { command as command5 } from "cmd-ts";
-function removedCommand(name, replacement) {
-  return command5({
-    name,
-    description: `[removed] Use \`${replacement}\` instead.`,
-    args: {},
-    handler: async () => {
-      process.stderr.write(
-        `
-\x1B[33m!\x1B[0m \`pilot ${name}\` was removed in pilot v2.
-  Use \x1B[1m${replacement}\x1B[0m instead.
-
-  Migration guide:
-    pilot scope "<goal>"  \u2014 interactive scoping (replaces pilot plan)
-    pilot go              \u2014 autonomous execution (replaces pilot build)
-    pilot configure       \u2014 set up models and verify commands
-    pilot status          \u2014 check workflow status
-
+  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)
 `
-      );
-      process.exit(1);
-    }
-  });
-}
-var buildShim = removedCommand("build", "pilot go");
-var validateShim = removedCommand("validate", "pilot configure");
-var logsShim = removedCommand("logs", "pilot status --json");
-var costShim = removedCommand("cost", "pilot status --json");
-var buildResumeShim = removedCommand("build-resume", "pilot go");
-
-// src/pilot/cli/index.ts
-var pilotSubcommand = subcommands({
-  name: "pilot",
-  description: "Pilot v2 \u2014 SPEAR-based autonomous execution (scope \u2192 plan \u2192 execute \u2192 assess \u2192 resolve).",
-  cmds: {
-    scope: scopeCmd,
-    go: goCmd,
-    configure: configureCmd,
-    status: statusCmd,
-    // Shims for removed v1 commands (print migration message)
-    build: buildShim,
-    validate: validateShim,
-    logs: logsShim,
-    cost: costShim,
-    "build-resume": buildResumeShim
+    );
   }
 });
 
 // src/cli/cli-update.ts
-import * as fs9 from "fs";
-import * as path5 from "path";
-import * as os4 from "os";
+import * as fs8 from "fs";
+import * as path8 from "path";
+import * as os6 from "os";
 import { spawn } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var PACKAGE_NAME = "@glrs-dev/harness-plugin-opencode";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-var c = {
+var c2 = {
   reset: "\x1B[0m",
   green: "\x1B[32m",
   yellow: "\x1B[33m",
@@ -2098,12 +1779,12 @@ function isMajorBump(current, latest) {
   return latest.major > current.major;
 }
 function getStateFilePath() {
-  const cacheHome = process.env["XDG_CACHE_HOME"] ?? path5.join(os4.homedir(), ".cache");
-  return path5.join(cacheHome, "harness-opencode", "cli-update.json");
+  const cacheHome = process.env["XDG_CACHE_HOME"] ?? path8.join(os6.homedir(), ".cache");
+  return path8.join(cacheHome, "harness-opencode", "cli-update.json");
 }
 function readState() {
   try {
-    const raw = fs9.readFileSync(getStateFilePath(), "utf8");
+    const raw = fs8.readFileSync(getStateFilePath(), "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -2112,21 +1793,21 @@ function readState() {
 function writeState(state) {
   try {
     const statePath = getStateFilePath();
-    fs9.mkdirSync(path5.dirname(statePath), { recursive: true });
-    fs9.writeFileSync(statePath, JSON.stringify(state));
+    fs8.mkdirSync(path8.dirname(statePath), { recursive: true });
+    fs8.writeFileSync(statePath, JSON.stringify(state));
   } catch {
   }
 }
 function readInstalledVersion() {
-  const here = path5.dirname(fileURLToPath2(import.meta.url));
+  const here = path8.dirname(fileURLToPath2(import.meta.url));
   const candidates = [
-    path5.join(here, "..", "package.json"),
-    path5.join(here, "..", "..", "package.json"),
-    path5.join(here, "package.json")
+    path8.join(here, "..", "package.json"),
+    path8.join(here, "..", "..", "package.json"),
+    path8.join(here, "package.json")
   ];
   for (const candidate of candidates) {
     try {
-      const raw = fs9.readFileSync(candidate, "utf8");
+      const raw = fs8.readFileSync(candidate, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed.name === PACKAGE_NAME && typeof parsed.version === "string") {
         return parsed.version;
@@ -2197,7 +1878,7 @@ function startUpdateCheck() {
       action = () => {
         process.stderr.write(
           `
-${c.blue}\u2022${c.reset} Updating ${PACKAGE_NAME} ${c.dim}${currentVersionStr}${c.reset} \u2192 ${c.green}${latestStr}${c.reset} in the background...
+${c2.blue}\u2022${c2.reset} Updating ${PACKAGE_NAME} ${c2.dim}${currentVersionStr}${c2.reset} \u2192 ${c2.green}${latestStr}${c2.reset} in the background...
 `
         );
         spawnBackgroundUpdate();
@@ -2212,8 +1893,8 @@ ${c.blue}\u2022${c.reset} Updating ${PACKAGE_NAME} ${c.dim}${currentVersionStr}$
 function printMajorNotice(current, latest) {
   process.stderr.write(
     `
-${c.yellow}${c.bold}Major update available:${c.reset} ${current} \u2192 ${c.green}${latest}${c.reset}
-${c.dim}Review the changelog before upgrading:${c.reset}
+${c2.yellow}${c2.bold}Major update available:${c2.reset} ${current} \u2192 ${c2.green}${latest}${c2.reset}
+${c2.dim}Review the changelog before upgrading:${c2.reset}
   bun update -g ${PACKAGE_NAME}
 `
   );
@@ -2252,7 +1933,7 @@ Upgrade Node or run via a compatible Bun runtime. See the "engines" field in pac
   }
 }
 var VERSION = "0.1.0";
-var installCmd = command6({
+var installCmd = command3({
   name: "install",
   description: 'Add "@glrs-dev/harness-plugin-opencode" to your opencode.json plugin array.',
   args: {
@@ -2269,7 +1950,7 @@ var installCmd = command6({
     await install({ dryRun, pin });
   }
 });
-var uninstallCmd = command6({
+var uninstallCmd = command3({
   name: "uninstall",
   description: 'Remove "@glrs-dev/harness-plugin-opencode" from your opencode.json plugin array.',
   args: {
@@ -2282,7 +1963,7 @@ var uninstallCmd = command6({
     uninstall({ dryRun });
   }
 });
-var doctorCmd = command6({
+var doctorCmd = command3({
   name: "doctor",
   description: "Check installation health (OpenCode CLI, plugin registration, MCP backends).",
   args: {},
@@ -2290,58 +1971,7 @@ var doctorCmd = command6({
     doctor();
   }
 });
-var planCheckCmd = command6({
-  name: "plan-check",
-  description: "Parse a plan file's plan-state fence (legacy markdown plans).",
-  args: {
-    run: option3({
-      long: "run",
-      type: optional3(string2),
-      description: "Print verify commands for pending items, one per line."
-    }),
-    check: option3({
-      long: "check",
-      type: optional3(string2),
-      description: "Structural validation; exits 1 if any item is invalid."
-    }),
-    rest: restPositionals2({
-      type: string2,
-      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 = command6({
-  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 = command6({
+var installPluginCmd = command3({
   name: "install-plugin",
   description: 'Add "@glrs-dev/harness-plugin-opencode" to your opencode.json plugin array.',
   args: {
@@ -2358,7 +1988,7 @@ var installPluginCmd = command6({
     await install({ dryRun, pin });
   }
 });
-var cli = subcommands2({
+var cli = subcommands({
   name: "glrs-oc",
   description: "OpenCode agent harness CLI.",
   version: VERSION,
@@ -2367,9 +1997,11 @@ var cli = subcommands2({
     install: installCmd,
     uninstall: uninstallCmd,
     doctor: doctorCmd,
-    "plan-check": planCheckCmd,
-    "plan-dir": planDirCmd,
-    pilot: pilotSubcommand
+    // `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();