opencode-auto-agent 1.0.0 → 1.2.0

package/src/commands/run.js

@@ -1,106 +1,201 @@
 /**
- * run command — start the orchestrator.
+ * run command — start the orchestrator via Ralphy + OpenCode.
  *
  * Flow:
- *  1. Load config.json
- *  2. Assemble runtime context (preset rules + base rules + docs)
- *  3. Write assembled context to .ai-starter-kit/context/
- *  4. Invoke Ralphy with --opencode engine against the PRD/task file
- *  5. Ralphy drives OpenCode, which loads the orchestrator agent and delegates
+ *  1. Validate prerequisites (require Ralphy for this command)
+ *  2. Load config.json (v0.2.0 schema with model mappings)
+ *  3. Assemble runtime context (preset rules + base rules + docs + model info)
+ *  4. Write assembled context to .opencode/context/
+ *  5. Show run summary with TUI
+ *  6. Invoke Ralphy with --opencode engine against the PRD/task file
+ *  7. Ralphy drives OpenCode, which loads the orchestrator agent and delegates
  */
 
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { execSync, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 
-import { SCAFFOLD_DIR, CONFIG_FILE, DIRS } from "../lib/constants.js";
+import {
+  SCAFFOLD_DIR, CONFIG_FILE, DIRS, AGENTS, AGENT_ROLES,
+} from "../lib/constants.js";
 import { readJsonSync, readTextSync, writeTextSync } from "../lib/fs-utils.js";
+import { validateAndReport } from "../lib/prerequisites.js";
+import {
+  banner, section, status, kv, error, warn, success, c, table, hr,
+} from "../lib/ui.js";
 
+/**
+ * @param {string} targetDir - Project root
+ * @param {Object} flags
+ * @param {string} [flags.engine] - Ralphy engine override
+ * @param {boolean} [flags.dryRun] - Assemble context but don't launch Ralphy
+ * @param {boolean} [flags.verbose] - Extra output
+ */
 export async function run(targetDir, flags = {}) {
+  banner("OpenCode Auto-Agent Runner", "Starting the AI agent orchestrator");
+
+  // ── 1. Prerequisites ──────────────────────────────────────────────────────
+  section("Prerequisites");
+  const prereqResult = validateAndReport({ requireRalphy: true, abortOnFail: true });
+  console.log();
+
+  // ── 2. Load config ────────────────────────────────────────────────────────
+  section("Configuration");
   const scaffoldDir = join(targetDir, SCAFFOLD_DIR);
   const configPath = join(scaffoldDir, CONFIG_FILE);
-
-  // 1. Load config
   const config = readJsonSync(configPath);
+
   if (!config) {
-    console.error(`[run] No config found at ${configPath}. Run 'opencode-auto-agent init' first.`);
+    error(
+      `No config found at ${SCAFFOLD_DIR}/${CONFIG_FILE}.`,
+      "Run 'npx opencode-auto-agent init' first."
+    );
     process.exit(1);
   }
 
-  console.log(`[run] Preset: ${config.preset}`);
-  console.log(`[run] Engine: ${flags.engine || config.engine || "opencode"}`);
+  const engine = flags.engine || config.engine || "opencode";
+  const preset = config.preset || "java";
 
-  // 2. Assemble runtime context
-  console.log("[run] Assembling runtime context...");
-  const context = assembleContext(targetDir, config);
-  const contextFile = join(scaffoldDir, DIRS.context, "runtime-context.md");
-  writeTextSync(contextFile, context);
-  console.log(`[run] Context written to ${DIRS.context}/runtime-context.md`);
+  kv("Preset", preset);
+  kv("Engine", engine);
+  kv("Schema version", config.version || "unknown");
 
-  // 3. Determine task file
+  // Show model assignments
+  if (config.models) {
+    console.log();
+    table(
+      ["Agent", "Model", "Mode"],
+      AGENTS.filter((role) => config.agents?.[role]?.enabled !== false).map((role) => [
+        role,
+        c.cyan(config.models[role] || "(default)"),
+        c.gray(AGENT_ROLES[role]?.mode || "subagent"),
+      ])
+    );
+  }
+
+  // ── 3. Validate task file ─────────────────────────────────────────────────
+  section("Task File");
   const tasksPath = join(targetDir, config.tasksPath || "PRD.md");
+
   if (!existsSync(tasksPath)) {
-    console.error(`[run] Task file not found: ${tasksPath}`);
-    console.error(`[run] Create a PRD.md or update tasksPath in config.json.`);
+    error(
+      `Task file not found: ${config.tasksPath || "PRD.md"}`,
+      "Create a PRD.md or update 'tasksPath' in config.json."
+    );
     process.exit(1);
   }
 
-  // 4. Invoke Ralphy
-  const engine = flags.engine || config.engine || "opencode";
+  const taskContent = readTextSync(tasksPath);
+  const taskLines = taskContent ? taskContent.split("\n").length : 0;
+  status("pass", `Task file: ${config.tasksPath || "PRD.md"}`, `${taskLines} lines`);
+
+  // ── 4. Assemble runtime context ───────────────────────────────────────────
+  section("Context Assembly");
+  const context = assembleContext(targetDir, config);
+  const contextFile = join(scaffoldDir, DIRS.context, "runtime-context.md");
+  writeTextSync(contextFile, context);
+  status("pass", "Runtime context assembled", `${DIRS.context}/runtime-context.md`);
+
+  // ── 5. Dry run check ─────────────────────────────────────────────────────
+  if (flags.dryRun) {
+    success("Dry run complete. Context written but Ralphy not launched.");
+    console.log(`  ${c.gray("Context file:")} ${contextFile}`);
+    console.log();
+    return;
+  }
+
+  // ── 6. Launch Ralphy ──────────────────────────────────────────────────────
+  section("Launching Orchestrator");
+  console.log();
+
   const ralphyArgs = [
     "--prd", tasksPath,
     `--${engine}`,
   ];
 
-  console.log(`[run] Starting Ralphy: ralphy ${ralphyArgs.join(" ")}`);
-  console.log("[run] ─────────────────────────────────────────────");
-
-  const child = spawn("ralphy", ralphyArgs, {
-    cwd: targetDir,
-    stdio: "inherit",
-    shell: true,
-    env: {
-      ...process.env,
-      // Pass context location to OpenCode via env
-      AISK_CONTEXT_DIR: join(scaffoldDir, DIRS.context),
-      AISK_CONFIG_PATH: configPath,
-    },
-  });
+  status("arrow", `ralphy ${ralphyArgs.join(" ")}`);
+  hr();
+  console.log();
 
-  child.on("close", (code) => {
-    if (code === 0) {
-      console.log("\n[run] Orchestrator completed successfully.");
-    } else {
-      console.error(`\n[run] Orchestrator exited with code ${code}.`);
-      process.exit(code);
-    }
-  });
+  return new Promise((resolve, reject) => {
+    const child = spawn("ralphy", ralphyArgs, {
+      cwd: targetDir,
+      stdio: "inherit",
+      shell: true,
+      env: {
+        ...process.env,
+        // Pass context location to OpenCode via env
+        AISK_CONTEXT_DIR: join(scaffoldDir, DIRS.context),
+        AISK_CONFIG_PATH: configPath,
+        // Pass model info as env vars for downstream use
+        AISK_ORCHESTRATOR_MODEL: config.models?.orchestrator || "",
+        AISK_PRESET: preset,
+      },
+    });
 
-  child.on("error", (err) => {
-    if (err.code === "ENOENT") {
-      console.error("[run] 'ralphy' CLI not found. Install it:");
-      console.error("  npm install -g ralphy-cli");
-    } else {
-      console.error("[run] Failed to start Ralphy:", err.message);
-    }
-    process.exit(1);
+    child.on("close", (code) => {
+      console.log();
+      hr();
+      if (code === 0) {
+        success("Orchestrator completed successfully.");
+      } else {
+        error(
+          `Orchestrator exited with code ${code}.`,
+          "Check the output above for details."
+        );
+        process.exit(code);
+      }
+      resolve();
+    });
+
+    child.on("error", (err) => {
+      console.log();
+      if (err.code === "ENOENT") {
+        error(
+          "'ralphy' CLI not found.",
+          "Install: npm install -g ralphy-cli"
+        );
+      } else {
+        error(
+          `Failed to start Ralphy: ${err.message}`,
+          "Ensure ralphy is installed and accessible."
+        );
+      }
+      process.exit(1);
+    });
   });
 }
 
-// ── context assembly ───────────────────────────────────────────────────────
+// ── Context assembly ───────────────────────────────────────────────────────
 
 function assembleContext(targetDir, config) {
   const scaffoldDir = join(targetDir, SCAFFOLD_DIR);
   const sections = [];
 
   sections.push("# Runtime Context (auto-generated)\n");
+  sections.push(`> Generated by opencode-auto-agent at ${new Date().toISOString()}`);
   sections.push(`Preset: **${config.preset}**`);
-  sections.push(`Workflow: ${(config.orchestrator?.workflowSteps || []).join(" → ")}\n`);
+  sections.push(`Engine: **${config.engine || "opencode"}**`);
+  sections.push(`Workflow: ${(config.orchestrator?.workflowSteps || []).join(" \u2192 ")}\n`);
+
+  // Model assignments
+  if (config.models) {
+    sections.push("## Agent Model Assignments\n");
+    sections.push("| Agent | Model | Mode |");
+    sections.push("| --- | --- | --- |");
+    for (const role of AGENTS) {
+      if (config.agents?.[role]?.enabled === false) continue;
+      const model = config.models[role] || "(default)";
+      const mode = AGENT_ROLES[role]?.mode || "subagent";
+      sections.push(`| ${role} | ${model} | ${mode} |`);
+    }
+    sections.push("");
+  }
 
   // Base rules
   const rulesDir = join(scaffoldDir, DIRS.rules);
   if (existsSync(rulesDir)) {
-    for (const file of readdirSync(rulesDir).filter((f) => f.endsWith(".md"))) {
+    for (const file of safeReaddir(rulesDir).filter((f) => f.endsWith(".md")).sort()) {
       const content = readTextSync(join(rulesDir, file));
       if (content) {
         sections.push(`## Rules: ${file}\n${content}`);
@@ -114,7 +209,7 @@ function assembleContext(targetDir, config) {
   if (presetContent) {
     sections.push(`## Preset: ${config.preset}\n${presetContent}`);
   } else {
-    sections.push(`## Preset: ${config.preset}\n(No preset file found at ${presetFile})`);
+    sections.push(`## Preset: ${config.preset}\n(No preset file found)`);
   }
 
   // Repo docs (if configured and present)
@@ -122,7 +217,7 @@ function assembleContext(targetDir, config) {
   if (existsSync(docsPath)) {
     sections.push(`## Project Documentation\nDocs location: ${docsPath}`);
     try {
-      const docFiles = readdirSync(docsPath).filter((f) => f.endsWith(".md"));
+      const docFiles = safeReaddir(docsPath).filter((f) => f.endsWith(".md"));
       for (const file of docFiles.slice(0, 10)) {
         const content = readTextSync(join(docsPath, file));
         if (content) {
@@ -134,14 +229,40 @@ function assembleContext(targetDir, config) {
     }
   }
 
+  // Instructions (from config)
+  if (Array.isArray(config.instructions) && config.instructions.length > 0) {
+    sections.push("## Instructions\n");
+    for (const instrPath of config.instructions) {
+      const resolved = join(targetDir, instrPath);
+      if (existsSync(resolved)) {
+        const content = readTextSync(resolved);
+        if (content) {
+          sections.push(`### ${instrPath}\n${content.slice(0, 3000)}`);
+        }
+      } else {
+        sections.push(`- ${instrPath} (not found)`);
+      }
+    }
+  }
+
   // Agent manifest
   sections.push("## Agent Team");
   const agentsDir = join(scaffoldDir, DIRS.agents);
   if (existsSync(agentsDir)) {
-    for (const file of readdirSync(agentsDir).filter((f) => f.endsWith(".md")).sort()) {
-      sections.push(`- ${file.replace(".md", "")}`);
+    for (const file of safeReaddir(agentsDir).filter((f) => f.endsWith(".md")).sort()) {
+      const role = file.replace(".md", "");
+      const model = config.models?.[role] || "default";
+      sections.push(`- **${role}** \u2014 ${AGENT_ROLES[role]?.description || role} (model: ${model})`);
     }
   }
 
   return sections.join("\n\n");
 }
+
+function safeReaddir(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}

package/src/commands/setup.js

@@ -1,40 +1,340 @@
 /**
- * setup command — apply or switch a preset.
+ * setup command — switch presets and optionally reconfigure model assignments.
  *
- * This updates config.json and regenerates the runtime context references.
+ * Updates both .opencode/config.json and the project-root opencode.json
+ * to keep them in sync. Can also update agent .md frontmatter with new models.
+ *
+ * Flow:
+ *  1. Verify scaffold exists
+ *  2. Load current config
+ *  3. Validate or interactively select preset
+ *  4. Optionally reconfigure model assignments
+ *  5. Write updated config.json
+ *  6. Write updated opencode.json
+ *  7. Update agent .md frontmatter (if models changed)
  */
 
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  SCAFFOLD_DIR, CONFIG_FILE, PRESETS, AGENTS, AGENT_ROLES,
+  DIRS, DEFAULT_MODEL_MAP, WORKFLOW_STEPS, SCHEMA_VERSION,
+} from "../lib/constants.js";
+import { readJsonSync, writeJsonSync, writeTextSync } from "../lib/fs-utils.js";
+import { discoverModelsInteractive, findModel, groupByProvider } from "../lib/models.js";
+import {
+  banner, section, status, kv, success, error, warn, c,
+  select, confirm, table, boxList,
+} from "../lib/ui.js";
 
-import { SCAFFOLD_DIR, CONFIG_FILE, PRESETS } from "../lib/constants.js";
-import { readJsonSync, writeJsonSync, readTextSync } from "../lib/fs-utils.js";
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const TEMPLATES_ROOT = resolve(__dirname, "..", "..", "templates");
+
+/**
+ * @param {string} targetDir - Project root
+ * @param {string|null} preset - Preset name (null triggers interactive selection)
+ * @param {Object} opts
+ * @param {boolean} [opts.models] - Also reconfigure model assignments
+ * @param {boolean} [opts.nonInteractive] - Skip prompts, use defaults
+ */
+export async function setup(targetDir, preset, { models: reconfigModels, nonInteractive } = {}) {
+  banner("OpenCode Auto-Agent Setup", "Switch preset or reconfigure models");
 
-export async function setup(targetDir, preset) {
   const scaffoldDir = join(targetDir, SCAFFOLD_DIR);
   const configPath = join(scaffoldDir, CONFIG_FILE);
 
+  // ── 1. Verify scaffold ────────────────────────────────────────────────────
   if (!existsSync(configPath)) {
-    console.error(`[setup] No ${SCAFFOLD_DIR}/ found. Run 'opencode-auto-agent init' first.`);
+    error(
+      `No ${SCAFFOLD_DIR}/ found.`,
+      "Run 'npx opencode-auto-agent init' first."
+    );
     process.exit(1);
   }
 
-  // Validate preset
-  const presetFile = join(scaffoldDir, "presets", `${preset}.md`);
-  if (!existsSync(presetFile)) {
-    console.error(`[setup] Unknown preset: "${preset}"`);
-    console.error(`[setup] Available: ${PRESETS.join(", ")}`);
-    console.error(`[setup] Or create a custom preset at: presets/${preset}.md`);
+  // ── 2. Load current config ────────────────────────────────────────────────
+  const config = readJsonSync(configPath);
+  if (!config) {
+    error("Failed to read config.json.", "File may be corrupted. Re-run init with --force.");
     process.exit(1);
   }
 
-  // Update config
-  const config = readJsonSync(configPath);
-  const oldPreset = config.preset;
-  config.preset = preset;
+  section("Current Configuration");
+  kv("Preset", config.preset || "(none)");
+  kv("Schema version", config.version || "(unknown)");
+  if (config.models) {
+    for (const [role, model] of Object.entries(config.models)) {
+      kv(`  ${role}`, model);
+    }
+  }
+
+  // ── 3. Select preset ──────────────────────────────────────────────────────
+  section("Preset Selection");
+  let chosenPreset = preset;
+
+  if (!chosenPreset && !nonInteractive) {
+    const presetItems = PRESETS.map((p) => ({
+      label: p,
+      value: p,
+      hint: `${presetDescription(p)}${p === config.preset ? " (current)" : ""}`,
+    }));
+    const result = await select("Choose a project preset", presetItems);
+    chosenPreset = result.value;
+  }
+
+  if (chosenPreset && !PRESETS.includes(chosenPreset)) {
+    // Check if it exists as a custom preset file
+    const customPreset = join(scaffoldDir, DIRS.presets, `${chosenPreset}.md`);
+    if (!existsSync(customPreset)) {
+      error(
+        `Unknown preset: "${chosenPreset}"`,
+        `Available: ${PRESETS.join(", ")} (or create a custom preset at ${DIRS.presets}/${chosenPreset}.md)`
+      );
+      process.exit(1);
+    }
+  }
+
+  chosenPreset = chosenPreset || config.preset || "java";
+  const presetChanged = chosenPreset !== config.preset;
+  status(presetChanged ? "arrow" : "pass",
+    presetChanged
+      ? `Preset: ${c.yellow(config.preset)} ${c.gray("\u2192")} ${c.green(chosenPreset)}`
+      : `Preset: ${c.bold(chosenPreset)} ${c.gray("(unchanged)")}`
+  );
+
+  // ── 4. Model reconfiguration ──────────────────────────────────────────────
+  let modelMapping = config.models || { ...DEFAULT_MODEL_MAP };
+  let modelsChanged = false;
+
+  // Ask about model reconfiguration if preset changed or explicitly requested
+  const shouldReconfigModels = reconfigModels ||
+    (!nonInteractive && presetChanged &&
+      await confirm("Reconfigure model assignments for the new preset?", false));
+
+  if (shouldReconfigModels && !nonInteractive) {
+    section("Model Discovery");
+    const models = discoverModelsInteractive();
+
+    if (models.length > 0) {
+      const groups = groupByProvider(models);
+      const providerList = [...groups.entries()].map(
+        ([p, ms]) => `${c.bold(p)} ${c.gray(`(${ms.length} models)`)}`
+      );
+      boxList("Available Providers", providerList);
+
+      section("Agent Model Assignment");
+      console.log(`  ${c.gray("Select a model for each agent role. Current assignment shown.")}`);
+      console.log();
+
+      for (const role of AGENTS) {
+        const currentModel = modelMapping[role] || DEFAULT_MODEL_MAP[role];
+        const currentFound = findModel(models, currentModel);
+
+        // Build selection: current first, default second (if different), then rest
+        const items = [];
+        const seen = new Set();
+
+        if (currentFound) {
+          items.push({ label: currentFound.id, value: currentFound.id, hint: "(current)" });
+          seen.add(currentFound.id);
+        }
+
+        const defaultId = DEFAULT_MODEL_MAP[role];
+        const defaultFound = findModel(models, defaultId);
+        if (defaultFound && !seen.has(defaultFound.id)) {
+          items.push({ label: defaultFound.id, value: defaultFound.id, hint: "(recommended)" });
+          seen.add(defaultFound.id);
+        }
+
+        for (const m of models) {
+          if (!seen.has(m.id)) {
+            items.push({ label: m.id, value: m.id });
+          }
+        }
+
+        const result = await select(
+          `Model for ${c.bold(role)} ${c.gray(`\u2014 ${AGENT_ROLES[role].description}`)}`,
+          items
+        );
+        if (result.value !== currentModel) modelsChanged = true;
+        modelMapping[role] = result.value;
+      }
+    } else {
+      warn("No models found. Keeping current model assignments.", "Configure opencode providers first.");
+    }
+  } else if (shouldReconfigModels && nonInteractive) {
+    status("info", "Model reconfiguration skipped in non-interactive mode");
+  }
+
+  // ── 5. Show summary ──────────────────────────────────────────────────────
+  if (presetChanged || modelsChanged) {
+    section("Changes Summary");
+    if (presetChanged) {
+      kv("Preset", `${config.preset} \u2192 ${chosenPreset}`);
+    }
+    if (modelsChanged) {
+      console.log();
+      table(
+        ["Agent Role", "Model", "Mode"],
+        AGENTS.map((role) => [
+          c.bold(role),
+          c.cyan(modelMapping[role]),
+          c.gray(AGENT_ROLES[role].mode),
+        ])
+      );
+    }
+
+    if (!nonInteractive) {
+      console.log();
+      const proceed = await confirm("Apply these changes?", true);
+      if (!proceed) {
+        console.log(c.gray("\n  Aborted.\n"));
+        process.exit(0);
+      }
+    }
+  } else {
+    console.log();
+    status("info", "No changes to apply.");
+    return;
+  }
+
+  // ── 6. Write updated config.json ──────────────────────────────────────────
+  section("Applying Changes");
+
+  config.preset = chosenPreset;
+  config.models = modelMapping;
+  config.version = SCHEMA_VERSION;
+
+  // Update agents section
+  if (!config.agents) config.agents = {};
+  for (const role of AGENTS) {
+    if (!config.agents[role]) config.agents[role] = {};
+    config.agents[role].enabled = config.agents[role]?.enabled ?? true;
+    config.agents[role].model = modelMapping[role];
+    config.agents[role].mode = AGENT_ROLES[role].mode;
+  }
+
   writeJsonSync(configPath, config);
+  status("pass", "Updated config.json");
+
+  // ── 7. Write updated opencode.json ────────────────────────────────────────
+  const opencodeConfigPath = join(targetDir, "opencode.json");
+  const opencodeConfig = readJsonSync(opencodeConfigPath) || {};
+
+  // Update root model
+  opencodeConfig.$schema = opencodeConfig.$schema || "https://opencode.ai/config.json";
+  opencodeConfig.model = modelMapping.orchestrator;
+  opencodeConfig.instructions = opencodeConfig.instructions || [
+    "AGENTS.md",
+    `.opencode/rules/universal.md`,
+  ];
+
+  // Update agent definitions
+  if (!opencodeConfig.agent) opencodeConfig.agent = {};
+  for (const role of AGENTS) {
+    const def = AGENT_ROLES[role];
+    if (!opencodeConfig.agent[role]) {
+      opencodeConfig.agent[role] = {
+        description: def.description,
+        mode: def.mode,
+        prompt: buildAgentPrompt(role, chosenPreset),
+        tools: def.tools,
+      };
+      if (Object.keys(def.permission).length > 0) {
+        opencodeConfig.agent[role].permission = def.permission;
+      }
+    }
+    opencodeConfig.agent[role].model = modelMapping[role];
+    opencodeConfig.agent[role].temperature = def.temperature;
+  }
+
+  writeJsonSync(opencodeConfigPath, opencodeConfig);
+  status("pass", "Updated opencode.json");
+
+  // ── 8. Update agent markdown frontmatter ──────────────────────────────────
+  if (modelsChanged) {
+    const agentsDir = join(scaffoldDir, DIRS.agents);
+    for (const role of AGENTS) {
+      const agentFile = join(agentsDir, `${role}.md`);
+      if (existsSync(agentFile)) {
+        try {
+          const content = readFileSync(agentFile, "utf8");
+          const patched = patchAgentModelFrontmatter(content, modelMapping[role]);
+          if (patched !== content) {
+            writeTextSync(agentFile, patched);
+          }
+        } catch {
+          // Non-fatal: markdown patching failure
+        }
+      }
+    }
+    status("pass", "Updated agent markdown frontmatter");
+  }
+
+  // ── Done ──────────────────────────────────────────────────────────────────
+  success("Setup complete!");
+
+  console.log(`  ${c.bold("Next steps:")}`);
+  console.log(`  ${c.gray("1.")} Run  ${c.cyan("npx opencode-auto-agent doctor")} to validate`);
+  console.log(`  ${c.gray("2.")} Run  ${c.cyan("npx opencode-auto-agent run")} to start the orchestrator`);
+  console.log();
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function presetDescription(name) {
+  const desc = {
+    java: "General Java project (Maven/Gradle)",
+    springboot: "Spring Boot 3.x web application",
+    nextjs: "Next.js 14+ with App Router",
+  };
+  return desc[name] || "Custom preset";
+}
+
+function buildAgentPrompt(role, preset) {
+  const prompts = {
+    orchestrator:
+      `You are the orchestrator. Read .opencode/context/ for active context. Follow the workflow: plan -> implement -> test -> verify. Preset: ${preset}.`,
+    planner:
+      "You are the planner agent. Produce step-by-step implementation plans. Do not write code. Output plans as numbered markdown lists.",
+    developer:
+      "You are the developer agent. Implement code changes per the plan. Follow project conventions. Write clean, tested code.",
+    qa:
+      "You are the QA agent. Run tests, check for regressions, verify acceptance criteria. Report pass/fail status clearly.",
+    reviewer:
+      "You are the reviewer agent. Review code for correctness, security issues, performance problems, and style violations. Do not make changes.",
+    docs:
+      "You are the docs agent. Update documentation to reflect code changes. Keep README, API docs, and inline comments accurate.",
+  };
+  return prompts[role] || `You are the ${role} agent.`;
+}
+
+/**
+ * Patch or add the `model:` field in markdown YAML frontmatter.
+ */
+function patchAgentModelFrontmatter(content, modelId) {
+  if (!content.startsWith("---")) return content;
+
+  const endIdx = content.indexOf("---", 3);
+  if (endIdx === -1) return content;
+
+  let frontmatter = content.slice(3, endIdx);
+  const body = content.slice(endIdx);
+
+  if (/^model:/m.test(frontmatter)) {
+    frontmatter = frontmatter.replace(/^model:.*$/m, `model: ${modelId}`);
+  } else {
+    const lines = frontmatter.split("\n");
+    const descIdx = lines.findIndex((l) => l.startsWith("description:"));
+    if (descIdx >= 0) {
+      lines.splice(descIdx + 1, 0, `model: ${modelId}`);
+    } else {
+      lines.push(`model: ${modelId}`);
+    }
+    frontmatter = lines.join("\n");
+  }
 
-  console.log(`[setup] Preset changed: ${oldPreset} → ${preset}`);
-  console.log(`[setup] Preset file: presets/${preset}.md`);
-  console.log(`[setup] Run 'opencode-auto-agent run' to use the new preset.`);
+  return `---${frontmatter}${body}`;
 }