@glrs-dev/cli 0.1.1 → 1.0.0

package/dist/vendor/harness-opencode/dist/chunk-BKTFWXLG.js

@@ -0,0 +1,204 @@
+// src/pilot/paths.ts
+import { promises as fs2 } from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+
+// src/plan-paths.ts
+import { execFile } from "child_process";
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+function execFileP(file, args, opts = {}) {
+  const { cwd, timeoutMs = 5e3 } = opts;
+  return new Promise((resolve2, reject) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    execFile(
+      file,
+      args,
+      { signal: controller.signal, cwd, encoding: "utf8" },
+      (err, stdout) => {
+        clearTimeout(timer);
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve2(stdout ?? "");
+      }
+    );
+  });
+}
+function expandTilde(p) {
+  if (p === "~") return os.homedir();
+  if (p.startsWith("~/")) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+async function getRepoFolder(worktreeDir) {
+  let stdout;
+  try {
+    stdout = await execFileP(
+      "git",
+      ["rev-parse", "--git-common-dir"],
+      { cwd: worktreeDir }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error running `git rev-parse --git-common-dir`";
+    throw new Error(
+      `getRepoFolder: failed to resolve git-common-dir for ${worktreeDir}: ${msg}`
+    );
+  }
+  const gitCommonDir = stdout.trim();
+  if (!gitCommonDir) {
+    throw new Error(
+      `getRepoFolder: \`git rev-parse --git-common-dir\` returned empty for ${worktreeDir}`
+    );
+  }
+  const absCommonDir = path.isAbsolute(gitCommonDir) ? gitCommonDir : path.resolve(worktreeDir, gitCommonDir);
+  const repoRoot = path.dirname(absCommonDir);
+  return path.basename(repoRoot);
+}
+async function getPlanDir(worktreeDir) {
+  const override = process.env.GLORIOUS_PLAN_DIR;
+  const base = override ? expandTilde(override) : path.join(os.homedir(), ".glorious", "opencode");
+  const repoFolder = await getRepoFolder(worktreeDir);
+  const planDir = path.join(base, repoFolder, "plans");
+  await fs.mkdir(planDir, { recursive: true });
+  return planDir;
+}
+async function migratePlans(worktreeDir, planDir) {
+  const oldDir = path.join(worktreeDir, ".agent", "plans");
+  const marker = path.join(oldDir, ".migrated");
+  try {
+    await fs.stat(oldDir);
+  } catch {
+    return;
+  }
+  try {
+    await fs.stat(marker);
+    return;
+  } catch {
+  }
+  let entries;
+  try {
+    entries = await fs.readdir(oldDir);
+  } catch {
+    return;
+  }
+  const planFiles = entries.filter(
+    (name) => name.endsWith(".md") && !name.startsWith(".")
+  );
+  await fs.mkdir(planDir, { recursive: true });
+  for (const name of planFiles) {
+    const src = path.join(oldDir, name);
+    const dst = path.join(planDir, name);
+    let dstExists = false;
+    try {
+      await fs.stat(dst);
+      dstExists = true;
+    } catch {
+      dstExists = false;
+    }
+    if (!dstExists) {
+      await fs.rename(src, dst);
+      continue;
+    }
+    const [srcBuf, dstBuf] = await Promise.all([
+      fs.readFile(src),
+      fs.readFile(dst)
+    ]);
+    if (srcBuf.equals(dstBuf)) {
+      await fs.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 fs.writeFile(marker, "");
+}
+
+// src/pilot/paths.ts
+function expandTilde2(p) {
+  if (p === "~") return os2.homedir();
+  if (p.startsWith("~/")) return path2.join(os2.homedir(), p.slice(2));
+  return p;
+}
+function resolveBaseDir() {
+  const pilotEnv = process.env.GLORIOUS_PILOT_DIR;
+  if (pilotEnv) return expandTilde2(pilotEnv);
+  const planEnv = process.env.GLORIOUS_PLAN_DIR;
+  if (planEnv) {
+    return path2.dirname(expandTilde2(planEnv));
+  }
+  return path2.join(os2.homedir(), ".glorious", "opencode");
+}
+async function getPilotDir(cwd) {
+  const base = resolveBaseDir();
+  const repoFolder = await getRepoFolder(cwd);
+  const dir = path2.join(base, repoFolder, "pilot");
+  await fs2.mkdir(dir, { recursive: true });
+  return dir;
+}
+async function getPlansDir(cwd) {
+  const pilot = await getPilotDir(cwd);
+  const dir = path2.join(pilot, "plans");
+  await fs2.mkdir(dir, { recursive: true });
+  return dir;
+}
+async function getRunDir(cwd, runId) {
+  if (!isSafeRunId(runId)) {
+    throw new Error(
+      `getRunDir: runId ${JSON.stringify(runId)} is not a safe filesystem segment`
+    );
+  }
+  const pilot = await getPilotDir(cwd);
+  const dir = path2.join(pilot, "runs", runId);
+  await fs2.mkdir(dir, { recursive: true });
+  return dir;
+}
+async function getStateDbPath(cwd, runId) {
+  const runDir = await getRunDir(cwd, runId);
+  return path2.join(runDir, "state.db");
+}
+async function getWorkerJsonlPath(cwd, runId, n) {
+  const runDir = await getRunDir(cwd, runId);
+  const workersDir = path2.join(runDir, "workers");
+  await fs2.mkdir(workersDir, { recursive: true });
+  const padded = n.toString().padStart(2, "0");
+  return path2.join(workersDir, `${padded}.jsonl`);
+}
+async function getTaskJsonlPath(cwd, runId, taskId) {
+  if (!isSafeRunId(runId)) {
+    throw new Error(
+      `getTaskJsonlPath: runId ${JSON.stringify(runId)} is not a safe filesystem segment`
+    );
+  }
+  if (!isSafeTaskId(taskId)) {
+    throw new Error(
+      `getTaskJsonlPath: taskId ${JSON.stringify(taskId)} is not a safe filesystem segment`
+    );
+  }
+  const runDir = await getRunDir(cwd, runId);
+  const taskDir = path2.join(runDir, "tasks", taskId);
+  await fs2.mkdir(taskDir, { recursive: true });
+  return path2.join(taskDir, "session.jsonl");
+}
+function isSafeRunId(runId) {
+  return /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(runId);
+}
+function isSafeTaskId(taskId) {
+  return /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(taskId);
+}
+
+export {
+  getPlanDir,
+  migratePlans,
+  resolveBaseDir,
+  getPilotDir,
+  getPlansDir,
+  getRunDir,
+  getStateDbPath,
+  getWorkerJsonlPath,
+  getTaskJsonlPath
+};

package/dist/vendor/harness-opencode/dist/{chunk-XCZ3NOXR.js → chunk-CZMAJISX.js}

@@ -59,6 +59,9 @@ var agentsMdWriterPrompt = readPrompt("agents-md-writer.md");
 var pilotBuilderPrompt = readPrompt("pilot-builder.md");
 var pilotPlannerPrompt = readPrompt("pilot-planner.md");
 var researchPrompt = readPrompt("research.md");
+var researchWebPrompt = readPrompt("research-web.md");
+var researchLocalPrompt = readPrompt("research-local.md");
+var researchAutoPrompt = readPrompt("research-auto.md");
 function stripFrontmatter(md) {
   if (!md.startsWith("---")) return md;
   const end = md.indexOf("\n---", 3);
@@ -557,6 +560,9 @@ var AGENT_TIERS = {
   "gap-analyzer": "deep",
   "pilot-planner": "deep",
   research: "deep",
+  "research-web": "deep",
+  "research-local": "deep",
+  "research-auto": "deep",
   build: "mid",
   "qa-reviewer": "mid",
   "docs-maintainer": "mid",
@@ -641,6 +647,28 @@ function createAgents() {
       model: "anthropic/claude-opus-4-7",
       temperature: 0.3,
       permission: RESEARCH_PERMISSIONS
+    }),
+    // Research subagents — thin shims that load the bundled skills
+    "research-web": agentFromPrompt(researchWebPrompt, {
+      description: "Research orchestrator subagent \u2014 Multi-agent web research orchestrator. Decomposes a research question into parallel agent workstreams, launches them, monitors progress, and synthesizes results. Use when user says 'research this topic', 'I need to understand', 'deep dive into', 'investigate the market for', 'what do we know about'. Provide the research topic and context.",
+      mode: "all",
+      model: "anthropic/claude-opus-4-7",
+      temperature: 0.3,
+      permission: RESEARCH_PERMISSIONS
+    }),
+    "research-local": agentFromPrompt(researchLocalPrompt, {
+      description: "Research orchestrator subagent \u2014 Deep codebase research using parallel Explore subagents. Decomposes a question about the local codebase into research tasks, launches parallel explorations, reviews for gaps, iterates, and synthesizes findings with specific file paths and line numbers. Use when user says 'how does X work in this codebase', 'where is Y implemented', 'trace the data flow for Z', 'what patterns does this repo use', 'explain the architecture of'. Provide the research topic as arguments.",
+      mode: "all",
+      model: "anthropic/claude-opus-4-7",
+      temperature: 0.3,
+      permission: RESEARCH_PERMISSIONS
+    }),
+    "research-auto": agentFromPrompt(researchAutoPrompt, {
+      description: "Research orchestrator subagent \u2014 Autonomous experimentation skill. Agent interviews the user, sets up a lab, then explores freely (think, test, reflect) until stopped or a target is hit. Works for any domain where you can measure or evaluate a result. Use when user says 'optimize this', 'experiment with', 'find the best approach', 'iterate on', 'research mode'. Do NOT use for binary validation tests (use /spec-lab instead). Based on ResearcherSkill v1.4.4 by krzysztofdudek.",
+      mode: "all",
+      model: "anthropic/claude-opus-4-7",
+      temperature: 0.3,
+      permission: RESEARCH_PERMISSIONS
     })
   };
 }

package/dist/vendor/harness-opencode/dist/chunk-KB7M7JXU.js

@@ -0,0 +1,145 @@
+// src/pilot/worker/safety-gate.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import picomatch from "picomatch";
+var execFileP = promisify(execFile);
+var SAFETY_GATE_TOLERATE = [
+  // opencode plugin installer churn. opencode upgrades its own plugin
+  // dependency in the background, which bumps the pinned version in
+  // .opencode/package.json + .opencode/package-lock.json. Users don't
+  // author those edits; refusing to start pilot because of them is a
+  // consistent friction.
+  ".opencode/**",
+  // Next.js — `next build` regenerates this every run, often outside
+  // a pilot session.
+  "**/next-env.d.ts",
+  // Next.js app-router generated types.
+  "**/.next/types/**",
+  "**/.next/dev/types/**",
+  // TypeScript project-reference build info — tsc writes these.
+  "**/*.tsbuildinfo",
+  // Snapshot test files rewritten by `vitest -u` / `jest -u`.
+  "**/__snapshots__/**",
+  "**/*.snap"
+];
+async function git(cwd, args) {
+  for (const a of args) {
+    if (a.includes("\0")) {
+      throw new Error(`git arg contains null byte: ${JSON.stringify(a)}`);
+    }
+  }
+  try {
+    const { stdout, stderr } = await execFileP("git", args, {
+      cwd,
+      timeout: 1e4,
+      maxBuffer: 1 << 20
+    });
+    return { stdout: stdout.toString(), stderr: stderr.toString(), ok: true };
+  } catch (err) {
+    const e = err;
+    return {
+      stdout: (e.stdout ?? "").toString(),
+      stderr: (e.stderr ?? "").toString(),
+      ok: false
+    };
+  }
+}
+async function headSha(cwd) {
+  const r = await git(cwd, ["rev-parse", "HEAD"]);
+  if (!r.ok) throw new Error(`git rev-parse HEAD failed: ${r.stderr.trim()}`);
+  return r.stdout.trim();
+}
+var FORBIDDEN_BRANCHES = /* @__PURE__ */ new Set(["main", "master"]);
+function parsePorcelainPaths(stdout) {
+  const paths = [];
+  for (const line of stdout.split("\n")) {
+    if (line.length < 4) continue;
+    let rest = line.slice(3);
+    const arrow = rest.indexOf(" -> ");
+    if (arrow !== -1) rest = rest.slice(arrow + 4);
+    if (rest.startsWith('"') && rest.endsWith('"')) {
+      rest = rest.slice(1, -1);
+    }
+    paths.push(rest);
+  }
+  return paths;
+}
+async function checkCwdSafety(cwd) {
+  const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (!inside.ok || inside.stdout.trim() !== "true") {
+    return {
+      ok: false,
+      reason: `not inside a git worktree: ${cwd}`
+    };
+  }
+  const branchRes = await git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (!branchRes.ok) {
+    return {
+      ok: false,
+      reason: `cannot determine current branch: ${branchRes.stderr.trim()}`
+    };
+  }
+  const branch = branchRes.stdout.trim();
+  if (FORBIDDEN_BRANCHES.has(branch)) {
+    return {
+      ok: false,
+      reason: `refuse to run on protected branch: ${branch}. Switch to a feature branch first.`
+    };
+  }
+  const defaultRes = await git(cwd, [
+    "symbolic-ref",
+    "--short",
+    "refs/remotes/origin/HEAD"
+  ]);
+  if (defaultRes.ok) {
+    const remoteDefault = defaultRes.stdout.trim().replace(/^origin\//, "");
+    if (remoteDefault && branch === remoteDefault) {
+      return {
+        ok: false,
+        reason: `refuse to run on the remote's default branch: ${branch}. Switch to a feature branch first.`
+      };
+    }
+  }
+  const statusRes = await git(cwd, ["status", "--porcelain"]);
+  if (!statusRes.ok) {
+    return {
+      ok: false,
+      reason: `git status failed: ${statusRes.stderr.trim()}`
+    };
+  }
+  const rawStdout = statusRes.stdout.replace(/\n$/, "");
+  if (rawStdout.length === 0) {
+    return { ok: true, warnings: [] };
+  }
+  const paths = parsePorcelainPaths(rawStdout);
+  const matchTolerate = picomatch([...SAFETY_GATE_TOLERATE], { dot: true });
+  const tolerated = [];
+  const genuine = [];
+  for (const p of paths) {
+    if (matchTolerate(p)) tolerated.push(p);
+    else genuine.push(p);
+  }
+  if (genuine.length > 0) {
+    const lines = rawStdout.split("\n").slice(0, 10).map((s) => "  " + s).join("\n");
+    return {
+      ok: false,
+      reason: `working tree is dirty; pilot refuses to run on uncommitted changes.
+Commit, stash, or discard them, then re-run.
+First 10 lines of git status --porcelain:
+${lines}`
+    };
+  }
+  const preview = tolerated.slice(0, 5);
+  const suffix = tolerated.length > preview.length ? ` (+${tolerated.length - preview.length} more)` : "";
+  const warnings = [
+    `working tree has ${tolerated.length} modified file(s) in framework-owned paths; treating tree as clean:
+` + preview.map((p) => `  ${p}`).join("\n") + suffix
+  ];
+  return { ok: true, warnings };
+}
+
+export {
+  SAFETY_GATE_TOLERATE,
+  headSha,
+  checkCwdSafety
+};

package/dist/vendor/harness-opencode/dist/chunk-RNRCXQ65.js

@@ -0,0 +1,56 @@
+// src/pilot/mcp/session-registry.ts
+import * as fs from "fs";
+import * as path from "path";
+import { promisify } from "util";
+var writeFile2 = promisify(fs.writeFile);
+var rename2 = promisify(fs.rename);
+var unlink2 = promisify(fs.unlink);
+var mkdir2 = promisify(fs.mkdir);
+function getSessionsPath(runDir) {
+  return path.join(runDir, "sessions.json");
+}
+function readSessions(runDir) {
+  const sessionsPath = getSessionsPath(runDir);
+  try {
+    const content = fs.readFileSync(sessionsPath, "utf8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null) {
+      return {};
+    }
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+async function registerSession(args) {
+  const { runDir, sessionId, runId, taskId } = args;
+  const sessionsPath = getSessionsPath(runDir);
+  await mkdir2(runDir, { recursive: true });
+  const current = readSessions(runDir);
+  const updated = {
+    ...current,
+    [sessionId]: { runId, taskId }
+  };
+  const tempPath = `${sessionsPath}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 8)}`;
+  await writeFile2(tempPath, JSON.stringify(updated, null, 2), "utf8");
+  await rename2(tempPath, sessionsPath);
+}
+async function unregisterSession(args) {
+  const { runDir, sessionId } = args;
+  const sessionsPath = getSessionsPath(runDir);
+  const current = readSessions(runDir);
+  if (!(sessionId in current)) {
+    return;
+  }
+  const { [sessionId]: _, ...rest } = current;
+  const tempPath = `${sessionsPath}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 8)}`;
+  await writeFile2(tempPath, JSON.stringify(rest, null, 2), "utf8");
+  await rename2(tempPath, sessionsPath);
+}
+
+export {
+  getSessionsPath,
+  readSessions,
+  registerSession,
+  unregisterSession
+};

package/dist/vendor/harness-opencode/dist/{chunk-VVMP6QWS.js → chunk-WBBN7OVN.js}

@@ -257,7 +257,7 @@ async function requirePlugin() {
     );
     process.exit(1);
   }
-  const { install: install2 } = await import("./install-4EYR56OR.js");
+  const { install: install2 } = await import("./install-X5KEANRB.js");
   await install2({ nonInteractive: true });
 }
 
@@ -505,6 +505,116 @@ function migrateHarnessKeyToPluginOptions(configPath) {
   } 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_NAME2 || String(name ?? "").startsWith(`${PLUGIN_NAME2}@`);
+    });
+    if (pluginIdx < 0) {
+      return { changed: false };
+    }
+    const current = config.plugin[pluginIdx];
+    const existingName = typeof current === "string" ? current : Array.isArray(current) ? current[0] : PLUGIN_NAME2;
+    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 };
+  }
+}
 async function install(opts = {}) {
   const { dryRun = false, pin = false, nonInteractive = false } = opts;
   const configPath = getOpencodeConfigPath2();
@@ -533,6 +643,10 @@ ${c.bold}${c.blue}@glrs-dev/harness-plugin-opencode${c.reset} setup
   if (existingMcps.size > 0) {
     ok(`MCPs: ${[...existingMcps].join(", ")} enabled`);
   }
+  let reconfigureModels = false;
+  let reconfigureMcps = false;
+  let newModelsValue = null;
+  let newMcpEnabledSet = /* @__PURE__ */ new Set();
   if (hasPlugin && (existingProvider || hasModels)) {
     const unconfiguredMcps = MCP_TOGGLES.filter(
       (t) => !existingMcps.has(t.name) && !existing?.mcp?.[t.name]
@@ -544,8 +658,20 @@ ${c.bold}${c.blue}@glrs-dev/harness-plugin-opencode${c.reset} setup
         0
       );
       if (reconfigure === 1) {
+        reconfigureModels = true;
         hasModels = false;
-      } else if (unconfiguredMcps.length === 0) {
+      }
+      if (existingMcps.size > 0) {
+        const reconfigureMcpChoice = await promptChoice(
+          "  Reconfigure MCPs?",
+          ["No, keep current config", "Yes, reconfigure MCPs"],
+          0
+        );
+        if (reconfigureMcpChoice === 1) {
+          reconfigureMcps = true;
+        }
+      }
+      if (!reconfigureModels && !reconfigureMcps && unconfiguredMcps.length === 0) {
         console.log(`
 ${c.bold}Ready.${c.reset} Run ${c.green}opencode${c.reset} to start.
 `);
@@ -632,6 +758,11 @@ ${c.bold}Ready.${c.reset} Run ${c.green}opencode${c.reset} to start.
         mid: [preset.mid],
         fast: [preset.fast]
       };
+      newModelsValue = {
+        deep: [preset.deep],
+        mid: [preset.mid],
+        fast: [preset.fast]
+      };
       ok(`Models configured`);
     } else if (!pluginOpts._skipModels) {
       info("Enter model IDs in <provider>/<model-id> format (e.g. amazon-bedrock/global.anthropic.claude-opus-4-7)");
@@ -645,6 +776,11 @@ ${c.bold}Ready.${c.reset} Run ${c.green}opencode${c.reset} to start.
           mid: [midModel || deepModel],
           fast: [fastModel || midModel || deepModel]
         };
+        newModelsValue = {
+          deep: [deepModel],
+          mid: [midModel || deepModel],
+          fast: [fastModel || midModel || deepModel]
+        };
         ok("Models: custom");
       } else {
         ok("Models: OpenCode defaults");
@@ -653,6 +789,22 @@ ${c.bold}Ready.${c.reset} Run ${c.green}opencode${c.reset} to start.
     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();
+  }
   const pluginValue = Object.keys(pluginOpts).length > 0 ? [pluginEntry, pluginOpts] : pluginEntry;
   const config = {
     $schema: "https://opencode.ai/config.json",
@@ -683,6 +835,12 @@ ${c.bold}Ready.${c.reset} Run ${c.green}opencode${c.reset} to start.
       console.log();
     }
   }
+  if (reconfigureModels && newModelsValue) {
+    writePluginOption(configPath, "models", newModelsValue, { dryRun });
+  }
+  if (reconfigureMcps) {
+    writeMcpToggles(configPath, newMcpEnabledSet, { dryRun });
+  }
   if (!fs3.existsSync(configPath)) {
     if (dryRun) {
       info(`[dry-run] Would create ${configPath}`);
@@ -727,5 +885,7 @@ ${c.bold}Ready.${c.reset} Run ${c.green}opencode${c.reset} to start.
 export {
   requirePlugin,
   MODEL_PRESETS,
+  writePluginOption,
+  writeMcpToggles,
   install
 };