@sns-myagent/cli 0.2.0 → 0.3.1

package/src/adapters/telegram/bridge.ts

@@ -0,0 +1,186 @@
+/**
+ * Telegram ↔ Agent bridge.
+ *
+ * Creates per-chat agent sessions via the SDK `createAgentSession()` API.
+ * Each chat ID gets its own persistent session (auto-created on first message).
+ *
+ * The `createForwardToAgent()` factory returns a `ForwardToAgent` function
+ * that the TelegramBot handler calls for every `/chat` and freeform message.
+ */
+
+import { createAgentSession, type CreateAgentSessionResult } from "../../sdk.js";
+import type { AgentSession } from "../../session/agent-session.js";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
+import { sanitizeText } from "@oh-my-pi/pi-utils";
+import { loadConfig } from "../../config/loader.js";
+import { initializeExtensions } from "../../modes/runtime-init.js";
+
+/** Internal session record. */
+interface ChatRecord {
+  result: CreateAgentSessionResult;
+  session: AgentSession;
+  createdAt: number;
+}
+
+/** ForwardToAgent signature — matches handler.ts ForwardToAgent. */
+export type ForwardToAgentFn = (
+  chatId: string,
+  userId: string,
+  text: string,
+) => Promise<string>;
+
+/**
+ * TTL cache: chatId → ChatRecord.
+ * Sessions auto-expire after `maxIdleMs` of inactivity.
+ */
+class SessionCache {
+  readonly #cache = new Map<string, ChatRecord>();
+  readonly #maxIdleMs: number;
+
+  constructor(maxIdleMs = 30 * 60 * 1000) {
+    this.#maxIdleMs = maxIdleMs;
+  }
+
+  get(chatId: string): ChatRecord | undefined {
+    const rec = this.#cache.get(chatId);
+    if (!rec) return undefined;
+    // Check idle expiry
+    if (Date.now() - rec.createdAt > this.#maxIdleMs) {
+      this.#cache.delete(chatId);
+      return undefined;
+    }
+    return rec;
+  }
+
+  set(chatId: string, record: ChatRecord): void {
+    this.#cache.set(chatId, record);
+  }
+
+  delete(chatId: string): void {
+    this.#cache.delete(chatId);
+  }
+
+  clear(): void {
+    this.#cache.clear();
+  }
+
+  get size(): number {
+    return this.#cache.size;
+  }
+
+  keys(): IterableIterator<string> {
+    return this.#cache.keys();
+  }
+}
+
+const sessionCache = new SessionCache();
+
+/**
+ * Extract the assistant's text response from a session after prompt().
+ */
+function extractAssistantText(session: AgentSession): string {
+  const msgs = session.state.messages;
+  for (let i = msgs.length - 1; i >= 0; i--) {
+    const msg = msgs[i];
+    if (msg && msg.role === "assistant") {
+      const asst = msg as AssistantMessage;
+      if (asst.stopReason === "error" || asst.stopReason === "aborted") {
+        return `⚠️ ${sanitizeText(asst.errorMessage || `Request ${asst.stopReason}`)}`;
+      }
+      const parts: string[] = [];
+      for (const c of asst.content) {
+        if (c.type === "text") parts.push(sanitizeText(c.text));
+      }
+      if (parts.length > 0) return parts.join("\n");
+    }
+  }
+  return "⚠️ No response from agent.";
+}
+
+/**
+ * Create or retrieve an agent session for a chatId.
+ */
+async function getOrCreateSession(chatId: string): Promise<AgentSession> {
+  const existing = sessionCache.get(chatId);
+  if (existing) return existing.session;
+
+  const cfg = loadConfig();
+  const cwd = process.cwd();
+
+  const result = await createAgentSession({
+    cwd,
+    autoApprove: true,
+  });
+
+  const session = result.session;
+
+  // Subscribe for persistence (required by print-mode pattern)
+  session.subscribe(() => {});
+
+  // Initialize extensions (lightweight, no TUI)
+  await initializeExtensions(session, {
+    reportSendError: (_action, err) => {
+      console.error(`[telegram-bridge] extension error: ${err.message}`);
+    },
+    reportRuntimeError: (err) => {
+      console.error(`[telegram-bridge] runtime error: ${err.error}`);
+    },
+  });
+
+  sessionCache.set(chatId, {
+    result,
+    session,
+    createdAt: Date.now(),
+  });
+
+  console.error(`[telegram-bridge] created session for chat=${chatId} (cache=${sessionCache.size})`);
+  return session;
+}
+
+/**
+ * Create the forwardToAgent function that the TelegramBot handler calls.
+ *
+ * Usage in CLI:
+ *   const forwardToAgent = createForwardToAgent();
+ *   startTelegramAdapter(token, { autostart: true, forwardToAgent });
+ */
+export function createForwardToAgent(): ForwardToAgentFn {
+  return async (chatId, _userId, text): Promise<string> => {
+    try {
+      const session = await getOrCreateSession(chatId);
+
+      // session.prompt() returns true (agent processed) or false (slash-command consumed)
+      const handled = await session.prompt(text);
+
+      if (!handled) {
+        // Slash command consumed it — no LLM response to return
+        return "✅ Command processed.";
+      }
+
+      return extractAssistantText(session);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`[telegram-bridge] forwardToAgent error: ${msg}`);
+      return `⚠️ Agent error: ${msg}`;
+    }
+  };
+}
+
+/**
+ * Reset a specific chat session (for /reset command).
+ */
+export function resetChatSession(chatId: string): boolean {
+  const had = sessionCache.get(chatId) !== undefined;
+  sessionCache.delete(chatId);
+  return had;
+}
+
+/**
+ * Get bridge stats (for /status).
+ */
+export function getBridgeStats(): { activeSessions: number; chatIds: string[] } {
+  return {
+    activeSessions: sessionCache.size,
+    chatIds: [...sessionCache.keys()],
+  };
+}

package/src/adapters/telegram/handler.ts

@@ -12,12 +12,18 @@ import { logger } from "@oh-my-pi/pi-utils";
 export type ParsedMessage =
 	| { kind: "command"; command: TelegramCommand; args: string; raw: string; userId: number; chatId: number; messageId: number }
 	| { kind: "chat"; text: string; userId: number; chatId: number; messageId: number }
+	| { kind: "file"; fileId: string; fileName: string; mimeType: string; caption: string; userId: number; chatId: number; messageId: number }
 	| { kind: "empty"; userId: number; chatId: number; messageId: number };
 
-export type TelegramCommand = "start" | "help" | "chat" | "reset" | "status";
+export type TelegramCommand =
+  | "start" | "help" | "chat" | "reset" | "status"
+  | "memory" | "cron" | "model" | "code" | "review" | "task";
 
 /** Commands we recognise, mapped to their canonical name. */
-const COMMANDS: ReadonlySet<string> = new Set(["start", "help", "chat", "reset", "status"]);
+const COMMANDS: ReadonlySet<string> = new Set([
+  "start", "help", "chat", "reset", "status",
+  "memory", "cron", "model", "code", "review", "task",
+]);
 
 /**
  * Parse a grammY `Message` into a `ParsedMessage`. Returns `kind: "empty"`
@@ -29,6 +35,59 @@ export function parseMessage(msg: Message): ParsedMessage {
 	const messageId = msg.message_id;
 	const text = (msg.text ?? msg.caption ?? "").trim();
 
+	// Detect file attachments (document, photo, video, audio, voice)
+	if (msg.document) {
+		return {
+			kind: "file",
+			fileId: msg.document.file_id,
+			fileName: msg.document.file_name ?? "file",
+			mimeType: msg.document.mime_type ?? "application/octet-stream",
+			caption: text,
+			userId, chatId, messageId,
+		};
+	}
+	if (msg.photo && msg.photo.length > 0) {
+		const largest = msg.photo[msg.photo.length - 1]!;
+		return {
+			kind: "file",
+			fileId: largest.file_id,
+			fileName: `photo_${messageId}.jpg`,
+			mimeType: "image/jpeg",
+			caption: text,
+			userId, chatId, messageId,
+		};
+	}
+	if (msg.video) {
+		return {
+			kind: "file",
+			fileId: msg.video.file_id,
+			fileName: msg.video.file_name ?? `video_${messageId}.mp4`,
+			mimeType: msg.video.mime_type ?? "video/mp4",
+			caption: text,
+			userId, chatId, messageId,
+		};
+	}
+	if (msg.voice) {
+		return {
+			kind: "file",
+			fileId: msg.voice.file_id,
+			fileName: `voice_${messageId}.ogg`,
+			mimeType: msg.voice.mime_type ?? "audio/ogg",
+			caption: text,
+			userId, chatId, messageId,
+		};
+	}
+	if (msg.audio) {
+		return {
+			kind: "file",
+			fileId: msg.audio.file_id,
+			fileName: msg.audio.file_name ?? `audio_${messageId}.mp3`,
+			mimeType: msg.audio.mime_type ?? "audio/mpeg",
+			caption: text,
+			userId, chatId, messageId,
+		};
+	}
+
 	if (text.length === 0) {
 		return { kind: "empty", userId, chatId, messageId };
 	}
@@ -73,15 +132,22 @@ export const COMMAND_REPLIES: Record<TelegramCommand, string> = {
 		"/help — list commands (this message)\n" +
 		"/chat \\<message\\> — send a prompt to the agent explicitly\n" +
 		"/reset — clear the per\\-chat conversation context\n" +
-		"/status — show adapter health\n\n" +
+		"/status — show adapter health + bridge stats\n" +
+		"/memory — show agent memory usage\n" +
+		"/cron — show cron jobs\n" +
+		"/model — show current model\n" +
+		"/code \\<task\\> — send a coding task to the agent\n" +
+		"/review \\<task\\> — ask the agent to review code\n\n" +
 		"Anything that isn't a command is also forwarded to the agent.",
 	chat: "", // computed dynamically when invoked
-	reset: "Context cleared for this chat. Next message starts a fresh thread.",
-	status:
-		"*Adapter status*\n\n" +
-		"• transport: polling\n" +
-		"• backend: grammY v1\n" +
-		"• agent: stub \\(Phase 2 will wire real session\\)",
+	reset: "", // computed dynamically when invoked
+	status: "", // computed dynamically when invoked
+	memory: "", // forwarded to agent
+	cron: "", // forwarded to agent
+	model: "", // forwarded to agent
+	code: "", // forwarded to agent
+	review: "", // forwarded to agent
+	task: "", // forwarded to agent
 };
 
 export interface HandleContext {
@@ -89,6 +155,12 @@ export interface HandleContext {
 	readonly sessionKey: string;
 	/** Optional callback that the real agent integration replaces. */
 	forwardToAgent?: (text: string, sessionKey: string) => Promise<string>;
+	/** Optional callback to reset a chat session (bridge). */
+	resetChatSession?: (chatId: string) => boolean;
+	/** Optional callback to get bridge stats. */
+	getBridgeStats?: () => { activeSessions: number; chatIds: string[] };
+	/** Optional callback to download a Telegram file to local path. */
+	downloadFile?: (fileId: string, fileName: string) => Promise<string>;
 }
 
 /**
@@ -100,24 +172,77 @@ export async function resolveReply(parsed: ParsedMessage, ctx: HandleContext): P
 	switch (parsed.kind) {
 		case "empty":
 			return "I can only read text right now. Send a message and I'll forward it to the agent.";
+
 		case "command": {
 			switch (parsed.command) {
 				case "start":
 				case "help":
-				case "reset":
-				case "status":
 					return COMMAND_REPLIES[parsed.command];
+
+				case "reset": {
+					if (ctx.resetChatSession) {
+						const had = ctx.resetChatSession(ctx.sessionKey);
+						return had
+							? "Context cleared for this chat. Next message starts a fresh thread."
+							: "No active session for this chat. Next message will start one.";
+					}
+					return "Context cleared for this chat. Next message starts a fresh thread.";
+				}
+
+				case "status": {
+					const stats = ctx.getBridgeStats?.();
+					const sessions = stats ? stats.activeSessions : 0;
+					return (
+						"*Adapter status*\n\n" +
+						"• transport: polling\n" +
+						"• backend: grammY v1\n" +
+						`• agent sessions: ${sessions}\n` +
+						"• bridge: wired ✓"
+					);
+				}
+
 				case "chat": {
 					const text = parsed.args.length > 0 ? parsed.args : "(empty)";
 					if (ctx.forwardToAgent) return ctx.forwardToAgent(text, ctx.sessionKey);
 					logger.debug("telegram: forwardToAgent not wired; echoing", { sessionKey: ctx.sessionKey });
 					return `[stub\\-agent echo] you said: ${escapeForPlain(text)}`;
 				}
+
+				case "memory":
+				case "cron":
+				case "model":
+				case "code":
+				case "review":
+			case "task": {
+					// Route through agent — the slash command will be recognized by the session
+					const cmdText = `/${parsed.command} ${parsed.args}`.trim();
+					if (ctx.forwardToAgent) return ctx.forwardToAgent(cmdText, ctx.sessionKey);
+					return `⚠️ Agent not wired. Use /help for available commands.`;
+				}
 			}
 		}
+
 		case "chat": {
-			if (ctx.forwardToAgent) return ctx.forwardToAgent(parsed.text, ctx.sessionKey);
-			return `[stub\\-agent echo] you said: ${escapeForPlain(parsed.text)}`;
+			const chatText = (parsed as { kind: "chat"; text: string }).text;
+			if (ctx.forwardToAgent) return ctx.forwardToAgent(chatText, ctx.sessionKey);
+			return `[stub\\-agent echo] you said: ${escapeForPlain(chatText)}`;
+		}
+
+		case "file": {
+			const f = parsed as Extract<ParsedMessage, { kind: "file" }>;
+			if (!ctx.downloadFile) {
+				return "⚠️ File handling not configured. Send text instead.";
+			}
+			try {
+				const localPath = await ctx.downloadFile(f.fileId, f.fileName);
+				const fileInfo = `📎 File uploaded: ${f.fileName} (${f.mimeType})\nSaved to: ${localPath}`;
+				const prompt = f.caption ? `${fileInfo}\n\nUser caption: ${f.caption}` : fileInfo;
+				if (ctx.forwardToAgent) return ctx.forwardToAgent(prompt, ctx.sessionKey);
+				return `File saved to ${localPath}. Agent not wired — cannot process.`;
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return `⚠️ File download failed: ${escapeForPlain(msg)}`;
+			}
 		}
 	}
 }

package/src/adapters/telegram/index.ts

@@ -36,14 +36,24 @@ let shuttingDown = false;
  */
 export function startTelegramAdapter(
 	token: string | undefined = process.env.SNS_TELEGRAM_BOT_TOKEN,
-	opts: { autostart?: boolean; forwardToAgent?: (text: string, sessionKey: string) => Promise<string> } = {},
+	opts: {
+		autostart?: boolean;
+		forwardToAgent?: (text: string, sessionKey: string) => Promise<string>;
+		resetChatSession?: (chatId: string) => boolean;
+		getBridgeStats?: () => { activeSessions: number; chatIds: string[] };
+	} = {},
 ): TelegramBot | undefined {
 	if (activeBot) return activeBot;
 	if (!token) return undefined;
 	const autostart = opts.autostart ?? process.env.SNS_TELEGRAM_AUTOSTART !== "0";
 	if (!autostart) return undefined;
 
-	const bot = new TelegramBot({ token, forwardToAgent: opts.forwardToAgent });
+	const bot = new TelegramBot({
+		token,
+		forwardToAgent: opts.forwardToAgent,
+		resetChatSession: opts.resetChatSession,
+		getBridgeStats: opts.getBridgeStats,
+	});
 	activeBot = bot;
 
 	bot.start().catch((error) => {

package/src/agents/__tests__/config.test.ts

@@ -0,0 +1,79 @@
+/**
+ * agents.yaml config tests — SNS-MyAgent Phase 5.2
+ *
+ * Tests YAML parsing + config validation without touching real fs paths
+ * (uses tmp dirs and cleans up after).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { parseYamlSimple, DEFAULT_CONFIG, AgentsConfigManager } from "../config.js";
+
+describe("parseYamlSimple", () => {
+	it("parses simple key:value pairs", () => {
+		const out = parseYamlSimple("model: gpt-4o\nprovider: openai");
+		expect(out.model).toBe("gpt-4o");
+		expect(out.provider).toBe("openai");
+	});
+
+	it("returns empty object on empty input", () => {
+		expect(parseYamlSimple("")).toEqual({});
+	});
+
+	it("does not throw on indented map", () => {
+		expect(() =>
+			parseYamlSimple(`agents:
+  coder:
+    model: gpt-4o
+    tools: bash
+`),
+		).not.toThrow();
+	});
+});
+
+describe("AgentsConfigManager", () => {
+	let tmpDir: string;
+	beforeEach(() => {
+		tmpDir = mkdtempSync(join(tmpdir(), "agents-config-"));
+		mkdirSync(join(tmpDir, ".sns-myagent"), { recursive: true });
+	});
+	afterEach(() => {
+		rmSync(tmpDir, { recursive: true, force: true });
+	});
+
+	it("loads bundled defaults when no custom config", () => {
+		const mgr = new AgentsConfigManager();
+		const cfg = mgr.load();
+		expect(cfg.agents).toBeDefined();
+	});
+
+	it("loads project config from disk", () => {
+		const yaml = `agents:
+  reviewer:
+    model: gpt-4o-mini
+    tools:
+      - read
+`;
+		writeFileSync(join(tmpDir, ".sns-myagent", "agents.yaml"), yaml);
+		const prevCwd = process.cwd();
+		process.chdir(tmpDir);
+		try {
+			const mgr = new AgentsConfigManager();
+			mgr.load();
+			expect(mgr.config.agents).toBeDefined();
+		} finally {
+			process.chdir(prevCwd);
+		}
+	});
+});
+
+describe("DEFAULT_CONFIG", () => {
+	it("has ensembles + defaults", () => {
+		expect(DEFAULT_CONFIG.ensembles).toBeDefined();
+		expect(DEFAULT_CONFIG.default_agent).toBe("task");
+		expect(typeof DEFAULT_CONFIG.max_concurrency).toBe("number");
+	});
+});

package/src/agents/__tests__/resilience.test.ts

@@ -0,0 +1,119 @@
+/**
+ * Resilience module smoke tests — SNS-MyAgent Phase 5.4
+ *
+ * Pure logic tests for retry, timeout, circuit breaker, fallback.
+ * No DB, no LLM, no async intervals.
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+	withRetry,
+	withTimeout,
+	withFallback,
+	CircuitBreaker,
+	TimeoutError,
+	CircuitBreakerOpenError,
+} from "../resilience.js";
+
+describe("withRetry", () => {
+	it("returns result on first success", async () => {
+		let calls = 0;
+		const out = await withRetry(
+			async () => {
+				calls++;
+				return 42;
+			},
+			{ maxAttempts: 3, baseDelayMs: 1, maxDelayMs: 1, backoffMultiplier: 1, jitterFactor: 0 },
+		);
+		expect(out.success).toBe(true);
+		expect(out.result).toBe(42);
+		expect(calls).toBe(1);
+	});
+
+	it("retries until success", async () => {
+		let calls = 0;
+		const out = await withRetry(
+			async () => {
+				calls++;
+				if (calls < 3) throw new Error("transient");
+				return "ok";
+			},
+			{ maxAttempts: 5, baseDelayMs: 1, maxDelayMs: 1, backoffMultiplier: 1, jitterFactor: 0 },
+		);
+		expect(out.success).toBe(true);
+		expect(out.result).toBe("ok");
+		expect(calls).toBe(3);
+	});
+
+	it("fails after maxAttempts", async () => {
+		let calls = 0;
+		const out = await withRetry(
+			async () => {
+				calls++;
+				throw new Error("permanent");
+			},
+			{ maxAttempts: 2, baseDelayMs: 1, maxDelayMs: 1, backoffMultiplier: 1, jitterFactor: 0 },
+		);
+		expect(out.success).toBe(false);
+		expect(out.error?.message).toBe("permanent");
+		expect(calls).toBe(2);
+	});
+});
+
+describe("withTimeout", () => {
+	it("resolves when fn finishes fast", async () => {
+		const out = await withTimeout(async () => "fast", 100);
+		expect(out).toBe("fast");
+	});
+
+	it("rejects with TimeoutError on slow fn", async () => {
+		await expect(
+			withTimeout(async () => {
+				await new Promise((r) => setTimeout(r, 200));
+				return "slow";
+			}, 20),
+		).rejects.toBeInstanceOf(TimeoutError);
+	});
+});
+
+describe("withFallback", () => {
+	it("returns primary result when it succeeds", async () => {
+		const out = await withFallback([
+			async () => "primary",
+			async () => "fallback",
+		]);
+		expect(out.success).toBe(true);
+		expect(out.result).toBe("primary");
+	});
+
+	it("falls back when primary throws", async () => {
+		const out = await withFallback([
+			async () => {
+				throw new Error("primary down");
+			},
+			async () => "fallback",
+		]);
+		expect(out.success).toBe(true);
+		expect(out.result).toBe("fallback");
+	});
+});
+
+describe("CircuitBreaker", () => {
+	it("opens after threshold failures", async () => {
+		const cb = new CircuitBreaker("test1", { failureThreshold: 2, resetTimeoutMs: 60_000 });
+		const failing = async () => {
+			throw new Error("boom");
+		};
+		await expect(cb.execute(failing)).rejects.toThrow();
+		await expect(cb.execute(failing)).rejects.toThrow();
+		await expect(cb.execute(failing)).rejects.toBeInstanceOf(CircuitBreakerOpenError);
+		expect(cb.state).toBe("open");
+	});
+
+	it("closes after successful execution in closed state", async () => {
+		const cb = new CircuitBreaker("test2", { failureThreshold: 5 });
+		const out = await cb.execute(async () => "ok");
+		expect(out).toBe("ok");
+		expect(cb.state).toBe("closed");
+	});
+});

package/src/agents/__tests__/strategies.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Ensemble strategy smoke tests — SNS-MyAgent Phase 5
+ *
+ * Pure logic tests (no DB, no LLM). Verifies deterministic
+ * consensus/critic/best-of-N behavior with mock executors.
+ */
+
+import { describe, it, expect } from "bun:test";
+import { ConsensusStrategy } from "../strategies/consensus.js";
+import { BestOfNStrategy } from "../strategies/best-of-n.js";
+import { CriticStrategy } from "../strategies/critic.js";
+import { aggregateTokens } from "../strategies/types.js";
+import type { AgentResponse } from "../strategies/types.js";
+
+function mockResp(role: string, content: string, tokens = { input: 10, output: 20 }): AgentResponse {
+	return { role, model: "test", content, tokens, timeMs: 5 };
+}
+
+describe("aggregateTokens", () => {
+	it("sums input/output across responses", () => {
+		const out = aggregateTokens([
+			mockResp("a", "x", { input: 5, output: 7 }),
+			mockResp("b", "y", { input: 3, output: 2 }),
+		]);
+		expect(out).toEqual({ input: 8, output: 9 });
+	});
+
+	it("treats missing tokens as zero", () => {
+		const out = aggregateTokens([{ role: "x", model: "m", content: "c", timeMs: 0 }]);
+		expect(out).toEqual({ input: 0, output: 0 });
+	});
+});
+
+describe("ConsensusStrategy", () => {
+	it("picks majority when threshold met", async () => {
+		const strat = new ConsensusStrategy({ n: 3, threshold: 0.5 });
+		const exec = async (role: string) => mockResp(role, role === "a" ? "YES" : "NO");
+		const result = await strat.execute("q?", ["a", "b"], exec);
+		expect(result.strategy).toBe("consensus");
+		expect(result.responses.length).toBe(3);
+		expect(["YES", "NO"]).toContain(result.final);
+	});
+
+	it("throws when no agents provided", async () => {
+		const strat = new ConsensusStrategy();
+		await expect(strat.execute("q?", [], async () => mockResp("x", "x"))).rejects.toThrow(
+			/at least 1 agent/,
+		);
+	});
+});
+
+describe("BestOfNStrategy", () => {
+	it("executes and returns a ranked result", async () => {
+		const strat = new BestOfNStrategy({ n: 2 });
+		const exec = async (role: string, prompt: string) => {
+			// Scorer prompt format → respond with a number
+			if (prompt.includes("Rate")) return mockResp(role, "0.8");
+			return mockResp(role, `out-${role}`);
+		};
+		const result = await strat.execute("q?", ["a", "b"], exec);
+		expect(result.strategy).toBe("best_of_n");
+		expect(result.responses.length).toBeGreaterThan(0);
+		expect(result.final).toMatch(/out-[ab]/);
+	});
+});
+
+describe("CriticStrategy", () => {
+	it("iterates generator→critic until accept or max rounds", async () => {
+		const strat = new CriticStrategy({ maxRounds: 2 });
+		let round = 0;
+		const exec = async (_role: string, prompt: string) => {
+			round++;
+			if (prompt.includes("[critic review")) {
+				return mockResp("critic", "accepted", { input: 5, output: 10 });
+			}
+			return mockResp("gen", `draft-v${round}`, { input: 1, output: 5 });
+		};
+		const result = await strat.execute("write essay", ["gen", "critic"], exec);
+		expect(result.strategy).toBe("critic");
+		expect(result.rounds).toBeGreaterThanOrEqual(1);
+		expect(result.final).toContain("draft");
+	});
+});