@kodrunhq/opencode-autopilot 1.1.2 → 1.2.0

package/assets/commands/oc-configure.md

@@ -2,113 +2,26 @@
 description: Configure opencode-autopilot model assignments for each agent group
 agent: autopilot
 ---
-Help the user configure opencode-autopilot by walking through the model
-assignment process interactively.
+Model configuration uses an interactive terminal wizard with searchable
+model selection. This cannot be done inside the OpenCode TUI — it requires
+a separate terminal.
 
-## Step 1: Discover available models
+Tell the user to open a terminal and run:
 
-Call the oc_configure tool with subcommand "start". This returns:
-- `availableModels`: a map of provider -> list of "provider/model" strings
-- `groups`: the 8 agent groups with descriptions and recommendations
-- `currentConfig`: existing assignments if reconfiguring
-- `diversityRules`: adversarial diversity constraints
-
-If `availableModels` is empty or has no entries, tell the user:
-"No models were discovered from your providers. Run `opencode models`
-in your terminal to see available models, then type them manually below."
-
-## Step 2: Build the complete model list
-
-Combine ALL models from ALL providers into a single numbered list.
-Every model the user has access to must appear. Do NOT filter, summarize,
-or show only "recommended" models. The user decides — you present options.
-
-Example (show ALL of them, not a subset). The IDs must match exactly
-what `availableModels` returns (provider prefix comes from the provider):
 ```
-Available models:
- 1. anthropic/claude-opus-4-6
- 2. anthropic/claude-sonnet-4-6
- 3. anthropic/claude-haiku-4-5
- 4. openai/gpt-5.4
- 5. openai/gpt-5.4-mini
- 6. openai/gpt-5.4-codex
- 7. google/gemini-3.1-pro
- 8. google/gemini-3-flash
- ...
-```
-
-## Step 3: Walk through each group
-
-For each of the 8 groups (architects first, utilities last):
-
-1. Explain what the group does and which agents belong to it
-2. Show the tier recommendation
-3. For adversarial groups (challengers, reviewers, red-team): explain WHY
-   model diversity matters and which group they are adversarial to
-4. Show the full numbered model list again whenever asking for selections
-
-### Collecting models for each group
-
-For each group, collect an ORDERED LIST of models (not just one):
-
-```
-Group: Architects
-Pick models in priority order. The first is the primary; the rest are
-fallbacks tried in sequence when the primary is rate-limited or fails.
-
-Enter model numbers separated by commas (e.g. 1,4,7):
+bunx @kodrunhq/opencode-autopilot configure
 ```
 
-- The FIRST number is the primary model
-- All subsequent numbers are fallbacks, tried in the order given
-- Minimum 1 model (the primary), recommend 2-3 total
-- Emphasize that fallbacks are the core feature: "When your primary model
-  hits a rate limit, the plugin automatically retries with the next model
-  in your fallback chain. More fallbacks = more resilience."
-
-Parse the user's response:
-- If they send numbers like "1,4,7": map to model IDs
-- If they send model IDs directly: use as-is
-- If they send a single number: that's the primary with no fallbacks
-
-Call oc_configure with subcommand "assign":
-- `group`: the group ID
-- `primary`: first model from the user's list
-- `fallbacks`: remaining models as comma-separated string
-
-### Diversity warnings
-
-If the assign response contains `diversityWarnings`, explain them
-conversationally. Strong warnings should be highlighted — the user can
-still proceed, but make the quality trade-off clear.
-
-Example: "Heads up: Architects and Challengers both use Claude models.
-Challengers are supposed to critique Architect decisions — using the same
-model family means you get confirmation bias instead of genuine challenge.
-Consider picking a different family for one of them. Continue anyway?"
-
-## Step 4: Commit and verify
-
-After all 8 groups are assigned, call oc_configure with subcommand "commit".
-
-Then call oc_configure with subcommand "doctor" to verify health.
-
-Show a final summary table:
-
-```
-Group          | Primary                      | Fallbacks
-───────────────┼──────────────────────────────┼──────────────────────────
-Architects     | anthropic/claude-opus-4-6    | openai/gpt-5.4
-Challengers    | openai/gpt-5.4              | google/gemini-3.1-pro
-...
-```
+This will:
+1. Discover all available models from their configured providers
+2. Walk through each of the 8 agent groups with a searchable model picker
+3. For each group, select a primary model and optional fallback models
+4. Check adversarial diversity (different families for groups that review each other)
+5. Save the configuration
 
-## Rules
+After running the wizard, tell the user to restart OpenCode to pick up
+the new model assignments.
 
-- NEVER pre-select models for the user. Always present the full list.
-- NEVER skip fallback collection. Always ask for ordered model lists.
-- NEVER filter the model list to "recommended" models. Show everything.
-- If the user says "pick for me" or "use defaults", THEN you may suggest
-  assignments based on the tier recommendations and diversity rules, but
-  still show what you picked and ask for confirmation.
+Do NOT attempt to configure models through the oc_configure tool's assign
+subcommand directly. The interactive wizard is the supported configuration
+method.

package/bin/cli.ts

@@ -10,6 +10,7 @@ import { diagnose } from "../src/registry/doctor";
 import { ALL_GROUP_IDS, DIVERSITY_RULES, GROUP_DEFINITIONS } from "../src/registry/model-groups";
 import type { GroupId } from "../src/registry/types";
 import { fileExists } from "../src/utils/fs-helpers";
+import { runConfigure } from "./configure-tui";
 
 const execFile = promisify(execFileCb);
 
@@ -124,14 +125,12 @@ export async function runInstall(options: CliOptions = {}): Promise<void> {
 	console.log("");
 	console.log(bold("Next steps:"));
 	console.log("");
-	console.log("  1. Launch OpenCode");
-	console.log("  2. Run /oc-configure to set up your model assignments");
+	console.log("  Run the interactive configuration wizard:");
 	console.log("");
-	console.log("  Or paste this into your AI session for guided setup:");
+	console.log(`    ${bold("bunx @kodrunhq/opencode-autopilot configure")}`);
 	console.log("");
-	console.log(
-		"    https://raw.githubusercontent.com/kodrunhq/opencode-autopilot/main/docs/guide/installation.md",
-	);
+	console.log("  This walks through each agent group with searchable model");
+	console.log("  selection and fallback configuration.");
 	console.log("");
 }
 
@@ -313,6 +312,7 @@ function printUsage(): void {
 	console.log("");
 	console.log("Commands:");
 	console.log("  install     Register the plugin and create starter config");
+	console.log("  configure   Interactive model assignment for each agent group");
 	console.log("  doctor      Check installation health and model assignments");
 	console.log("");
 	console.log("Options:");
@@ -330,6 +330,9 @@ if (import.meta.main) {
 		case "install":
 			await runInstall({ noTui: args.includes("--no-tui") });
 			break;
+		case "configure":
+			await runConfigure();
+			break;
 		case "doctor":
 			await runDoctor();
 			break;

package/bin/configure-tui.ts

@@ -0,0 +1,338 @@
+/**
+ * Interactive TUI for configuring model assignments.
+ * Uses @inquirer/search (filterable single-select) and @inquirer/checkbox
+ * (multi-select) to handle 100+ models deterministically — no LLM involved.
+ */
+
+import { execFile as execFileCb } from "node:child_process";
+import { promisify } from "node:util";
+import checkbox, { Separator as CheckboxSeparator } from "@inquirer/checkbox";
+import confirm from "@inquirer/confirm";
+import search from "@inquirer/search";
+import { CONFIG_PATH, createDefaultConfig, loadConfig, saveConfig } from "../src/config";
+import { checkDiversity } from "../src/registry/diversity";
+import { ALL_GROUP_IDS, DIVERSITY_RULES, GROUP_DEFINITIONS } from "../src/registry/model-groups";
+import type { GroupId, GroupModelAssignment } from "../src/registry/types";
+
+const execFile = promisify(execFileCb);
+
+// ── ANSI helpers ───────────────────────────────────────────────────
+
+const green = (s: string) => `\x1b[32m${s}\x1b[0m`;
+const red = (s: string) => `\x1b[31m${s}\x1b[0m`;
+const yellow = (s: string) => `\x1b[33m${s}\x1b[0m`;
+const bold = (s: string) => `\x1b[1m${s}\x1b[0m`;
+const dim = (s: string) => `\x1b[2m${s}\x1b[0m`;
+const cyan = (s: string) => `\x1b[36m${s}\x1b[0m`;
+
+// ── Model discovery ────────────────────────────────────────────────
+
+interface DiscoveredModel {
+	readonly id: string; // "provider/model"
+	readonly provider: string;
+	readonly model: string;
+}
+
+/**
+ * Discover available models by running `opencode models`.
+ * Each line of output is a "provider/model" string.
+ */
+async function discoverModels(): Promise<readonly DiscoveredModel[]> {
+	try {
+		const { stdout } = await execFile("opencode", ["models"]);
+		const lines = stdout
+			.split("\n")
+			.map((l) => l.trim())
+			.filter(Boolean);
+
+		return lines.map((id) => {
+			const slashIndex = id.indexOf("/");
+			return {
+				id,
+				provider: slashIndex > 0 ? id.slice(0, slashIndex) : "unknown",
+				model: slashIndex > 0 ? id.slice(slashIndex + 1) : id,
+			};
+		});
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Group models by provider for display with separators.
+ */
+function groupByProvider(models: readonly DiscoveredModel[]): Map<string, DiscoveredModel[]> {
+	const grouped = new Map<string, DiscoveredModel[]>();
+	for (const m of models) {
+		const existing = grouped.get(m.provider) ?? [];
+		existing.push(m);
+		grouped.set(m.provider, existing);
+	}
+	return grouped;
+}
+
+// ── Search source for @inquirer/search ─────────────────────────────
+
+function createSearchSource(models: readonly DiscoveredModel[], exclude?: Set<string>) {
+	const byProvider = groupByProvider(models);
+
+	return async (term: string | undefined) => {
+		const results: Array<
+			{ name: string; value: string; description: string } | typeof CheckboxSeparator.prototype
+		> = [];
+
+		for (const [provider, providerModels] of byProvider) {
+			const filtered = providerModels.filter((m) => {
+				if (exclude?.has(m.id)) return false;
+				if (!term) return true;
+				return m.id.toLowerCase().includes(term.toLowerCase());
+			});
+
+			if (filtered.length === 0) continue;
+
+			results.push(new CheckboxSeparator(`── ${provider} ──`));
+			for (const m of filtered) {
+				results.push({
+					name: m.id,
+					value: m.id,
+					description: m.model,
+				});
+			}
+		}
+
+		return results;
+	};
+}
+
+// ── Checkbox choices for fallback selection ─────────────────────────
+
+function createCheckboxChoices(models: readonly DiscoveredModel[], excludePrimary: string) {
+	const byProvider = groupByProvider(models);
+	const choices: Array<{ name: string; value: string } | InstanceType<typeof CheckboxSeparator>> =
+		[];
+
+	for (const [provider, providerModels] of byProvider) {
+		const filtered = providerModels.filter((m) => m.id !== excludePrimary);
+		if (filtered.length === 0) continue;
+
+		choices.push(new CheckboxSeparator(`── ${provider} ──`));
+		for (const m of filtered) {
+			choices.push({
+				name: m.id,
+				value: m.id,
+			});
+		}
+	}
+
+	return choices;
+}
+
+// ── Diversity check display ────────────────────────────────────────
+
+function extractFamily(model: string): string {
+	const slashIndex = model.indexOf("/");
+	return slashIndex > 0 ? model.slice(0, slashIndex) : model;
+}
+
+function showDiversityWarnings(assignments: Record<string, GroupModelAssignment>): void {
+	const warnings = checkDiversity(assignments);
+	if (warnings.length === 0) return;
+
+	console.log("");
+	for (const w of warnings) {
+		const groupLabels = w.groups.map((g) => GROUP_DEFINITIONS[g as GroupId]?.label ?? g);
+		const label = groupLabels.join(" & ");
+		const severity = w.rule.severity === "strong" ? red("WARNING") : yellow("note");
+		console.log(`  ${severity}: ${label} both use ${cyan(w.sharedFamily)} family`);
+		console.log(`  ${dim(w.rule.reason)}`);
+		console.log("");
+	}
+}
+
+// ── Group walkthrough ──────────────────────────────────────────────
+
+async function configureGroup(
+	groupId: GroupId,
+	models: readonly DiscoveredModel[],
+	assignments: Record<string, GroupModelAssignment>,
+): Promise<GroupModelAssignment> {
+	const def = GROUP_DEFINITIONS[groupId];
+
+	console.log("");
+	console.log(bold(`── ${def.label} ──────────────────────────────────────`));
+	console.log(`  ${dim("Purpose:")} ${def.purpose}`);
+	console.log(`  ${dim("Recommendation:")} ${def.recommendation}`);
+
+	// Check if this group is adversarial to another
+	for (const rule of DIVERSITY_RULES) {
+		if (rule.groups.includes(groupId)) {
+			const others = rule.groups.filter((g) => g !== groupId);
+			const assignedOthers = others.filter((g) => assignments[g]);
+			if (assignedOthers.length > 0) {
+				const otherLabels = assignedOthers.map(
+					(g) =>
+						`${GROUP_DEFINITIONS[g as GroupId].label} (${extractFamily(assignments[g].primary)})`,
+				);
+				console.log(
+					`  ${yellow("⚡")} Adversarial to: ${otherLabels.join(", ")} — pick a ${bold("different")} family`,
+				);
+			}
+		}
+	}
+
+	console.log("");
+
+	// Primary model — searchable select
+	const primary = await search({
+		message: `Primary model for ${def.label}:`,
+		source: createSearchSource(models),
+		pageSize: 15,
+	});
+
+	// Fallback models — checkbox multi-select
+	const wantFallbacks = await confirm({
+		message: "Add fallback models? (recommended for resilience)",
+		default: true,
+	});
+
+	let fallbacks: string[] = [];
+	if (wantFallbacks) {
+		fallbacks = await checkbox({
+			message: `Fallback models for ${def.label} (space to select, enter to confirm):`,
+			choices: createCheckboxChoices(models, primary),
+			pageSize: 15,
+		});
+	}
+
+	const assignment: GroupModelAssignment = Object.freeze({
+		primary,
+		fallbacks: Object.freeze(fallbacks),
+	});
+
+	// Show what was selected
+	console.log(
+		`  ${green("✓")} ${def.label}: ${cyan(primary)}${fallbacks.length > 0 ? ` → ${fallbacks.map(cyan).join(" → ")}` : ""}`,
+	);
+
+	return assignment;
+}
+
+// ── Main configure flow ────────────────────────────────────────────
+
+export async function runConfigure(configPath: string = CONFIG_PATH): Promise<void> {
+	console.log("");
+	console.log(bold("opencode-autopilot configure"));
+	console.log("────────────────────────────");
+	console.log("");
+
+	// 1. Discover models
+	console.log("  Discovering available models...");
+	const models = await discoverModels();
+
+	if (models.length === 0) {
+		console.log("");
+		console.log(red("  No models found."));
+		console.log("  Make sure OpenCode is installed and you have providers configured.");
+		console.log("  Run: opencode providers list");
+		console.log("");
+		process.exit(1);
+	}
+
+	const byProvider = groupByProvider(models);
+	console.log(
+		`  ${green("✓")} Found ${bold(String(models.length))} models from ${bold(String(byProvider.size))} providers`,
+	);
+
+	// 2. Load existing config
+	const existingConfig = await loadConfig(configPath);
+	if (existingConfig?.configured) {
+		console.log(`  ${yellow("⚠")} Existing configuration found — this will overwrite it`);
+		const proceed = await confirm({
+			message: "Continue with reconfiguration?",
+			default: true,
+		});
+		if (!proceed) {
+			console.log("  Cancelled.");
+			return;
+		}
+	}
+
+	console.log("");
+	console.log(bold("Walk through each agent group and assign models."));
+	console.log(dim("Type to search, arrow keys to navigate, enter to select."));
+	console.log(dim("For fallbacks: space to toggle, enter to confirm selection."));
+
+	// 3. Walk through each group
+	const assignments: Record<string, GroupModelAssignment> = {};
+
+	for (const groupId of ALL_GROUP_IDS) {
+		assignments[groupId] = await configureGroup(groupId, models, assignments);
+		showDiversityWarnings(assignments);
+	}
+
+	// 4. Show summary
+	console.log("");
+	console.log(bold("── Summary ───────────────────────────────────────────"));
+	console.log("");
+
+	const labelWidth = Math.max(...ALL_GROUP_IDS.map((id) => GROUP_DEFINITIONS[id].label.length)) + 2;
+
+	for (const groupId of ALL_GROUP_IDS) {
+		const def = GROUP_DEFINITIONS[groupId];
+		const a = assignments[groupId];
+		const label = def.label.padEnd(labelWidth);
+		const fallbackStr = a.fallbacks.length > 0 ? ` → ${a.fallbacks.join(" → ")}` : "";
+		console.log(`  ${label} ${cyan(a.primary)}${dim(fallbackStr)}`);
+	}
+
+	console.log("");
+
+	// 5. Confirm and save
+	const doCommit = await confirm({
+		message: "Save this configuration?",
+		default: true,
+	});
+
+	if (!doCommit) {
+		console.log("  Configuration discarded.");
+		return;
+	}
+
+	// Build and save config
+	const baseConfig = existingConfig ?? createDefaultConfig();
+	const groupsRecord: Record<string, { primary: string; fallbacks: string[] }> = {};
+	for (const [key, val] of Object.entries(assignments)) {
+		groupsRecord[key] = { primary: val.primary, fallbacks: [...val.fallbacks] };
+	}
+
+	const newConfig = {
+		...baseConfig,
+		version: 4 as const,
+		configured: true,
+		groups: groupsRecord,
+		overrides: baseConfig.overrides ?? {},
+	};
+
+	await saveConfig(newConfig, configPath);
+	console.log(`  ${green("✓")} Configuration saved`);
+
+	// 6. Final diversity check
+	console.log("");
+	console.log(bold("Adversarial Diversity Check"));
+	const finalWarnings = checkDiversity(groupsRecord);
+	if (finalWarnings.length === 0) {
+		console.log(`  ${green("✓")} All adversarial groups use different model families`);
+	} else {
+		for (const w of finalWarnings) {
+			const groupLabels = w.groups.map((g) => GROUP_DEFINITIONS[g as GroupId]?.label ?? g);
+			console.log(
+				`  ${yellow("⚠")} ${groupLabels.join(" & ")}: shared ${cyan(w.sharedFamily)} family — ${dim(w.rule.reason)}`,
+			);
+		}
+	}
+
+	console.log("");
+	console.log(green("Configuration complete!"));
+	console.log(dim("Run 'bunx @kodrunhq/opencode-autopilot doctor' to verify."));
+	console.log("");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kodrunhq/opencode-autopilot",
-	"version": "1.1.2",
+	"version": "1.2.0",
 	"description": "Curated agents, skills, and commands for the OpenCode AI coding CLI — autonomous orchestrator, multi-agent code review, model fallback, and in-session asset creation tools.",
 	"main": "src/index.ts",
 	"keywords": [
@@ -51,6 +51,10 @@
 	},
 	"type": "module",
 	"dependencies": {
+		"@inquirer/checkbox": "^5.1.2",
+		"@inquirer/confirm": "^6.0.10",
+		"@inquirer/search": "^4.1.6",
+		"@inquirer/select": "^5.1.2",
 		"yaml": "^2.8.3"
 	}
 }

package/src/installer.ts

@@ -1,6 +1,6 @@
-import { readdir, unlink } from "node:fs/promises";
-import { join } from "node:path";
-import { copyIfMissing, isEnoentError } from "./utils/fs-helpers";
+import { access, copyFile, readdir, unlink } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { copyIfMissing, ensureDir, isEnoentError } from "./utils/fs-helpers";
 import { getAssetsDir, getGlobalConfigDir } from "./utils/paths";
 
 /**
@@ -9,6 +9,13 @@ import { getAssetsDir, getGlobalConfigDir } from "./utils/paths";
  */
 const DEPRECATED_ASSETS = ["agents/placeholder-agent.md", "commands/configure.md"] as const;
 
+/**
+ * Assets that must be overwritten on every install, even if the user has a copy.
+ * Used when the shipped version has critical fixes that override user customizations.
+ * Remove entries once the fix has been deployed long enough.
+ */
+const FORCE_UPDATE_ASSETS = ["commands/oc-configure.md"] as const;
+
 export interface InstallResult {
 	readonly copied: readonly string[];
 	readonly skipped: readonly string[];
@@ -138,6 +145,33 @@ async function cleanupDeprecatedAssets(
 	return { removed, errors };
 }
 
+async function forceUpdateAssets(
+	sourceDir: string,
+	targetDir: string,
+): Promise<{ readonly updated: readonly string[]; readonly errors: readonly string[] }> {
+	const updated: string[] = [];
+	const errors: string[] = [];
+	for (const asset of FORCE_UPDATE_ASSETS) {
+		const source = join(sourceDir, asset);
+		const target = join(targetDir, asset);
+		try {
+			// Verify source exists before attempting copy — skip silently if
+			// the source isn't in the bundle (test environments, partial installs)
+			await access(source);
+			await ensureDir(dirname(target));
+			await copyFile(source, target);
+			updated.push(asset);
+		} catch (error: unknown) {
+			if (!isEnoentError(error)) {
+				const message = error instanceof Error ? error.message : String(error);
+				errors.push(`force-update ${asset}: ${message}`);
+			}
+			// ENOENT = source not in bundle, skip silently
+		}
+	}
+	return { updated, errors };
+}
+
 export async function installAssets(
 	assetsDir: string = getAssetsDir(),
 	targetDir: string = getGlobalConfigDir(),
@@ -145,6 +179,9 @@ export async function installAssets(
 	// Remove deprecated assets before copying new ones
 	const cleanup = await cleanupDeprecatedAssets(targetDir);
 
+	// Force-overwrite assets with critical fixes
+	const forceUpdate = await forceUpdateAssets(assetsDir, targetDir);
+
 	const [agents, commands, skills] = await Promise.all([
 		processFiles(assetsDir, targetDir, "agents"),
 		processFiles(assetsDir, targetDir, "commands"),
@@ -152,8 +189,14 @@ export async function installAssets(
 	]);
 
 	return {
-		copied: [...agents.copied, ...commands.copied, ...skills.copied],
+		copied: [...forceUpdate.updated, ...agents.copied, ...commands.copied, ...skills.copied],
 		skipped: [...agents.skipped, ...commands.skipped, ...skills.skipped],
-		errors: [...cleanup.errors, ...agents.errors, ...commands.errors, ...skills.errors],
+		errors: [
+			...cleanup.errors,
+			...forceUpdate.errors,
+			...agents.errors,
+			...commands.errors,
+			...skills.errors,
+		],
 	};
 }

package/src/tools/configure.ts

@@ -117,6 +117,37 @@ function serializeDiversityWarnings(warnings: readonly DiversityWarning[]): read
 	}));
 }
 
+/**
+ * Build a flat numbered list of all available models and an index map.
+ * Returns { numberedList: "1. provider/model\n2. ...", indexMap: { "1": "provider/model", ... } }
+ */
+function buildNumberedModelList(modelsByProvider: Map<string, string[]>): {
+	numberedList: string;
+	indexMap: Record<string, string>;
+	totalCount: number;
+} {
+	const allModels: string[] = [];
+	for (const models of modelsByProvider.values()) {
+		allModels.push(...models);
+	}
+	// Sort alphabetically for stable ordering
+	allModels.sort();
+
+	const indexMap: Record<string, string> = {};
+	const lines: string[] = [];
+	for (let i = 0; i < allModels.length; i++) {
+		const num = String(i + 1);
+		indexMap[num] = allModels[i];
+		lines.push(`  ${num}. ${allModels[i]}`);
+	}
+
+	return {
+		numberedList: lines.join("\n"),
+		indexMap,
+		totalCount: allModels.length,
+	};
+}
+
 async function handleStart(configPath?: string): Promise<string> {
 	// Wait for background provider discovery (up to 5s) before building model list
 	await Promise.race([
@@ -125,6 +156,7 @@ async function handleStart(configPath?: string): Promise<string> {
 	]);
 
 	const modelsByProvider = discoverAvailableModels();
+	const { numberedList, indexMap, totalCount } = buildNumberedModelList(modelsByProvider);
 
 	// Load current plugin config to show existing assignments
 	const currentConfig = await loadConfig(configPath);
@@ -148,15 +180,53 @@ async function handleStart(configPath?: string): Promise<string> {
 		};
 	});
 
+	// Pre-formatted text the LLM should show verbatim — avoids summarization
+	const displayText =
+		totalCount > 0
+			? [
+					`Available models (${totalCount} total):`,
+					numberedList,
+					"",
+					"For each group below, enter model numbers separated by commas (e.g. 1,4,7).",
+					"First number = primary model. Remaining = fallbacks tried in order.",
+					"More fallbacks = more resilience when a model is rate-limited.",
+				].join("\n")
+			: [
+					"No models were discovered from your providers.",
+					"Run `opencode models` in your terminal to see available models,",
+					"then type model IDs manually (e.g. anthropic/claude-opus-4-6).",
+				].join("\n");
+
+	// Compact group summaries — only fields the LLM needs for the walkthrough
+	const compactGroups = groups.map((g) => ({
+		id: g.id,
+		label: g.label,
+		purpose: g.purpose,
+		recommendation: g.recommendation,
+		agents: g.agents,
+		currentAssignment: g.currentAssignment,
+	}));
+
+	// Compact diversity rules — just the text the LLM should mention
+	const compactRules = DIVERSITY_RULES.map((r) => ({
+		groups: r.groups,
+		severity: r.severity,
+		reason: r.reason,
+	}));
+
+	// NOTE: availableModels is intentionally excluded — it's redundant with
+	// displayText/modelIndex and can be 400KB+ with many providers, causing
+	// OpenCode to truncate the tool output and lose everything after it.
 	return JSON.stringify({
 		action: "configure",
 		stage: "start",
-		availableModels: Object.fromEntries(modelsByProvider),
-		groups,
+		displayText,
+		modelIndex: indexMap,
+		groups: compactGroups,
+		diversityRules: compactRules,
 		currentConfig: currentConfig
 			? { configured: currentConfig.configured, groups: currentConfig.groups }
 			: null,
-		diversityRules: DIVERSITY_RULES,
 	});
 }