@agentplate/cli 1.1.0 → 1.2.0

package/src/merge/auto.test.ts

@@ -0,0 +1,157 @@
+/**
+ * Tests for auto-merge (maybeAutoMerge).
+ *
+ * Real git repos in temp dirs (per "never mock what you can use for real"), the
+ * real merge queue + lock, and a recording mail stub so we can assert the outcome
+ * notifications without a mail DB. Covers the mode gate, the capability skip, the
+ * gates-pass fail-closed rule, a clean landing, and a reported conflict.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Capability, NewMail } from "../types.ts";
+import { type AutoMergeParams, maybeAutoMerge } from "./auto.ts";
+
+let repo: string;
+
+async function git(...args: string[]): Promise<string> {
+	const proc = Bun.spawn(["git", ...args], { cwd: repo, stdout: "pipe", stderr: "pipe" });
+	const [stdout, stderr, exitCode] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+		proc.exited,
+	]);
+	if (exitCode !== 0) throw new Error(`git ${args.join(" ")} failed (${exitCode}): ${stderr}`);
+	return stdout;
+}
+
+/** Recording mail stub satisfying the `{ send }` surface maybeAutoMerge needs. */
+function recordingMail() {
+	const sent: Array<{ type: string; subject: string; to: string }> = [];
+	return {
+		sent,
+		send: (m: NewMail) => {
+			sent.push({ type: m.type, subject: m.subject, to: m.to });
+		},
+	};
+}
+
+/** Build params with sensible defaults; override per test. */
+function params(
+	over: Partial<AutoMergeParams> & { mail: ReturnType<typeof recordingMail> },
+): AutoMergeParams {
+	return {
+		root: repo,
+		branchName: "agentplate/builder-x",
+		targetBranch: "main",
+		capability: "builder" as Capability,
+		agentName: "builder-x",
+		taskId: "task-x",
+		parent: "lead-1",
+		mode: "on-complete",
+		aiResolveEnabled: true,
+		gateStatus: null,
+		...over,
+	};
+}
+
+beforeEach(async () => {
+	repo = mkdtempSync(join(tmpdir(), "agentplate-automerge-"));
+	mkdirSync(join(repo, ".agentplate"), { recursive: true });
+	await git("init", "-q");
+	await git("config", "user.email", "test@agentplate.dev");
+	await git("config", "user.name", "Agentplate Test");
+	await git("checkout", "-q", "-b", "main");
+	await Bun.write(join(repo, "base.txt"), "base\n");
+	await git("add", "-A");
+	await git("commit", "-q", "-m", "initial");
+});
+
+afterEach(() => {
+	rmSync(repo, { recursive: true, force: true });
+});
+
+/** Create a worker branch with a new-file commit, then return to main. */
+async function workerBranchWithCommit(branch: string, file: string): Promise<void> {
+	await git("checkout", "-q", "-b", branch);
+	await Bun.write(join(repo, file), "from worker\n");
+	await git("add", "-A");
+	await git("commit", "-q", "-m", `add ${file}`);
+	await git("checkout", "-q", "main");
+}
+
+describe("maybeAutoMerge — gating", () => {
+	test("mode 'off' never merges", async () => {
+		const mail = recordingMail();
+		await workerBranchWithCommit("agentplate/builder-x", "feature.txt");
+		const out = await maybeAutoMerge(params({ mail, mode: "off" }));
+		expect(out).toEqual({ merged: false, reason: "disabled" });
+		expect(existsSync(join(repo, "feature.txt"))).toBe(false);
+		expect(mail.sent).toHaveLength(0);
+	});
+
+	test("read-only capabilities are skipped", async () => {
+		const mail = recordingMail();
+		for (const capability of ["scout", "merger"] as Capability[]) {
+			const out = await maybeAutoMerge(params({ mail, capability }));
+			expect(out).toEqual({ merged: false, reason: "capability-skipped" });
+		}
+		expect(mail.sent).toHaveLength(0);
+	});
+
+	test("on-gates-pass holds (fail-closed) when gates did not pass", async () => {
+		const mail = recordingMail();
+		await workerBranchWithCommit("agentplate/builder-x", "feature.txt");
+		for (const gateStatus of [null, "failure", "partial"] as const) {
+			const out = await maybeAutoMerge(params({ mail, mode: "on-gates-pass", gateStatus }));
+			expect(out).toEqual({ merged: false, reason: "gates-not-passed" });
+		}
+		expect(existsSync(join(repo, "feature.txt"))).toBe(false);
+		expect(mail.sent.every((m) => m.type === "status")).toBe(true);
+	});
+});
+
+describe("maybeAutoMerge — landing", () => {
+	test("on-complete lands the branch and reports 'merged'", async () => {
+		const mail = recordingMail();
+		await workerBranchWithCommit("agentplate/builder-x", "feature.txt");
+		const out = await maybeAutoMerge(params({ mail, mode: "on-complete" }));
+		expect(out).toEqual({ merged: true, status: "merged", tier: "clean-merge" });
+		expect(existsSync(join(repo, "feature.txt"))).toBe(true); // landed on main
+		expect(mail.sent).toHaveLength(1);
+		expect(mail.sent[0]).toMatchObject({ type: "merged", to: "lead-1" });
+	});
+
+	test("on-gates-pass merges on a clean gate success", async () => {
+		const mail = recordingMail();
+		await workerBranchWithCommit("agentplate/builder-x", "feature.txt");
+		const out = await maybeAutoMerge(
+			params({ mail, mode: "on-gates-pass", gateStatus: "success" }),
+		);
+		expect(out).toMatchObject({ merged: true, status: "merged" });
+		expect(existsSync(join(repo, "feature.txt"))).toBe(true);
+	});
+
+	test("an unresolved conflict reports 'merge_failed' (never throws)", async () => {
+		const mail = recordingMail();
+		// Both branches edit base.txt differently -> conflict; aiResolveEnabled=false
+		// makes mergeBranch abort and fail.
+		await git("checkout", "-q", "-b", "agentplate/builder-x");
+		await Bun.write(join(repo, "base.txt"), "worker change\n");
+		await git("add", "-A");
+		await git("commit", "-q", "-m", "worker edits base");
+		await git("checkout", "-q", "main");
+		await Bun.write(join(repo, "base.txt"), "main change\n");
+		await git("add", "-A");
+		await git("commit", "-q", "-m", "main edits base");
+
+		const out = await maybeAutoMerge(
+			params({ mail, mode: "on-complete", aiResolveEnabled: false }),
+		);
+		expect(out.merged).toBe(false);
+		expect(out).toMatchObject({ reason: "merge-failed" });
+		expect(mail.sent[0]).toMatchObject({ type: "merge_failed" });
+	});
+});

package/src/merge/auto.ts

@@ -0,0 +1,118 @@
+/**
+ * Auto-merge: land a completed worker's branch onto the canonical branch without
+ * an operator running `agentplate merge`. Gated by `config.merge.autoMerge`:
+ *
+ *   off            → never (manual merge by the operator/coordinator)
+ *   on-gates-pass  → merge only when the task's quality gates passed cleanly
+ *   on-complete    → merge as soon as the agent finished without error
+ *
+ * This reuses the exact same path as the manual `merge` command — the merge queue
+ * (audit), the cross-process merge lock (so parallel auto-merges serialize), and
+ * {@link mergeBranch} (clean-merge / auto-resolve per `aiResolveEnabled`). Outcomes
+ * are reported to the parent/coordinator over mail (`merged` / `merge_failed`), so
+ * the existing coordination flow still sees every landing and handles conflicts.
+ *
+ * Pulled out of `sling` into its own unit so it can be tested against a real temp
+ * git repo without driving an agent turn.
+ */
+
+import { createMailClient } from "../mail/client.ts";
+import { mergeDbPath } from "../paths.ts";
+import type { AutoMergeMode, Capability, MergeStatus, MergeTier, OutcomeStatus } from "../types.ts";
+import { withMergeLock } from "./lock.ts";
+import { createMergeQueue } from "./queue.ts";
+import { mergeBranch } from "./resolver.ts";
+
+/** Capabilities that never produce a branch worth landing on the canonical branch. */
+const NON_MERGING_CAPABILITIES: ReadonlySet<Capability> = new Set<Capability>(["scout", "merger"]);
+
+export interface AutoMergeParams {
+	root: string;
+	branchName: string;
+	targetBranch: string;
+	capability: Capability;
+	agentName: string;
+	taskId: string;
+	/** Who to notify of the outcome (falls back to the coordinator). */
+	parent: string | null;
+	mode: AutoMergeMode;
+	/** Conflict strategy passed through to `mergeBranch`. */
+	aiResolveEnabled: boolean;
+	/** The task's quality-gate outcome, or null if gates did not run. */
+	gateStatus: OutcomeStatus | null;
+	/** Mail surface for reporting the outcome (injectable for tests). */
+	mail?: { send: (m: Parameters<ReturnType<typeof createMailClient>["send"]>[0]) => unknown };
+}
+
+export type AutoMergeOutcome =
+	| { merged: true; status: MergeStatus; tier: MergeTier | null }
+	| {
+			merged: false;
+			reason: "disabled" | "capability-skipped" | "gates-not-passed" | "merge-failed";
+			conflictFiles?: string[];
+	  };
+
+/**
+ * Decide whether to auto-merge `branchName` and, if so, do it under the merge lock.
+ * Never throws on a merge conflict — it reports `merge_failed` and returns a
+ * non-merged outcome so the spawn that called it is never failed by a landing.
+ */
+export async function maybeAutoMerge(params: AutoMergeParams): Promise<AutoMergeOutcome> {
+	const mail = params.mail ?? createMailClient(params.root);
+	const to = params.parent ?? "coordinator";
+
+	if (params.mode === "off") return { merged: false, reason: "disabled" };
+	if (NON_MERGING_CAPABILITIES.has(params.capability)) {
+		return { merged: false, reason: "capability-skipped" };
+	}
+	// Fail closed: on-gates-pass merges ONLY on a clean pass. A null status (gates
+	// not configured / not run) or any non-success holds the merge for a human.
+	if (params.mode === "on-gates-pass" && params.gateStatus !== "success") {
+		mail.send({
+			from: params.agentName,
+			to,
+			subject: `Auto-merge held: ${params.branchName}`,
+			body: `Quality gates did not pass (status: ${params.gateStatus ?? "not run"}); not merging. Review and merge manually.`,
+			type: "status",
+		});
+		return { merged: false, reason: "gates-not-passed" };
+	}
+
+	const queue = createMergeQueue(mergeDbPath(params.root));
+	try {
+		const entry = queue.enqueue({
+			branchName: params.branchName,
+			agentName: params.agentName,
+			taskId: params.taskId,
+			targetBranch: params.targetBranch,
+		});
+		const result = await withMergeLock(params.root, () =>
+			mergeBranch(params.root, params.branchName, params.targetBranch, {
+				autoResolve: params.aiResolveEnabled,
+			}),
+		);
+		queue.markStatus(entry.id, result.status);
+
+		if (result.status === "merged") {
+			mail.send({
+				from: params.agentName,
+				to,
+				subject: `Auto-merged: ${params.branchName} → ${params.targetBranch}`,
+				body: `Landed via ${result.tier ?? "merge"}.`,
+				type: "merged",
+			});
+			return { merged: true, status: result.status, tier: result.tier };
+		}
+
+		mail.send({
+			from: params.agentName,
+			to,
+			subject: `Auto-merge failed: ${params.branchName}`,
+			body: `Conflicts in: ${result.conflictFiles.join(", ") || "unknown"}. Merge manually.`,
+			type: "merge_failed",
+		});
+		return { merged: false, reason: "merge-failed", conflictFiles: result.conflictFiles };
+	} finally {
+		queue.close();
+	}
+}

package/src/runtimes/resolve.test.ts

@@ -0,0 +1,49 @@
+/**
+ * Tests for resolveModel — focused on per-capability model tiering. Auth-mode is
+ * set to "none" so no secret is read; we assert which model id is chosen.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { DEFAULT_CONFIG } from "../config.ts";
+import type { AgentplateConfig, Capability } from "../types.ts";
+import { resolveModel } from "./resolve.ts";
+
+/** A config whose active provider has a default model + optional tiering map. */
+function configWith(
+	model: string | undefined,
+	models?: Partial<Record<Capability, string>>,
+): AgentplateConfig {
+	const cfg = structuredClone(DEFAULT_CONFIG);
+	cfg.activeProvider = "anthropic";
+	cfg.providers.anthropic = { type: "native", authMode: "none", model, models };
+	return cfg;
+}
+
+const ROOT = "/tmp/agentplate-resolve-test"; // never read (authMode "none")
+
+describe("resolveModel — tiering", () => {
+	test("uses the provider default model when no capability is given", () => {
+		const { model } = resolveModel(configWith("claude-opus-4-8"), ROOT, "alias");
+		expect(model).toBe("claude-opus-4-8");
+	});
+
+	test("a per-capability override wins over the provider default", () => {
+		const cfg = configWith("claude-opus-4-8", {
+			scout: "claude-haiku-4-5",
+			reviewer: "claude-haiku-4-5",
+		});
+		expect(resolveModel(cfg, ROOT, "alias", "scout").model).toBe("claude-haiku-4-5");
+		expect(resolveModel(cfg, ROOT, "alias", "reviewer").model).toBe("claude-haiku-4-5");
+	});
+
+	test("a capability without an override falls back to the provider default", () => {
+		const cfg = configWith("claude-opus-4-8", { scout: "claude-haiku-4-5" });
+		expect(resolveModel(cfg, ROOT, "alias", "builder").model).toBe("claude-opus-4-8");
+	});
+
+	test("falls back to the manifest alias when the provider has no model", () => {
+		expect(resolveModel(configWith(undefined), ROOT, "manifest-alias", "builder").model).toBe(
+			"manifest-alias",
+		);
+	});
+});

package/src/runtimes/resolve.ts

@@ -2,11 +2,12 @@
  * Model resolution — bridge between the agent manifest (which names models by
  * alias) and a concrete {@link ResolvedModel} the runtime can spawn.
  *
- * Phase 2 keeps this deliberately simple: the active provider's configured
- * `model` (set by `agentplate setup`) is the concrete model, and the provider's
- * `authTokenEnv` secret is injected as an env var. Per-capability model tiering
- * (opus/sonnet/haiku) is a later refinement; for now the manifest alias is the
- * fallback when no provider model is configured.
+ * The active provider's configured `model` (set by `agentplate setup`) is the
+ * concrete model, and the provider's `authTokenEnv` secret is injected as an env
+ * var. Per-capability **model tiering** is supported: when a `capability` is given
+ * and the provider has a `models[capability]` override (e.g. a fast model for
+ * `scout`/`reviewer`), that wins; otherwise the provider `model`, otherwise the
+ * manifest alias.
  *
  * Auth mode matters here: only `api-key`/`env` providers inject a credential env
  * var. `subscription` providers delegate to the runtime CLI's own login (e.g. a
@@ -15,7 +16,7 @@
  */
 
 import { getSecret } from "../secrets.ts";
-import type { AgentplateConfig, ResolvedModel } from "../types.ts";
+import type { AgentplateConfig, Capability, ResolvedModel } from "../types.ts";
 
 /**
  * Resolve the concrete model + provider env for a manifest model alias.
@@ -23,14 +24,17 @@ import type { AgentplateConfig, ResolvedModel } from "../types.ts";
  * @param config  loaded Agentplate config
  * @param root    project root (to read the gitignored secret value)
  * @param manifestModel the model alias/id from the agent definition
+ * @param capability optional agent capability for per-capability model tiering
  */
 export function resolveModel(
 	config: AgentplateConfig,
 	root: string,
 	manifestModel: string,
+	capability?: Capability,
 ): ResolvedModel {
 	const provider = config.providers[config.activeProvider];
-	const model = provider?.model ?? manifestModel;
+	const tiered = capability ? provider?.models?.[capability] : undefined;
+	const model = tiered ?? provider?.model ?? manifestModel;
 	const env: Record<string, string> = {};
 
 	// Default to "api-key" for legacy configs written before authMode existed.

package/src/sessions/store.test.ts

@@ -318,6 +318,19 @@ describe("createSessionStore — countActive", () => {
 		store.updateSessionState(s.id, "completed");
 		expect(store.countActive("run-x")).toBe(0);
 	});
+
+	test("countActiveByParent counts a parent's active children only", () => {
+		store.upsertSession(makeSession({ runId: "r", parentAgent: "lead-1", state: "working" }));
+		store.upsertSession(makeSession({ runId: "r", parentAgent: "lead-1", state: "booting" }));
+		const done = makeSession({ runId: "r", parentAgent: "lead-1", state: "completed" });
+		store.upsertSession(done);
+		store.upsertSession(makeSession({ runId: "r", parentAgent: "lead-2", state: "working" }));
+
+		expect(store.countActiveByParent("lead-1", "r")).toBe(2); // excludes the completed child
+		expect(store.countActiveByParent("lead-2", "r")).toBe(1);
+		expect(store.countActiveByParent("lead-1", "other-run")).toBe(0);
+		expect(store.countActiveByParent("nobody")).toBe(0);
+	});
 });
 
 describe("createSessionStore — file-backed database", () => {

package/src/sessions/store.ts

@@ -57,6 +57,7 @@ export interface SessionStore {
 	setRuntimeSessionId(id: string, runtimeSessionId: string): void;
 	touch(id: string): void;
 	countActive(runId?: string): number;
+	countActiveByParent(parentAgent: string, runId?: string): number;
 	// --- Lifecycle ---
 	close(): void;
 }
@@ -328,6 +329,24 @@ export function createSessionStore(dbPath: string): SessionStore {
 		return row.n;
 	}
 
+	function countActiveByParent(parentAgent: string, runId?: string): number {
+		// Active children of a given parent (for the per-lead child cap).
+		if (runId !== undefined) {
+			const row = db
+				.query(
+					`SELECT COUNT(*) AS n FROM sessions WHERE parent_agent = ? AND run_id = ? AND state IN ${ACTIVE_STATES_SQL}`,
+				)
+				.get(parentAgent, runId) as { n: number };
+			return row.n;
+		}
+		const row = db
+			.query(
+				`SELECT COUNT(*) AS n FROM sessions WHERE parent_agent = ? AND state IN ${ACTIVE_STATES_SQL}`,
+			)
+			.get(parentAgent) as { n: number };
+		return row.n;
+	}
+
 	function close(): void {
 		db.close();
 	}
@@ -345,6 +364,7 @@ export function createSessionStore(dbPath: string): SessionStore {
 		setRuntimeSessionId,
 		touch,
 		countActive,
+		countActiveByParent,
 		close,
 	};
 }

package/src/types.ts

@@ -127,6 +127,11 @@ export interface ProviderConfig {
 	authTokenEnv?: string;
 	/** Default model id for this provider. */
 	model?: string;
+	/**
+	 * Per-capability model overrides (tiering): e.g. a fast/cheap model for
+	 * `scout`/`reviewer` and a strong model for `builder`. Falls back to `model`.
+	 */
+	models?: Partial<Record<Capability, string>>;
 }
 
 /** Orchestration limits and agent registry locations. */
@@ -150,10 +155,20 @@ export interface AgentsConfig {
 	idleTimeoutMinutes: number;
 }
 
-/** Conflict-resolution behavior for merging agent branches. */
+/**
+ * When a completed worker's branch is auto-merged into the canonical branch.
+ * - `off`: never (the operator/coordinator merges manually) — the default.
+ * - `on-gates-pass`: merge only if the task's quality gates pass.
+ * - `on-complete`: merge as soon as the agent finishes without error.
+ */
+export type AutoMergeMode = "off" | "on-gates-pass" | "on-complete";
+
+/** Conflict-resolution and auto-merge behavior for merging agent branches. */
 export interface MergeConfig {
 	/** Allow AI-assisted resolution of semantic conflicts. */
 	aiResolveEnabled: boolean;
+	/** When to auto-merge a completed worker's branch into the canonical branch. */
+	autoMerge: AutoMergeMode;
 }
 
 /** Logging behavior. */

package/src/version.ts

@@ -4,4 +4,4 @@
  * Kept as a plain constant (not read from package.json at runtime) so the value
  * is available without filesystem access and survives bundling.
  */
-export const VERSION = "1.1.0";
+export const VERSION = "1.2.0";

package/src/wizard/setup.test.ts

@@ -0,0 +1,45 @@
+/**
+ * Wizard helper tests. The interactive prompts themselves need a TTY, but the
+ * pure pieces are unit-tested directly. `detectQualityGates` reads a project's
+ * package.json to suggest gate commands.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { detectQualityGates } from "./setup.ts";
+
+let dir: string;
+
+beforeEach(() => {
+	dir = mkdtempSync(join(tmpdir(), "agentplate-wizard-"));
+});
+
+afterEach(() => {
+	rmSync(dir, { recursive: true, force: true });
+});
+
+describe("detectQualityGates", () => {
+	test("falls back to stack defaults when there is no package.json", () => {
+		const gates = detectQualityGates(dir);
+		expect(gates).toEqual([
+			{ name: "test", command: "bun test" },
+			{ name: "lint", command: "biome check ." },
+			{ name: "typecheck", command: "tsc --noEmit" },
+		]);
+	});
+
+	test("prefers `bun run <script>` for scripts the project defines", () => {
+		writeFileSync(
+			join(dir, "package.json"),
+			JSON.stringify({ scripts: { test: "vitest", typecheck: "tsc -p ." } }),
+			"utf8",
+		);
+		const gates = detectQualityGates(dir);
+		const byName = Object.fromEntries(gates.map((g) => [g.name, g.command]));
+		expect(byName.test).toBe("bun run test"); // script present → run it
+		expect(byName.typecheck).toBe("bun run typecheck"); // script present
+		expect(byName.lint).toBe("biome check ."); // no lint script → fallback
+	});
+});

package/src/wizard/setup.ts

@@ -7,10 +7,18 @@
  * module owns only the interactive I/O.
  */
 
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import * as p from "@clack/prompts";
 import { applyProviderSelection, buildProviderConfig } from "../providers/apply.ts";
 import { getProviderSpec, listProviders, meetsContextFloor } from "../providers/registry.ts";
-import type { AgentplateConfig, AuthMode } from "../types.ts";
+import type {
+	AgentplateConfig,
+	AuthMode,
+	AutoMergeMode,
+	Capability,
+	QualityGate,
+} from "../types.ts";
 import { commandOnPath, detectDefaultRuntime } from "../utils/detect.ts";
 
 /** Runtimes the wizard can offer. */
@@ -34,6 +42,32 @@ export interface WizardResult {
 	secret?: { key: string; value: string };
 }
 
+/**
+ * Suggest quality gates for a project. Prefers the project's own package.json
+ * scripts (`bun run <script>`) when present, falling back to the Bun/Biome/TS
+ * defaults this stack uses. The user confirms/deselects in the wizard.
+ */
+export function detectQualityGates(root: string): QualityGate[] {
+	let scripts: Record<string, string> = {};
+	try {
+		const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8")) as {
+			scripts?: Record<string, string>;
+		};
+		scripts = pkg.scripts ?? {};
+	} catch {
+		// No package.json (or unreadable) — fall back to stack defaults below.
+	}
+	const gate = (name: string, fallback: string): QualityGate => ({
+		name,
+		command: scripts[name] ? `bun run ${name}` : fallback,
+	});
+	return [
+		gate("test", "bun test"),
+		gate("lint", "biome check ."),
+		gate("typecheck", "tsc --noEmit"),
+	];
+}
+
 /** Abort the wizard cleanly if the user cancelled a prompt. */
 function ensure<T>(value: T | symbol): T {
 	if (p.isCancel(value)) {
@@ -192,6 +226,31 @@ export async function runSetupWizard(currentConfig: AgentplateConfig): Promise<W
 		).trim();
 	}
 
+	// 4b. Model tiering — optionally use a faster/cheaper model for read-only
+	//     roles (scout, reviewer), keeping the chosen model for the rest.
+	let modelsByCapability: Partial<Record<Capability, string>> | undefined;
+	if (eligible.length > 1) {
+		const wantTiering = ensure(
+			await p.confirm({
+				message: "Use a faster/cheaper model for read-only roles (scout & reviewer)?",
+				initialValue: false,
+			}),
+		);
+		if (wantTiering) {
+			const fast = ensure(
+				await p.select({
+					message: "Fast model for scout & reviewer",
+					options: eligible.map((m) => ({
+						value: m.id,
+						label: m.label,
+						hint: `${Math.round(m.contextWindow / 1000)}k context`,
+					})),
+				}),
+			) as string;
+			modelsByCapability = { scout: fast, reviewer: fast };
+		}
+	}
+
 	// 5. Runtime -----------------------------------------------------------
 	const detected = await detectDefaultRuntime();
 	const installed = new Set<string>();
@@ -219,7 +278,50 @@ export async function runSetupWizard(currentConfig: AgentplateConfig): Promise<W
 		}),
 	);
 
-	// 6. Summary -----------------------------------------------------------
+	// 6. Orchestration & merge --------------------------------------------
+	const canonicalBranch = currentConfig.project.canonicalBranch;
+	const suggestedGates = detectQualityGates(currentConfig.project.root || ".");
+	const chosenGateNames = ensure(
+		await p.multiselect({
+			message:
+				"Quality gates to run on a worker's output (used by skill distillation and 'on gates pass' auto-merge)",
+			options: suggestedGates.map((g) => ({ value: g.name, label: g.name, hint: g.command })),
+			initialValues: suggestedGates.map((g) => g.name),
+			required: false,
+		}),
+	) as string[];
+	const qualityGates = suggestedGates.filter((g) => chosenGateNames.includes(g.name));
+
+	const autoMerge = ensure(
+		await p.select({
+			message: `Auto-merge a worker's branch into ${canonicalBranch} when it finishes?`,
+			initialValue: "off",
+			options: [
+				{ value: "off", label: "Never — merge manually", hint: "default; safest" },
+				{
+					value: "on-gates-pass",
+					label: "On quality gates pass",
+					hint: qualityGates.length
+						? "merge only when gates are green"
+						: "needs gates — will hold otherwise",
+				},
+				{
+					value: "on-complete",
+					label: "On complete",
+					hint: "merge as soon as the agent finishes (no gate check)",
+				},
+			],
+		}),
+	) as AutoMergeMode;
+
+	if (autoMerge === "on-gates-pass" && qualityGates.length === 0) {
+		p.note(
+			"No quality gates selected, so 'on gates pass' will hold every merge for manual review.\nAdd gates or pick a different mode to actually auto-merge.",
+			"Heads up",
+		);
+	}
+
+	// 7. Summary -----------------------------------------------------------
 	const previewProvider = buildProviderConfig(spec, model, authMode, baseUrl);
 	const authSummary: Record<AuthMode, string> = {
 		subscription: `subscription / ${runtimeCli(spec.subscriptionRuntime ?? runtime)} login (no key stored)`,
@@ -234,6 +336,11 @@ export async function runSetupWizard(currentConfig: AgentplateConfig): Promise<W
 			`runtime:   ${runtime}`,
 			`auth:      ${authSummary[authMode]}`,
 			previewProvider.baseUrl ? `base URL:  ${previewProvider.baseUrl}` : undefined,
+			`gates:     ${qualityGates.length ? qualityGates.map((g) => g.name).join(", ") : "none"}`,
+			`auto-merge:${autoMerge}`,
+			modelsByCapability?.scout
+				? `fast model: ${modelsByCapability.scout} (scout, reviewer)`
+				: undefined,
 		]
 			.filter(Boolean)
 			.join("\n"),
@@ -248,6 +355,12 @@ export async function runSetupWizard(currentConfig: AgentplateConfig): Promise<W
 		baseUrl,
 		runtime,
 	});
+	config.merge = { ...config.merge, autoMerge };
+	if (qualityGates.length) config.project = { ...config.project, qualityGates };
+	if (modelsByCapability) {
+		const pc = config.providers[providerId];
+		if (pc) config.providers[providerId] = { ...pc, models: modelsByCapability };
+	}
 
 	p.outro("Ready to write configuration.");
 	return secret ? { config, secret } : { config };