@glrs-dev/cli 2.1.0 → 2.2.0

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

@@ -1,65 +1,1037 @@
 #!/usr/bin/env bun
 import {
+  getOpenCodeCachePackageDir,
+  inspectCachePin,
+  readOurPackageVersion,
+  refreshPluginCache,
   validateModelOverride
-} from "./chunk-DZG4D3OH.js";
-import {
-  install
-} from "./chunk-6CZPRUMJ.js";
-import "./chunk-VJUETC6A.js";
-import {
-  getCurrentScopePath,
-  getPilotConfigPath,
-  getPilotDir,
-  getPlanArtifactPath,
-  getScopeArtifactPath,
-  getStateDbPath
-} from "./chunk-OYRKOEXK.js";
+} from "./chunk-PDMXYZM4.js";
 
 // src/cli.ts
 import {
   binary,
-  command as command6,
-  flag as flag2,
-  option as option3,
-  optional as optional3,
-  positional,
-  restPositionals as restPositionals2,
-  string as string2,
-  subcommands as subcommands2,
+  command as command2,
+  flag,
+  option as option2,
+  optional as optional2,
+  positional as positional2,
+  restPositionals,
+  string,
+  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";
+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;
+    }
+  }
+}
+function mergeConfig(srcJson, dstPath, dryRun = false) {
+  let dstText;
+  try {
+    dstText = fs.readFileSync(dstPath, "utf8");
+  } catch (e) {
+    throw new Error(`Failed to read dst ${dstPath}: ${e.message}`);
+  }
+  let dst;
+  try {
+    dst = JSON.parse(dstText);
+  } catch (e) {
+    throw new Error(
+      `User config at ${dstPath} has invalid JSON: ${e.message}. Not touching the file.`
+    );
+  }
+  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) {
+    return { changed: true, bakPath: "(dry-run)", additions, warnings };
+  }
+  const suffix = `${Date.now()}-${process.pid}`;
+  const bakPath = `${dstPath}.bak.${suffix}`;
+  const tmpPath = `${dstPath}.merge.tmp.${suffix}`;
+  try {
+    fs.copyFileSync(dstPath, bakPath);
+  } catch (e) {
+    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}`);
+  }
+  try {
+    fs.renameSync(tmpPath, dstPath);
+  } catch (e) {
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch {
+    }
+    try {
+      fs.unlinkSync(bakPath);
+    } catch {
+    }
+    throw new Error(`Failed to rename ${tmpPath} \u2192 ${dstPath}: ${e.message}`);
+  }
+  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/plugin-check.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
 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;
+}
+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);
+}
+
+// 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 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 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 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);
+    }
+    if (providers.length === 0) return null;
+    return providers;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// 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"
+  }
+];
+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
+  }
+];
+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];
+    }
+  }
+  return null;
+}
+function readPackageVersion() {
+  const here = path3.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path3.join(here, "..", "package.json"),
+    path3.join(here, "..", "..", "package.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const raw = fs3.readFileSync(candidate, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.name === PLUGIN_NAME && typeof parsed.version === "string") {
+        return parsed.version;
+      }
+    } catch {
+    }
+  }
+  throw new Error(
+    `Could not locate ${PLUGIN_NAME}'s package.json to read version`
+  );
+}
 function getOpencodeConfigPath() {
-  const configHome = process.env["XDG_CONFIG_HOME"] ?? path.join(os.homedir(), ".config");
-  return path.join(configHome, "opencode", "opencode.json");
+  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 {
+    return JSON.parse(fs3.readFileSync(configPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+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);
+    }
+  }
+  return enabled;
+}
+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);
+    }
+  }
+  return enabled;
+}
+function migrateHarnessKeyToPluginOptions(configPath) {
+  try {
+    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 {
+  }
+}
+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;
+  }
+  return true;
+}
+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 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}@`);
+    });
+    if (pluginIdx < 0) {
+      return { changed: false };
+    }
+    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 };
+    }
+    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 { changed: false };
+  }
+}
+function writeMcpToggles(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(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;
+      }
+    }
+    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;
+        }
+      }
+    }
+    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 (opts.dryRun) {
+      info(`[dry-run] Would reconfigure MCP toggles`);
+      return { changed: true };
+    }
+    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 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);
+      }
+    }
+    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);
+      }
+    }
+    if (toAdd.length === 0 && toRemove.size === 0) {
+      return { changed: false };
+    }
+    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 {
+    return { changed: false };
+  }
+}
+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}@`);
+    }
+  ) : 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]
+    );
+    if (interactive) {
+      const reconfigure = await promptChoice(
+        "  Reconfigure models?",
+        ["No, keep current config", "Yes, reconfigure models"],
+        0
+      );
+      if (reconfigure === 1) {
+        reconfigureModels = true;
+        hasModels = false;
+      }
+      if (existingMcps.size > 0) {
+        const reconfigureMcpChoice = await promptChoice(
+          "  Reconfigure MCPs?",
+          ["No, keep current config", "Yes, reconfigure MCPs"],
+          0
+        );
+        if (reconfigureMcpChoice === 1) {
+          reconfigureMcps = true;
+        }
+      }
+      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;
+    }
+  }
+  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 (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");
+      }
+    }
+    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");
+    }
+    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");
+    }
+    console.log();
+  }
+  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();
+    }
+    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");
+      }
+      console.log();
+    }
+  }
+  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.
+`);
+}
+
+// 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 = getOpencodeConfigPath();
-  const c2 = {
+  const configPath = getOpencodeConfigPath2();
+  const c3 = {
     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}`);
+  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(`
-${c2.blue}Uninstalling ${PLUGIN_NAME}${c2.reset}
+${c3.blue}Uninstalling ${PLUGIN_NAME2}${c3.reset}
 `);
-  if (!fs.existsSync(configPath)) {
-    warn(`No opencode.json found at ${configPath} \u2014 nothing to do`);
+  if (!fs4.existsSync(configPath)) {
+    warn2(`No opencode.json found at ${configPath} \u2014 nothing to do`);
     return;
   }
   let raw;
   try {
-    raw = fs.readFileSync(configPath, "utf8");
+    raw = fs4.readFileSync(configPath, "utf8");
   } catch (e) {
     console.error(`\x1B[31m\u2717\x1B[0m Failed to read ${configPath}: ${e.message}`);
     process.exit(1);
@@ -74,19 +1046,19 @@ ${c2.blue}Uninstalling ${PLUGIN_NAME}${c2.reset}
   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}@`);
+    return name !== PLUGIN_NAME2 && !String(name ?? "").startsWith(`${PLUGIN_NAME2}@`);
   });
   if (filtered.length === plugins.length) {
-    warn(`"${PLUGIN_NAME}" not found in plugin array \u2014 nothing to remove`);
+    warn2(`"${PLUGIN_NAME2}" not found in plugin array \u2014 nothing to remove`);
     return;
   }
   if (dryRun) {
-    info(`[dry-run] Would remove "${PLUGIN_NAME}" from plugin array in ${configPath}`);
+    info2(`[dry-run] Would remove "${PLUGIN_NAME2}" from plugin array in ${configPath}`);
     return;
   }
   const bakPath = `${configPath}.bak.${Date.now()}-${process.pid}`;
   try {
-    fs.copyFileSync(configPath, bakPath);
+    fs4.copyFileSync(configPath, bakPath);
   } catch (e) {
     console.error(`\x1B[31m\u2717\x1B[0m Failed to write backup: ${e.message}`);
     process.exit(1);
@@ -94,36 +1066,36 @@ ${c2.blue}Uninstalling ${PLUGIN_NAME}${c2.reset}
   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);
+    fs4.writeFileSync(tmpPath, JSON.stringify(config, null, 2) + "\n");
+    fs4.renameSync(tmpPath, configPath);
   } catch (e) {
     try {
-      fs.unlinkSync(tmpPath);
+      fs4.unlinkSync(tmpPath);
     } catch {
     }
     console.error(`\x1B[31m\u2717\x1B[0m Failed to write config: ${e.message}`);
     process.exit(1);
   }
-  ok(`Removed "${PLUGIN_NAME}" from ${configPath}`);
-  info(`Backup: ${bakPath}`);
+  ok2(`Removed "${PLUGIN_NAME2}" from ${configPath}`);
+  info2(`Backup: ${bakPath}`);
   console.log(`
 To fully remove the package: bun remove @glrs-dev/harness-plugin-opencode
 `);
 }
 
 // src/cli/doctor.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as os2 from "os";
+import * as fs5 from "fs";
+import * as path5 from "path";
+import * as os4 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");
+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(command7) {
+function cmd(command3) {
   try {
-    return execSync(command7, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return execSync(command3, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
     return null;
   }
@@ -132,38 +1104,38 @@ function which(bin) {
   return cmd(`which ${bin}`) !== null;
 }
 function doctor() {
-  const c2 = {
+  const c3 = {
     reset: "\x1B[0m",
     green: "\x1B[32m",
     yellow: "\x1B[33m",
     red: "\x1B[31m",
     bold: "\x1B[1m"
   };
-  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}`);
+  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(`
-${c2.bold}Doctor \u2014 ${PLUGIN_NAME2}${c2.reset}
+${c3.bold}Doctor \u2014 ${PLUGIN_NAME3}${c3.reset}
 `);
   const ocVersion = cmd("opencode --version 2>/dev/null | head -1");
   if (ocVersion) {
-    ok(`opencode ${ocVersion}`);
+    ok2(`opencode ${ocVersion}`);
   } else {
     fail("opencode CLI not found \u2014 install from https://opencode.ai");
   }
-  const configPath = getOpencodeConfigPath2();
-  if (fs2.existsSync(configPath)) {
+  const configPath = getOpencodeConfigPath3();
+  if (fs5.existsSync(configPath)) {
     try {
-      const config = JSON.parse(fs2.readFileSync(configPath, "utf8"));
+      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_NAME2 || p.startsWith(`${PLUGIN_NAME2}@`);
+          return p === PLUGIN_NAME3 || p.startsWith(`${PLUGIN_NAME3}@`);
         }
         if (Array.isArray(p)) {
           const [name, opts] = p;
-          const match = name === PLUGIN_NAME2 || String(name ?? "").startsWith(`${PLUGIN_NAME2}@`);
+          const match = name === PLUGIN_NAME3 || String(name ?? "").startsWith(`${PLUGIN_NAME3}@`);
           if (match && opts && typeof opts === "object") {
             pluginOptions = opts;
           }
@@ -172,9 +1144,9 @@ ${c2.bold}Doctor \u2014 ${PLUGIN_NAME2}${c2.reset}
         return false;
       });
       if (hasPlugin) {
-        ok(`"${PLUGIN_NAME2}" present in opencode.json plugin array`);
+        ok2(`"${PLUGIN_NAME3}" present in opencode.json plugin array`);
       } else {
-        warn(`"${PLUGIN_NAME2}" NOT in opencode.json plugin array \u2014 run: bunx ${PLUGIN_NAME2} install`);
+        warn2(`"${PLUGIN_NAME3}" NOT in opencode.json plugin array \u2014 run: bunx ${PLUGIN_NAME3} install`);
       }
       const modelSources = [];
       if (pluginOptions && typeof pluginOptions.models === "object") {
@@ -209,20 +1181,20 @@ ${c2.bold}Doctor \u2014 ${PLUGIN_NAME2}${c2.reset}
           }
         }
         if (invalid.length === 0) {
-          ok("model overrides look valid");
+          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(`    ${c2.yellow}reason:${c2.reset} ${entry.reason}`);
+              console.log(`    ${c3.yellow}reason:${c3.reset} ${entry.reason}`);
             }
             if (entry.suggestion) {
               console.log(
-                `    ${c2.yellow}fix:${c2.reset}    remove this key, or replace with \`${entry.suggestion}\``
+                `    ${c3.yellow}fix:${c3.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`
+                `    ${c3.yellow}fix:${c3.reset}    remove this key, or run \`bunx ${PLUGIN_NAME3} install\` to pick a current preset`
               );
             }
           }
@@ -232,73 +1204,44 @@ ${c2.bold}Doctor \u2014 ${PLUGIN_NAME2}${c2.reset}
       fail(`opencode.json at ${configPath} has invalid JSON`);
     }
   } else {
-    warn(`No opencode.json at ${configPath} \u2014 run: bunx ${PLUGIN_NAME2} install`);
+    warn2(`No opencode.json at ${configPath} \u2014 run: bunx ${PLUGIN_NAME3} install`);
   }
   if (which("uvx")) {
-    ok("uvx (serena + git MCPs)");
+    ok2("uvx (serena + git MCPs)");
   } else {
-    warn("uvx not found \u2014 serena and git MCPs won't work. Install: brew install uv");
+    warn2("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)`);
+    ok2(`node ${cmd("node --version") ?? ""} + npx (memory MCP)`);
   } else {
-    warn("node/npx not found \u2014 memory MCP won't work");
+    warn2("node/npx not found \u2014 memory MCP won't work");
   }
-  const planCheckResult = cmd(`bunx ${PLUGIN_NAME2} plan-check --help 2>/dev/null`);
+  const planCheckResult = cmd(`bunx ${PLUGIN_NAME3} plan-check --help 2>/dev/null`);
   if (planCheckResult !== null) {
-    ok("plan-check CLI invokable");
+    ok2("plan-check CLI invokable");
   } else {
-    warn("plan-check CLI not invokable \u2014 try: bun install");
+    warn2("plan-check CLI not invokable \u2014 try: bun install");
   }
   if (which("bun")) {
-    ok(`bun ${cmd("bun --version") ?? ""}`);
+    ok2(`bun ${cmd("bun --version") ?? ""}`);
   } else if (which("npm")) {
-    ok(`npm ${cmd("npm --version") ?? ""} (install bun for faster installs)`);
+    ok2(`npm ${cmd("npm --version") ?? ""} (install bun for faster installs)`);
   } else {
     fail("Neither bun nor npm found \u2014 cannot install plugins");
   }
   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");
-  }
-  if (which("bash")) {
-    ok("bash (verify-runner shell)");
-  } else {
-    fail("bash not found \u2014 pilot's verify commands run via `bash -c`");
-  }
-  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"
-        );
-      }
-    }
-  } else {
-    warn(
-      "could not run `opencode agent list` \u2014 skipping pilot agent registration check"
-    );
-  }
-  console.log();
 }
 
 // src/bin/plan-check.ts
 import { execFileSync } from "child_process";
-import { fileURLToPath } from "url";
-import { dirname, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname3, join as join5 } from "path";
 function planCheck(args) {
-  const here = dirname(fileURLToPath(import.meta.url));
+  const here = dirname3(fileURLToPath2(import.meta.url));
   const candidates = [
-    join3(here, "plan-check.sh"),
+    join5(here, "plan-check.sh"),
     // dev: src/bin/plan-check.sh
-    join3(here, "bin", "plan-check.sh")
+    join5(here, "bin", "plan-check.sh")
     // dist: dist/ → dist/bin/plan-check.sh
   ];
   let scriptPath;
@@ -326,9 +1269,9 @@ function planCheck(args) {
 
 // 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";
+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) => {
@@ -350,8 +1293,8 @@ function execFileP(file, args, opts = {}) {
   });
 }
 function expandTilde(p) {
-  if (p === "~") return os3.homedir();
-  if (p.startsWith("~/")) return path3.join(os3.homedir(), p.slice(2));
+  if (p === "~") return os5.homedir();
+  if (p.startsWith("~/")) return path6.join(os5.homedir(), p.slice(2));
   return p;
 }
 async function getRepoFolder(worktreeDir) {
@@ -374,695 +1317,92 @@ async function getRepoFolder(worktreeDir) {
       `getRepoFolder: \`git rev-parse --git-common-dir\` returned empty for ${worktreeDir}`
     );
   }
-  const absCommonDir = path3.isAbsolute(gitCommonDir) ? gitCommonDir : path3.resolve(worktreeDir, gitCommonDir);
-  const repoRoot = path3.dirname(absCommonDir);
-  return path3.basename(repoRoot);
+  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) : path3.join(os3.homedir(), ".glorious", "opencode");
+  const base = override ? expandTilde(override) : path6.join(os5.homedir(), ".glorious", "opencode");
   const repoFolder = await getRepoFolder(worktreeDir);
-  const planDir = path3.join(base, repoFolder, "plans");
-  await fs3.mkdir(planDir, { recursive: true });
+  const planDir = path6.join(base, repoFolder, "plans");
+  await fs6.mkdir(planDir, { recursive: true });
   return planDir;
 }
 async function migratePlans(worktreeDir, planDir) {
-  const oldDir = path3.join(worktreeDir, ".agent", "plans");
-  const marker = path3.join(oldDir, ".migrated");
+  const oldDir = path6.join(worktreeDir, ".agent", "plans");
+  const marker = path6.join(oldDir, ".migrated");
   try {
-    await fs3.stat(oldDir);
+    await fs6.stat(oldDir);
   } catch {
     return;
   }
   try {
-    await fs3.stat(marker);
+    await fs6.stat(marker);
     return;
   } catch {
   }
   let entries;
   try {
-    entries = await fs3.readdir(oldDir);
+    entries = await fs6.readdir(oldDir);
   } catch {
     return;
   }
   const planFiles = entries.filter(
     (name) => name.endsWith(".md") && !name.startsWith(".")
   );
-  await fs3.mkdir(planDir, { recursive: true });
+  await fs6.mkdir(planDir, { recursive: true });
   for (const name of planFiles) {
-    const src = path3.join(oldDir, name);
-    const dst = path3.join(planDir, name);
+    const src = path6.join(oldDir, name);
+    const dst = path6.join(planDir, name);
     let dstExists = false;
     try {
-      await fs3.stat(dst);
+      await fs6.stat(dst);
       dstExists = true;
     } catch {
       dstExists = false;
     }
     if (!dstExists) {
-      await fs3.rename(src, dst);
+      await fs6.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;
-    }
-    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, "");
-}
-
-// 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;
-  try {
-    raw = JSON.parse(fs4.readFileSync(configPath, "utf8"));
-  } 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 });
-  }
-  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
-  });
-}
-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);
-    }
-    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
-    });
-    let playwrightBaseUrl = current.playwright.base_url;
-    if (playwrightEnabled) {
-      playwrightBaseUrl = await input({
-        message: "Playwright base URL:",
-        default: current.playwright.base_url
-      });
-    }
-    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");
-    }
-  } 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();
-  } 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 {
-    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();
-  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 }
-      }
-    );
-    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.`
-      };
-    }
-    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 (!artifact) {
-      closeDb2();
-      return { ok: false, reason: `scope.json at ${scopePath} has invalid schema` };
-    }
-    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();
-  }
-}
-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);
-      }
-      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);
-      }
-    }
-    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);
+      fs6.readFile(src),
+      fs6.readFile(dst)
+    ]);
+    if (srcBuf.equals(dstBuf)) {
+      await fs6.unlink(src);
+      continue;
     }
-    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);
+    process.stderr.write(
+      `[harness-opencode] migratePlans: conflict on ${name} \u2014 destination ${dst} exists with different content; leaving source ${src} in place. Resolve manually.
+`
+    );
   }
-});
-
-// src/pilot/cli/go.ts
-import { command as command3, option, string as stringType, optional } from "cmd-ts";
+  await fs6.writeFile(marker, "");
+}
 
-// src/pilot/orchestrator.ts
-import * as fs8 from "fs";
+// src/autopilot/cli.ts
+import { command, option, positional, string as stringType, optional, number as numberType } from "cmd-ts";
 
-// src/pilot/server.ts
-import { execFile as execFile3 } from "child_process";
+// src/autopilot/loop.ts
+import { execFile as execFileCb } from "child_process";
 import { promisify as promisify2 } from "util";
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join8 } from "path";
+
+// src/lib/opencode-server.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify } from "util";
 import {
   createOpencodeServer,
   createOpencodeClient
 } from "@opencode-ai/sdk";
-var execFileP3 = promisify2(execFile3);
+var execFileP2 = promisify(execFile2);
 var DEFAULT_STARTUP_TIMEOUT_MS = 3e4;
 async function ensureOpencodeOnPath() {
   try {
-    await execFileP3("opencode", ["--version"]);
+    await execFileP2("opencode", ["--version"]);
   } catch {
     throw new Error(
       "opencode CLI not found on PATH.\n  Install: https://opencode.ai\n  Or: bunx opencode upgrade"
@@ -1089,17 +1429,6 @@ async function startServer(opts) {
   };
   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.`
-    );
-  }
-}
 async function createSession(client, opts) {
   const session = await client.session.create({
     body: {
@@ -1179,904 +1508,262 @@ async function waitForIdle(client, opts) {
     };
   });
 }
-
-// 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") : []
-    });
-  }
-  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}` };
-    }
-    if (!fs6.existsSync(planPath)) {
-      return { ok: false, reason: `Planner did not produce plan.json at ${planPath}` };
-    }
-    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` };
-    }
-    if (!artifact) {
-      return { ok: false, reason: `plan.json at ${planPath} has invalid schema` };
-    }
-    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();
-  }
-}
-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"]
-    }
-  ]
-}
-
-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 };
-      }
-      logEvent(db, {
-        workflowId,
-        phase: "execute",
-        kind: "task.execute.completed",
-        payload: { task: taskNum, id: task.id, commit: result.commitSha },
-        taskId: task.id
-      });
-    }
-    logEvent(db, {
-      workflowId,
-      phase: "execute",
-      kind: "task.execute.phase.completed",
-      payload: { task_count: plan.tasks.length }
-    });
-    return { ok: true, taskResults };
-  } finally {
-    closeDb();
-  }
-}
-async function runOneTask(opts) {
-  const { workflowId, task, taskNum, scope, cwd, server, db } = opts;
-  let headBefore;
-  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" };
-  }
-  let sessionId;
-  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)}`
-    };
-  }
-  const taskPrompt = buildTaskPrompt({ task, scope, workflowId });
-  const result = await sendAndWait(server.client, {
-    sessionId,
-    message: taskPrompt,
-    stallMs: 15 * 60 * 1e3
-    // 15 min per task
-  });
-  if (result.kind !== "idle") {
-    await cleanWorkingTree(cwd);
-    return {
-      ok: false,
-      taskId: task.id,
-      reason: `Builder session ended unexpectedly: ${result.kind}`
-    };
-  }
-  const verifyResult = await runVerifyCommands(task.verify, cwd);
-  if (!verifyResult.ok) {
-    await cleanWorkingTree(cwd);
-    return {
-      ok: false,
-      taskId: task.id,
-      reason: `Verify failed: ${verifyResult.reason}`
-    };
-  }
-  let commitSha;
-  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)}`
-    };
-  }
-  return { ok: true, taskId: task.id, commitSha };
-}
-async function runVerifyCommands(commands, cwd) {
-  for (const cmd2 of commands) {
-    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}` };
-    }
-  }
-  return { ok: true };
-}
-async function cleanWorkingTree(cwd) {
+async function getLastAssistantMessage(client, sessionId) {
   try {
-    await execFileP4("git", ["reset", "--hard", "HEAD"], { cwd });
-    await execFileP4("git", ["clean", "-fd"], { cwd });
+    const messages = await client.session.messages({ path: { id: sessionId } });
+    const assistantMessages = messages.filter((m) => m.info.role === "assistant");
+    if (assistantMessages.length === 0) return "";
+    const last = assistantMessages[assistantMessages.length - 1];
+    return last.parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
   } catch {
+    return "";
   }
 }
-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}
+// src/autopilot/config.ts
+var MAX_ITERATIONS = 50;
+var STRUGGLE_THRESHOLD = 3;
+var TIMEOUT_MS = 4 * 60 * 60 * 1e3;
+var STALL_MS = 60 * 60 * 1e3;
+var KILL_SWITCH_PATH = ".agent/autopilot-disable";
+var SENTINEL_TAG = "<autopilot-done>";
 
-Verify commands (run these after making changes):
-${verifyText}
-
-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/autopilot/sentinel.ts
+function detectSentinel(text) {
+  if (!text.includes(SENTINEL_TAG)) {
+    return false;
+  }
+  const withoutFences = text.replace(/```[\s\S]*?```/g, "");
+  const withoutInline = withoutFences.replace(/`[^`\n]*`/g, "");
+  return withoutInline.includes(SENTINEL_TAG);
 }
 
-// src/pilot/assess.ts
+// src/autopilot/struggle.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
-      });
-    }
-  }
-  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 }
-  });
-  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 assessorPrompt = buildAssessorPrompt({ workflowId, scope, plan, assessPath, cycle });
-    const result = await sendAndWait(server.client, {
-      sessionId,
-      message: assessorPrompt,
-      stallMs: 10 * 60 * 1e3
-      // 10 min
-    });
-    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 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 };
+import * as path7 from "path";
+var StruggleDetector = class {
+  _consecutiveStalls = 0;
+  _threshold;
+  constructor(threshold) {
+    this._threshold = threshold;
+  }
+  /** Number of consecutive stall iterations recorded so far. */
+  get consecutiveStalls() {
+    return this._consecutiveStalls;
+  }
+  /**
+   * Record the result of one iteration.
+   * @param madeProgress - true if the agent made filesystem changes this iteration.
+   */
+  record(madeProgress) {
+    if (madeProgress) {
+      this._consecutiveStalls = 0;
     } else {
-      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(", ")}`
-      };
+      this._consecutiveStalls++;
     }
-  } finally {
-    closeDb();
   }
-}
-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}
-
-Acceptance criteria to evaluate:
-${acsText}
-
-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?
-
-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.
-
-3. Write your assessment to: ${assessPath}
-
-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"
-}
-
-Verdict is "pass" only if ALL ACs are "met" AND no high-severity actionable risks exist.`;
-}
-
-// 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: {}
-  });
-  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 }
-    });
+  /**
+   * Returns true if the agent has stalled for `threshold` consecutive
+   * iterations without making progress.
+   */
+  isStruggling() {
+    return this._consecutiveStalls >= this._threshold;
   }
-  const durationMs = Date.now() - startedAt;
-  updateWorkflowStatus(db, workflowId, "completed");
-  logEvent(db, {
-    workflowId,
-    phase: "resolve",
-    kind: "task.resolve.completed",
-    payload: { acknowledged_risks: acknowledgedRisks.length }
-  });
-  logEvent(db, {
-    workflowId,
-    phase: "resolve",
-    kind: "workflow.completed",
-    payload: {
-      duration: `${Math.round(durationMs / 1e3)}s`
-    }
-  });
-  closeDb();
-  return {
-    workflowId,
-    goal: scope.goal,
-    durationMs,
-    acknowledgedRisks
-  };
+};
+function checkKillSwitch(cwd) {
+  const killSwitchFile = path7.join(cwd, KILL_SWITCH_PATH);
+  return fs7.existsSync(killSwitchFile);
 }
 
-// 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)) {
+// src/autopilot/loop.ts
+var execFile3 = promisify2(execFileCb);
+function buildFullPrompt(userPrompt) {
+  const candidates = [
+    join8(import.meta.dir, "prompt-template.md"),
+    join8(import.meta.dir, "..", "..", "src", "autopilot", "prompt-template.md")
+  ];
+  let template = "";
+  for (const candidate of candidates) {
     try {
-      const raw = 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"
-        );
-      }
+      const raw = readFileSync6(candidate, "utf8");
+      template = raw.replace(/^---\n[\s\S]*?\n---\n/, "");
+      break;
     } catch {
     }
   }
-  const scopePath = opts.scopePath ?? await findCurrentScope(cwd);
-  if (!scopePath) {
-    return {
-      ok: false,
-      reason: 'No scope found. Run `pilot scope "<goal>"` first.'
-    };
-  }
-  let scope;
+  const withArgs = template.replace("$ARGUMENTS", userPrompt);
+  return withArgs || userPrompt;
+}
+async function checkProgress(cwd, baseRef) {
   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` };
-    }
-    scope = parsed;
+    const { stdout } = await execFile3("git", ["diff", "--stat", baseRef], { cwd });
+    return stdout.trim().length > 0;
   } 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
-    };
+    return true;
   }
+}
+async function getHeadSha(cwd) {
   try {
-    const planResult = await runPlanPhase({ workflowId, scope, cwd, server });
-    if (!planResult.ok) {
-      return { ok: false, reason: `Plan phase failed: ${planResult.reason}`, workflowId };
-    }
-    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 { stdout } = await execFile3("git", ["rev-parse", "HEAD"], { cwd });
+    return stdout.trim();
+  } catch {
+    return "HEAD";
+  }
+}
+async function runRalphLoop(opts) {
+  const maxIterations = opts.maxIterations ?? MAX_ITERATIONS;
+  const timeoutMs = opts.timeoutMs ?? TIMEOUT_MS;
+  const stallMs = opts.stallMs ?? STALL_MS;
+  const struggleThreshold = opts.struggleThreshold ?? STRUGGLE_THRESHOLD;
+  const _startServer = opts._deps?.startServer ?? startServer;
+  const _createSession = opts._deps?.createSession ?? createSession;
+  const _sendAndWait = opts._deps?.sendAndWait ?? sendAndWait;
+  const _getLastAssistantMessage = opts._deps?.getLastAssistantMessage ?? getLastAssistantMessage;
+  const fullPrompt = buildFullPrompt(opts.prompt);
+  const struggle = new StruggleDetector(struggleThreshold);
+  const startTime = Date.now();
+  const server = await _startServer({ cwd: opts.cwd });
+  const abort = new AbortController();
+  const timeoutHandle = setTimeout(() => {
+    abort.abort();
+  }, timeoutMs);
+  try {
+    const sessionId = await _createSession(server.client, {
+      cwd: opts.cwd,
+      agentName: "prime"
+    });
+    for (let iteration = 1; iteration <= maxIterations; iteration++) {
+      if (checkKillSwitch(opts.cwd)) {
+        return {
+          exitReason: "kill-switch",
+          iterations: iteration - 1,
+          message: `Kill switch active (.agent/autopilot-disable exists). Stopping after ${iteration - 1} iteration(s).`
+        };
+      }
+      if (Date.now() - startTime >= timeoutMs) {
+        return {
+          exitReason: "timeout",
+          iterations: iteration - 1,
+          message: `Total timeout (${timeoutMs}ms) exceeded after ${iteration - 1} iteration(s).`
+        };
       }
-      const assessResult = await runAssessPhase({
-        workflowId,
-        scope,
-        plan: currentPlan,
-        cwd,
-        cycle,
-        server
+      const headBefore = await getHeadSha(opts.cwd);
+      const result = await _sendAndWait(server.client, {
+        sessionId,
+        message: fullPrompt,
+        stallMs,
+        abortSignal: abort.signal
       });
-      if (!assessResult.ok) {
-        return { ok: false, reason: `Assess phase failed: ${assessResult.reason}`, workflowId };
+      if (result.kind === "abort") {
+        return {
+          exitReason: "timeout",
+          iterations: iteration,
+          message: `Aborted after ${iteration} iteration(s) (total timeout exceeded).`
+        };
       }
-      if (assessResult.verdict === "pass") {
-        const resolveResult = await runResolvePhase({
-          workflowId,
-          scope,
-          assessment: assessResult.artifact,
-          cwd,
-          startedAt
-        });
+      if (result.kind === "stall") {
         return {
-          ok: true,
-          workflowId,
-          goal: scope.goal,
-          durationMs: resolveResult.durationMs,
-          acknowledgedRisks: resolveResult.acknowledgedRisks
+          exitReason: "stall",
+          iterations: iteration,
+          message: `Iteration ${iteration} stalled for ${result.stallMs}ms with no idle signal.`
         };
       }
-      if (cycle < maxCycles) {
-        const elapsedSec = Math.round((Date.now() - startedAt) / 1e3);
-        process.stderr.write(
-          `
-[pilot] \u26A0\uFE0F  Assess cycle ${cycle}/${maxCycles} failed. Re-planning...
-  Gap: ${assessResult.replanGuidance}
-  Elapsed: ${elapsedSec}s
-
-`
-        );
-        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;
+      if (result.kind === "error") {
+        return {
+          exitReason: "error",
+          iterations: iteration,
+          message: `Error in iteration ${iteration}: ${result.message}`
+        };
+      }
+      const lastMessage = await _getLastAssistantMessage(server.client, sessionId);
+      if (detectSentinel(lastMessage)) {
+        return {
+          exitReason: "sentinel",
+          iterations: iteration,
+          message: `Agent emitted <autopilot-done> at iteration ${iteration}.`
+        };
+      }
+      const madeProgress = await checkProgress(opts.cwd, headBefore);
+      struggle.record(madeProgress);
+      if (struggle.isStruggling()) {
+        return {
+          exitReason: "struggle",
+          iterations: iteration,
+          message: `Agent made no filesystem progress for ${struggleThreshold} consecutive iteration(s). Stopping at iteration ${iteration}.`
+        };
       }
     }
-    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 }
-    });
-    closeFailDb();
     return {
-      ok: false,
-      reason: `Assess failed after ${maxCycles} cycles. Manual intervention required.`,
-      workflowId
+      exitReason: "max-iterations",
+      iterations: maxIterations,
+      message: `Reached maximum iterations (${maxIterations}). Stopping.`
     };
   } finally {
+    clearTimeout(timeoutHandle);
     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;
-  }
-}
 
-// 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`.",
+// src/autopilot/cli.ts
+var autopilotCmd = command({
+  name: "autopilot",
+  description: "Run the Ralph loop: send a prompt to PRIME repeatedly until it emits <autopilot-done> or a budget is exhausted.",
   args: {
-    scope: option({
-      long: "scope",
-      type: optional(stringType),
-      description: "Path to scope.json (defaults to the current scope from `pilot scope`)"
+    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).`
     })
   },
-  handler: async ({ scope }) => {
+  handler: async ({ prompt, maxIterations, timeout }) => {
     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}
+    process.stdout.write("\n\x1B[1mAutopilot \u2014 Ralph loop\x1B[0m\n");
+    process.stdout.write(`Prompt: ${prompt.slice(0, 80)}${prompt.length > 80 ? "..." : ""}
 `);
-      if (result.workflowId) {
-        process.stderr.write(`  Workflow: ${result.workflowId}
+    process.stdout.write(`Max iterations: ${maxIterations ?? MAX_ITERATIONS}
 `);
-      }
-      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}`);
-      }
-    }
-    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.",
-  args: {
-    workflow: option2({
-      long: "workflow",
-      type: optional2(stringType2),
-      description: "Workflow ID (defaults to the latest)"
-    }),
-    json: flag({
-      long: "json",
-      description: "Output JSON"
-    })
-  },
-  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.
+    process.stdout.write(`Timeout: ${((timeout ?? TIMEOUT_MS) / 36e5).toFixed(1)}h
 
-  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
+`);
+    const result = await runRalphLoop({
+      prompt,
+      cwd,
+      maxIterations: maxIterations ?? void 0,
+      timeoutMs: timeout ?? void 0
+    });
+    const icon = result.exitReason === "sentinel" ? "\x1B[32m\u2713\x1B[0m" : result.exitReason === "kill-switch" ? "\x1B[33m\u2298\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+    process.stdout.write(`
+${icon} ${result.message}
+`);
+    process.stdout.write(`  Iterations: ${result.iterations}
 
-`
-      );
+`);
+    if (result.exitReason !== "sentinel" && result.exitReason !== "kill-switch") {
       process.exit(1);
     }
-  });
-}
-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
+    process.exit(0);
   }
 });
 
 // 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";
+import { fileURLToPath as fileURLToPath3 } 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 +1785,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 +1799,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(fileURLToPath3(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 +1884,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 +1899,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,15 +1939,15 @@ 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 = command2({
   name: "install",
   description: 'Add "@glrs-dev/harness-plugin-opencode" to your opencode.json plugin array.',
   args: {
-    dryRun: flag2({
+    dryRun: flag({
       long: "dry-run",
       description: "Preview changes without writing."
     }),
-    pin: flag2({
+    pin: flag({
       long: "pin",
       description: "Pin to the current exact version (e.g. @0.1.0)."
     })
@@ -2269,11 +1956,11 @@ var installCmd = command6({
     await install({ dryRun, pin });
   }
 });
-var uninstallCmd = command6({
+var uninstallCmd = command2({
   name: "uninstall",
   description: 'Remove "@glrs-dev/harness-plugin-opencode" from your opencode.json plugin array.',
   args: {
-    dryRun: flag2({
+    dryRun: flag({
       long: "dry-run",
       description: "Preview changes without writing."
     })
@@ -2282,7 +1969,7 @@ var uninstallCmd = command6({
     uninstall({ dryRun });
   }
 });
-var doctorCmd = command6({
+var doctorCmd = command2({
   name: "doctor",
   description: "Check installation health (OpenCode CLI, plugin registration, MCP backends).",
   args: {},
@@ -2290,22 +1977,22 @@ var doctorCmd = command6({
     doctor();
   }
 });
-var planCheckCmd = command6({
+var planCheckCmd = command2({
   name: "plan-check",
   description: "Parse a plan file's plan-state fence (legacy markdown plans).",
   args: {
-    run: option3({
+    run: option2({
       long: "run",
-      type: optional3(string2),
+      type: optional2(string),
       description: "Print verify commands for pending items, one per line."
     }),
-    check: option3({
+    check: option2({
       long: "check",
-      type: optional3(string2),
+      type: optional2(string),
       description: "Structural validation; exits 1 if any item is invalid."
     }),
-    rest: restPositionals2({
-      type: string2,
+    rest: restPositionals({
+      type: string,
       displayName: "plan-path",
       description: "Path to a plan markdown file. Required unless --run / --check is given."
     })
@@ -2322,7 +2009,7 @@ var planCheckCmd = command6({
     planCheck(legacy);
   }
 });
-var planDirCmd = command6({
+var planDirCmd = command2({
   name: "plan-dir",
   description: "Print the repo-shared plan directory for the current worktree (resolves + creates + migrates legacy).",
   args: {},
@@ -2341,15 +2028,15 @@ var planDirCmd = command6({
     }
   }
 });
-var installPluginCmd = command6({
+var installPluginCmd = command2({
   name: "install-plugin",
   description: 'Add "@glrs-dev/harness-plugin-opencode" to your opencode.json plugin array.',
   args: {
-    dryRun: flag2({
+    dryRun: flag({
       long: "dry-run",
       description: "Preview changes without writing."
     }),
-    pin: flag2({
+    pin: flag({
       long: "pin",
       description: "Pin to the current exact version (e.g. @0.1.0)."
     })
@@ -2358,7 +2045,7 @@ var installPluginCmd = command6({
     await install({ dryRun, pin });
   }
 });
-var cli = subcommands2({
+var cli = subcommands({
   name: "glrs-oc",
   description: "OpenCode agent harness CLI.",
   version: VERSION,
@@ -2369,7 +2056,7 @@ var cli = subcommands2({
     doctor: doctorCmd,
     "plan-check": planCheckCmd,
     "plan-dir": planDirCmd,
-    pilot: pilotSubcommand
+    autopilot: autopilotCmd
   }
 });
 var printUpdate = startUpdateCheck();