@os-eco/overstory-cli 0.6.1 → 0.6.5

package/src/commands/replay.ts

@@ -7,14 +7,16 @@
  */
 
 import { join } from "node:path";
+import { Command } from "commander";
 import { loadConfig } from "../config.ts";
 import { ValidationError } from "../errors.ts";
 import { createEventStore } from "../events/store.ts";
+import type { ColorFn } from "../logging/color.ts";
 import { color } from "../logging/color.ts";
 import type { EventType, StoredEvent } from "../types.ts";
 
 /** Labels and colors for each event type. */
-const EVENT_LABELS: Record<EventType, { label: string; color: string }> = {
+const EVENT_LABELS: Record<EventType, { label: string; color: ColorFn }> = {
 	tool_start: { label: "TOOL START", color: color.blue },
 	tool_end: { label: "TOOL END  ", color: color.blue },
 	session_start: { label: "SESSION  +", color: color.green },
@@ -26,41 +28,14 @@ const EVENT_LABELS: Record<EventType, { label: string; color: string }> = {
 	custom: { label: "CUSTOM    ", color: color.gray },
 };
 
-/** Colors assigned to agents in order of first appearance. */
-const AGENT_COLORS = [color.blue, color.green, color.yellow, color.cyan, color.magenta] as const;
-
-/**
- * Parse a named flag value from args.
- */
-function getFlag(args: string[], flag: string): string | undefined {
-	const idx = args.indexOf(flag);
-	if (idx === -1 || idx + 1 >= args.length) {
-		return undefined;
-	}
-	return args[idx + 1];
-}
-
-/**
- * Parse all occurrences of a named flag from args.
- * Returns an array of values (e.g., --agent a --agent b => ["a", "b"]).
- */
-function getAllFlags(args: string[], flag: string): string[] {
-	const values: string[] = [];
-	for (let i = 0; i < args.length; i++) {
-		if (args[i] === flag && i + 1 < args.length) {
-			const value = args[i + 1];
-			if (value !== undefined) {
-				values.push(value);
-			}
-			i++; // skip the value
-		}
-	}
-	return values;
-}
-
-function hasFlag(args: string[], flag: string): boolean {
-	return args.includes(flag);
-}
+/** Color functions assigned to agents in order of first appearance. */
+const AGENT_COLORS: readonly ColorFn[] = [
+	color.blue,
+	color.green,
+	color.yellow,
+	color.cyan,
+	color.magenta,
+];
 
 /**
  * Format a relative time string from a timestamp.
@@ -150,16 +125,16 @@ function buildEventDetail(event: StoredEvent): string {
 }
 
 /**
- * Assign a stable color to each agent based on order of first appearance.
+ * Assign a stable color function to each agent based on order of first appearance.
  */
-function buildAgentColorMap(events: StoredEvent[]): Map<string, string> {
-	const colorMap = new Map<string, string>();
+function buildAgentColorMap(events: StoredEvent[]): Map<string, ColorFn> {
+	const colorMap = new Map<string, ColorFn>();
 	for (const event of events) {
 		if (!colorMap.has(event.agentName)) {
 			const colorIndex = colorMap.size % AGENT_COLORS.length;
-			const color = AGENT_COLORS[colorIndex];
-			if (color !== undefined) {
-				colorMap.set(event.agentName, color);
+			const agentColorFn = AGENT_COLORS[colorIndex];
+			if (agentColorFn !== undefined) {
+				colorMap.set(event.agentName, agentColorFn);
 			}
 		}
 	}
@@ -172,15 +147,15 @@ function buildAgentColorMap(events: StoredEvent[]): Map<string, string> {
 function printReplay(events: StoredEvent[], useAbsoluteTime: boolean): void {
 	const w = process.stdout.write.bind(process.stdout);
 
-	w(`${color.bold}Replay${color.reset}\n`);
+	w(`${color.bold("Replay")}\n`);
 	w(`${"=".repeat(70)}\n`);
 
 	if (events.length === 0) {
-		w(`${color.dim}No events found.${color.reset}\n`);
+		w(`${color.dim("No events found.")}\n`);
 		return;
 	}
 
-	w(`${color.dim}${events.length} event${events.length === 1 ? "" : "s"}${color.reset}\n\n`);
+	w(`${color.dim(`${events.length} event${events.length === 1 ? "" : "s"}`)}\n\n`);
 
 	const colorMap = buildAgentColorMap(events);
 	let lastDate = "";
@@ -192,7 +167,7 @@ function printReplay(events: StoredEvent[], useAbsoluteTime: boolean): void {
 			if (lastDate !== "") {
 				w("\n");
 			}
-			w(`${color.dim}--- ${date} ---${color.reset}\n`);
+			w(`${color.dim(`--- ${date} ---`)}\n`);
 			lastDate = date;
 		}
 
@@ -205,57 +180,40 @@ function printReplay(events: StoredEvent[], useAbsoluteTime: boolean): void {
 			color: color.gray,
 		};
 
-		const levelColor =
-			event.level === "error" ? color.red : event.level === "warn" ? color.yellow : "";
-		const levelReset = levelColor ? color.reset : "";
+		const levelColorFn =
+			event.level === "error" ? color.red : event.level === "warn" ? color.yellow : null;
+		const applyLevel = (text: string) => (levelColorFn ? levelColorFn(text) : text);
 
 		const detail = buildEventDetail(event);
-		const detailSuffix = detail ? ` ${color.dim}${detail}${color.reset}` : "";
+		const detailSuffix = detail ? ` ${color.dim(detail)}` : "";
 
-		const agentColor = colorMap.get(event.agentName) ?? color.gray;
-		const agentLabel = ` ${agentColor}[${event.agentName}]${color.reset}`;
+		const agentColorFn = colorMap.get(event.agentName) ?? color.gray;
+		const agentLabel = ` ${agentColorFn(`[${event.agentName}]`)}`;
 
 		w(
-			`${color.dim}${timeStr.padStart(10)}${color.reset} ` +
-				`${levelColor}${eventInfo.color}${color.bold}${eventInfo.label}${color.reset}${levelReset}` +
+			`${color.dim(timeStr.padStart(10))} ` +
+				`${applyLevel(eventInfo.color(color.bold(eventInfo.label)))}` +
 				`${agentLabel}${detailSuffix}\n`,
 		);
 	}
 }
 
-const REPLAY_HELP = `overstory replay -- Interleaved chronological replay across agents
-
-Usage: overstory replay [options]
-
-Options:
-  --run <id>             Filter events by run ID
-  --agent <name>         Filter by agent name (can appear multiple times)
-  --since <timestamp>    Start time filter (ISO 8601)
-  --until <timestamp>    End time filter (ISO 8601)
-  --limit <n>            Max events to show (default: 200)
-  --json                 Output as JSON array of StoredEvent objects
-  --help, -h             Show this help
-
-If --run is specified, shows all events from that run.
-If --agent is specified, shows events from those agents merged chronologically.
-If neither is specified, tries to read the current run from .overstory/current-run.txt.
-Falls back to a 24-hour timeline of all events.`;
-
-/**
- * Entry point for `overstory replay [--run <id>] [--agent <name>...] [--json]`.
- */
-export async function replayCommand(args: string[]): Promise<void> {
-	if (args.includes("--help") || args.includes("-h")) {
-		process.stdout.write(`${REPLAY_HELP}\n`);
-		return;
-	}
+interface ReplayOpts {
+	run?: string;
+	agent: string[]; // repeatable
+	since?: string;
+	until?: string;
+	limit?: string;
+	json?: boolean;
+}
 
-	const json = hasFlag(args, "--json");
-	const runId = getFlag(args, "--run");
-	const agentNames = getAllFlags(args, "--agent");
-	const sinceStr = getFlag(args, "--since");
-	const untilStr = getFlag(args, "--until");
-	const limitStr = getFlag(args, "--limit");
+async function executeReplay(opts: ReplayOpts): Promise<void> {
+	const json = opts.json ?? false;
+	const runId = opts.run;
+	const agentNames = opts.agent;
+	const sinceStr = opts.since;
+	const untilStr = opts.until;
+	const limitStr = opts.limit;
 	const limit = limitStr ? Number.parseInt(limitStr, 10) : 200;
 
 	if (Number.isNaN(limit) || limit < 1) {
@@ -358,3 +316,38 @@ export async function replayCommand(args: string[]): Promise<void> {
 		eventStore.close();
 	}
 }
+
+export function createReplayCommand(): Command {
+	return new Command("replay")
+		.description("Interleaved chronological replay across agents")
+		.option("--run <id>", "Filter events by run ID")
+		.option(
+			"--agent <name>",
+			"Filter by agent name (can appear multiple times)",
+			(val: string, prev: string[]) => [...prev, val],
+			[] as string[],
+		)
+		.option("--since <timestamp>", "Start time filter (ISO 8601)")
+		.option("--until <timestamp>", "End time filter (ISO 8601)")
+		.option("--limit <n>", "Max events to show (default: 200)")
+		.option("--json", "Output as JSON array of StoredEvent objects")
+		.action(async (opts: ReplayOpts) => {
+			await executeReplay(opts);
+		});
+}
+
+export async function replayCommand(args: string[]): Promise<void> {
+	const cmd = createReplayCommand();
+	cmd.exitOverride();
+	try {
+		await cmd.parseAsync(args, { from: "user" });
+	} catch (err: unknown) {
+		if (err && typeof err === "object" && "code" in err) {
+			const code = (err as { code: string }).code;
+			if (code === "commander.helpDisplayed" || code === "commander.version") {
+				return;
+			}
+		}
+		throw err;
+	}
+}

package/src/commands/run.test.ts

@@ -68,7 +68,7 @@ function makeSession(overrides: Partial<AgentSession> = {}): AgentSession {
 		capability: "builder",
 		worktreePath: "/tmp/worktrees/test-agent",
 		branchName: "overstory/test-agent/task-1",
-		beadId: "task-1",
+		taskId: "task-1",
 		tmuxSession: "overstory-test-agent",
 		state: "working",
 		pid: 12345,

package/src/commands/run.ts

@@ -12,39 +12,12 @@
  */
 
 import { join } from "node:path";
+import { Command, CommanderError } from "commander";
 import { loadConfig } from "../config.ts";
+import { ValidationError } from "../errors.ts";
 import { createRunStore, createSessionStore } from "../sessions/store.ts";
 import type { AgentSession, Run } from "../types.ts";
 
-const RUN_HELP = `overstory run -- Manage runs (coordinator session groupings)
-
-Usage: overstory run [subcommand] [options]
-
-Subcommands:
-  (default)          Show current run status
-  list [--last <n>]  List recent runs (default last 10)
-  complete           Mark current run as completed
-  show <id>          Show run details (agents, duration)
-
-Options:
-  --json             Output as JSON
-  --help, -h         Show this help`;
-
-/**
- * Parse a named flag value from args.
- */
-function getFlag(args: string[], flag: string): string | undefined {
-	const idx = args.indexOf(flag);
-	if (idx === -1 || idx + 1 >= args.length) {
-		return undefined;
-	}
-	return args[idx + 1];
-}
-
-function hasFlag(args: string[], flag: string): boolean {
-	return args.includes(flag);
-}
-
 /**
  * Format milliseconds as human-readable duration.
  */
@@ -90,6 +63,18 @@ function runDuration(run: Run): string {
 	return formatDuration(end - start);
 }
 
+/**
+ * Format an agent's duration from startedAt to now (or completion).
+ */
+function formatAgentDuration(agent: AgentSession): string {
+	const start = new Date(agent.startedAt).getTime();
+	const end =
+		agent.state === "completed" || agent.state === "zombie"
+			? new Date(agent.lastActivity).getTime()
+			: Date.now();
+	return formatDuration(end - start);
+}
+
 /**
  * Show current run status (default subcommand).
  */
@@ -291,61 +276,96 @@ async function showRun(overstoryDir: string, runId: string, json: boolean): Prom
 	}
 }
 
-/**
- * Format an agent's duration from startedAt to now (or completion).
- */
-function formatAgentDuration(agent: AgentSession): string {
-	const start = new Date(agent.startedAt).getTime();
-	const end =
-		agent.state === "completed" || agent.state === "zombie"
-			? new Date(agent.lastActivity).getTime()
-			: Date.now();
-	return formatDuration(end - start);
+interface RunDefaultOpts {
+	json?: boolean;
 }
 
-/**
- * Entry point for `overstory run [subcommand] [options]`.
- */
-export async function runCommand(args: string[]): Promise<void> {
-	if (args.includes("--help") || args.includes("-h")) {
-		process.stdout.write(`${RUN_HELP}\n`);
-		return;
-	}
+interface RunListOpts {
+	last?: string;
+	json?: boolean;
+}
 
-	const json = hasFlag(args, "--json");
-	const cwd = process.cwd();
-	const config = await loadConfig(cwd);
-	const overstoryDir = join(config.project.root, ".overstory");
+interface RunShowOpts {
+	json?: boolean;
+}
 
-	const subcommand = args[0];
+interface RunCompleteOpts {
+	json?: boolean;
+}
 
-	switch (subcommand) {
-		case "list": {
-			const lastStr = getFlag(args, "--last");
+export function createRunCommand(): Command {
+	const cmd = new Command("run").description("Manage runs (coordinator session groupings)");
+
+	// Default action (bare `overstory run`)
+	cmd.option("--json", "Output as JSON").action(async (opts: RunDefaultOpts) => {
+		const cwd = process.cwd();
+		const config = await loadConfig(cwd);
+		const overstoryDir = join(config.project.root, ".overstory");
+		await showCurrentRun(overstoryDir, opts.json ?? false);
+	});
+
+	// `overstory run list`
+	cmd
+		.command("list")
+		.description("List recent runs")
+		.option("--last <n>", "Number of recent runs to show (default: 10)")
+		.option("--json", "Output as JSON")
+		.action(async (opts: RunListOpts) => {
+			const lastStr = opts.last;
 			const limit = lastStr ? Number.parseInt(lastStr, 10) : 10;
-			await listRuns(overstoryDir, limit, json);
-			break;
-		}
-		case "complete":
-			await completeCurrentRun(overstoryDir, json);
-			break;
-		case "show": {
-			const runId = args[1];
-			if (!runId || runId.startsWith("--")) {
-				if (json) {
-					process.stdout.write('{"error":"Missing run ID. Usage: overstory run show <id>"}\n');
-				} else {
-					process.stderr.write("Missing run ID. Usage: overstory run show <id>\n");
-				}
-				process.exitCode = 1;
-				return;
+			if (Number.isNaN(limit) || limit < 1) {
+				throw new ValidationError("--last must be a positive integer", {
+					field: "last",
+					value: lastStr,
+				});
 			}
-			await showRun(overstoryDir, runId, json);
-			break;
+			const cwd = process.cwd();
+			const config = await loadConfig(cwd);
+			const overstoryDir = join(config.project.root, ".overstory");
+			await listRuns(overstoryDir, limit, opts.json ?? false);
+		});
+
+	// `overstory run show <id>`
+	cmd
+		.command("show")
+		.description("Show run details (agents, duration)")
+		.argument("<id>", "Run ID")
+		.option("--json", "Output as JSON")
+		.action(async (id: string, opts: RunShowOpts) => {
+			const cwd = process.cwd();
+			const config = await loadConfig(cwd);
+			const overstoryDir = join(config.project.root, ".overstory");
+			await showRun(overstoryDir, id, opts.json ?? false);
+		});
+
+	// `overstory run complete`
+	cmd
+		.command("complete")
+		.description("Mark current run as completed")
+		.option("--json", "Output as JSON")
+		.action(async (opts: RunCompleteOpts) => {
+			const cwd = process.cwd();
+			const config = await loadConfig(cwd);
+			const overstoryDir = join(config.project.root, ".overstory");
+			await completeCurrentRun(overstoryDir, opts.json ?? false);
+		});
+
+	return cmd;
+}
+
+export async function runCommand(args: string[]): Promise<void> {
+	const program = new Command("overstory").exitOverride().configureOutput({
+		writeOut: (str) => process.stdout.write(str),
+		writeErr: (str) => process.stderr.write(str),
+	});
+	program.addCommand(createRunCommand());
+	try {
+		await program.parseAsync(["node", "overstory", "run", ...args]);
+	} catch (err: unknown) {
+		if (err instanceof CommanderError) {
+			if (err.code === "commander.helpDisplayed" || err.code === "commander.version") return;
+			throw new ValidationError(err.message, { field: "args" });
 		}
-		default:
-			// Default: show current run status
-			await showCurrentRun(overstoryDir, json);
-			break;
+		throw err;
 	}
 }

package/src/commands/sling.test.ts

@@ -1,5 +1,7 @@
 import { describe, expect, test } from "bun:test";
+import { resolveModel, resolveProviderEnv } from "../agents/manifest.ts";
 import { HierarchyError } from "../errors.ts";
+import type { AgentManifest, OverstoryConfig } from "../types.ts";
 import {
 	type BeaconOptions,
 	buildBeacon,
@@ -552,13 +554,13 @@ describe("isRunningAsRoot", () => {
 /**
  * Tests for checkBeadLock.
  *
- * checkBeadLock prevents concurrent agents from working the same bead ID.
+ * checkBeadLock prevents concurrent agents from working the same task ID.
  * It checks the active session list and returns the agent name that holds
  * the lock (i.e., is already working on the bead), or null if the bead is free.
  */
 
-function makeBeadSession(agentName: string, beadId: string): { agentName: string; beadId: string } {
-	return { agentName, beadId };
+function makeBeadSession(agentName: string, taskId: string): { agentName: string; taskId: string } {
+	return { agentName, taskId };
 }
 
 describe("checkBeadLock", () => {
@@ -566,7 +568,7 @@ describe("checkBeadLock", () => {
 		expect(checkBeadLock([], "overstory-abc")).toBeNull();
 	});
 
-	test("returns null when no session matches the bead ID", () => {
+	test("returns null when no session matches the task ID", () => {
 		const sessions = [
 			makeBeadSession("builder-1", "overstory-xyz"),
 			makeBeadSession("builder-2", "overstory-def"),
@@ -585,7 +587,7 @@ describe("checkBeadLock", () => {
 	});
 
 	test("returns the first matching agent when multiple sessions match", () => {
-		// Multiple sessions can have the same beadId (e.g., retried agent)
+		// Multiple sessions can have the same taskId (e.g., retried agent)
 		// checkBeadLock returns the first match
 		const sessions = [
 			makeBeadSession("builder-1", "overstory-abc"),
@@ -655,3 +657,197 @@ describe("checkRunSessionLimit", () => {
 		expect(checkRunSessionLimit(-1, 100)).toBe(false);
 	});
 });
+
+/**
+ * Tests for sling provider env injection building blocks.
+ *
+ * In slingCommand, resolveModel() is called to get the { model, env } for the
+ * spawned agent. The env dict is then spread into createSession's env parameter
+ * alongside OVERSTORY_AGENT_NAME and OVERSTORY_WORKTREE_PATH:
+ *
+ *   const { model, env } = resolveModel(config, manifest, capability, agentDef.model);
+ *   const pid = await createSession(tmuxSessionName, worktreePath, claudeCmd, {
+ *       ...env,
+ *       OVERSTORY_AGENT_NAME: name,
+ *       OVERSTORY_WORKTREE_PATH: worktreePath,
+ *   });
+ *
+ * These tests verify the building blocks: that resolveModel and resolveProviderEnv
+ * produce the correct env dicts for the provider scenarios sling will encounter.
+ */
+
+function makeConfig(
+	models: OverstoryConfig["models"] = {},
+	providers: OverstoryConfig["providers"] = { anthropic: { type: "native" } },
+): OverstoryConfig {
+	return {
+		project: { name: "test", root: "/tmp/test", canonicalBranch: "main" },
+		agents: {
+			manifestPath: ".overstory/agent-manifest.json",
+			baseDir: ".overstory/agent-defs",
+			maxConcurrent: 5,
+			staggerDelayMs: 0,
+			maxDepth: 2,
+			maxSessionsPerRun: 0,
+		},
+		worktrees: { baseDir: ".overstory/worktrees" },
+		taskTracker: { backend: "auto", enabled: false },
+		mulch: { enabled: false, domains: [], primeFormat: "markdown" },
+		merge: { aiResolveEnabled: false, reimagineEnabled: false },
+		providers,
+		watchdog: {
+			tier0Enabled: false,
+			tier0IntervalMs: 30_000,
+			tier1Enabled: false,
+			tier2Enabled: false,
+			staleThresholdMs: 300_000,
+			zombieThresholdMs: 600_000,
+			nudgeIntervalMs: 60_000,
+		},
+		models,
+		logging: { verbose: false, redactSecrets: true },
+	};
+}
+
+function makeManifest(): AgentManifest {
+	return {
+		version: "1.0",
+		agents: {
+			builder: {
+				file: "builder.md",
+				model: "opus",
+				tools: ["Read", "Write", "Edit", "Bash"],
+				capabilities: ["implement"],
+				canSpawn: false,
+				constraints: [],
+			},
+			coordinator: {
+				file: "coordinator.md",
+				model: "sonnet",
+				tools: ["Read", "Bash"],
+				capabilities: ["coordinate"],
+				canSpawn: true,
+				constraints: [],
+			},
+		},
+		capabilityIndex: { implement: ["builder"], coordinate: ["coordinator"] },
+	};
+}
+
+describe("sling provider env injection building blocks", () => {
+	test("resolveModel produces env for gateway provider in config override scenario", () => {
+		const config = makeConfig(
+			{ builder: "openrouter/anthropic/claude-3-5-sonnet" },
+			{ openrouter: { type: "gateway", baseUrl: "https://openrouter.ai/api/v1" } },
+		);
+		const manifest = makeManifest();
+
+		const result = resolveModel(config, manifest, "builder", "sonnet");
+
+		expect(result.model).toBe("sonnet");
+		expect(result.env).toBeDefined();
+		expect(result.env?.ANTHROPIC_BASE_URL).toBe("https://openrouter.ai/api/v1");
+		expect(result.env?.ANTHROPIC_API_KEY).toBe("");
+		expect(result.env?.ANTHROPIC_DEFAULT_SONNET_MODEL).toBe("anthropic/claude-3-5-sonnet");
+	});
+
+	test("env dict from resolveModel can be spread with OVERSTORY_AGENT_NAME and OVERSTORY_WORKTREE_PATH", () => {
+		const config = makeConfig(
+			{ builder: "openrouter/anthropic/claude-3-5-sonnet" },
+			{ openrouter: { type: "gateway", baseUrl: "https://openrouter.ai/api/v1" } },
+		);
+		const manifest = makeManifest();
+
+		const { env } = resolveModel(config, manifest, "builder", "sonnet");
+		// Simulates the spread in slingCommand: { ...env, OVERSTORY_AGENT_NAME: name, OVERSTORY_WORKTREE_PATH: wt }
+		const combined: Record<string, string> = {
+			...(env ?? {}),
+			OVERSTORY_AGENT_NAME: "test-builder",
+			OVERSTORY_WORKTREE_PATH: "/tmp/wt",
+		};
+
+		expect(combined.ANTHROPIC_BASE_URL).toBe("https://openrouter.ai/api/v1");
+		expect(combined.ANTHROPIC_API_KEY).toBe("");
+		expect(combined.OVERSTORY_AGENT_NAME).toBe("test-builder");
+		expect(combined.OVERSTORY_WORKTREE_PATH).toBe("/tmp/wt");
+	});
+
+	test("resolveModel returns no env for native anthropic provider", () => {
+		const config = makeConfig({ builder: "sonnet" }, { anthropic: { type: "native" } });
+		const manifest = makeManifest();
+
+		const result = resolveModel(config, manifest, "builder", "sonnet");
+
+		expect(result.model).toBe("sonnet");
+		expect(result.env).toBeUndefined();
+	});
+
+	test("resolveModel returns no env when model is a simple alias from manifest default", () => {
+		// No models override: manifest builder model "opus" is a simple alias
+		const config = makeConfig({}, {});
+		const manifest = makeManifest();
+
+		const result = resolveModel(config, manifest, "builder", "sonnet");
+
+		expect(result.model).toBe("opus");
+		expect(result.env).toBeUndefined();
+	});
+
+	test("resolveProviderEnv includes ANTHROPIC_AUTH_TOKEN when authTokenEnv var is set", () => {
+		const providers = {
+			openrouter: {
+				type: "gateway" as const,
+				baseUrl: "https://openrouter.ai/api/v1",
+				authTokenEnv: "MY_API_KEY",
+			},
+		};
+		const env = { MY_API_KEY: "sk-test-123" };
+
+		const result = resolveProviderEnv("openrouter", "anthropic/claude-3-5-sonnet", providers, env);
+
+		expect(result).not.toBeNull();
+		expect(result?.ANTHROPIC_AUTH_TOKEN).toBe("sk-test-123");
+	});
+
+	test("resolveProviderEnv omits ANTHROPIC_AUTH_TOKEN when authTokenEnv var is absent", () => {
+		const providers = {
+			openrouter: {
+				type: "gateway" as const,
+				baseUrl: "https://openrouter.ai/api/v1",
+				authTokenEnv: "MY_API_KEY",
+			},
+		};
+		const env: Record<string, string | undefined> = {};
+
+		const result = resolveProviderEnv("openrouter", "anthropic/claude-3-5-sonnet", providers, env);
+
+		expect(result).not.toBeNull();
+		expect(result?.ANTHROPIC_AUTH_TOKEN).toBeUndefined();
+	});
+
+	test("resolveModel produces different env dicts for coordinator and builder with different gateway providers", () => {
+		const config = makeConfig(
+			{
+				coordinator: "openrouter/anthropic/claude-3-5-sonnet",
+				builder: "litellm/anthropic/claude-3-5-haiku",
+			},
+			{
+				openrouter: { type: "gateway", baseUrl: "https://openrouter.ai/api/v1" },
+				litellm: { type: "gateway", baseUrl: "https://litellm.example.com/v1" },
+			},
+		);
+		const manifest = makeManifest();
+
+		const coordinatorResult = resolveModel(config, manifest, "coordinator", "sonnet");
+		const builderResult = resolveModel(config, manifest, "builder", "sonnet");
+
+		expect(coordinatorResult.model).toBe("sonnet");
+		expect(builderResult.model).toBe("sonnet");
+		expect(coordinatorResult.env?.ANTHROPIC_BASE_URL).toBe("https://openrouter.ai/api/v1");
+		expect(builderResult.env?.ANTHROPIC_BASE_URL).toBe("https://litellm.example.com/v1");
+		expect(coordinatorResult.env?.ANTHROPIC_DEFAULT_SONNET_MODEL).toBe(
+			"anthropic/claude-3-5-sonnet",
+		);
+		expect(builderResult.env?.ANTHROPIC_DEFAULT_SONNET_MODEL).toBe("anthropic/claude-3-5-haiku");
+	});
+});