@sns-myagent/cli 0.3.7 → 0.3.9

package/package.json

@@ -1,8 +1,8 @@
 {
   "type": "module",
   "name": "@sns-myagent/cli",
-  "version": "0.3.7",
-  "description": "SNS-MyAgent \u2014 BYOK coding agent CLI. Multi-agent + Telegram + self-learning memory. ~120MB binary, zero forced cost.",
+  "version": "0.3.9",
+  "description": "SNS-MyAgent — BYOK coding agent CLI. Multi-agent + Telegram + self-learning memory. ~120MB binary, zero forced cost.",
   "homepage": "https://github.com/Reihantt6/sns-myagent",
   "author": "Reihantt6",
   "contributors": [],
@@ -35,7 +35,7 @@
   "scripts": {
     "fetch-binary": "node scripts/fetch-binary.mjs",
     "postinstall": "node scripts/fetch-binary.mjs && node scripts/apply-pi-natives-patch.js",
-    "build": "bun build --compile --define process.env.PI_COMPILED='\"true\"' --define process.env.PKG_VERSION='\"0.3.4\"' --no-compile-autoload-bunfig --no-compile-autoload-dotenv --no-compile-autoload-tsconfig --no-compile-autoload-package-json --keep-names --outfile bin/snsagent-linux-x64 ./src/cli/entry.ts && cp bin/snsagent-linux-x64 bin/snsagent",
+    "build": "bun build --compile --define process.env.PI_COMPILED='\"true\"' --define process.env.PKG_VERSION='\"0.3.9\"' --no-compile-autoload-bunfig --no-compile-autoload-dotenv --no-compile-autoload-tsconfig --no-compile-autoload-package-json --keep-names --outfile bin/snsagent-linux-x64 ./src/cli/entry.ts && cp bin/snsagent-linux-x64 bin/snsagent",
     "check": "biome check . && bun run check:types",
     "check:types": "tsgo -p tsconfig.json --noEmit",
     "lint": "biome lint .",

package/src/adapters/telegram/handler.ts

@@ -122,7 +122,7 @@ export function parseMessage(msg: Message): ParsedMessage {
  */
 export const COMMAND_REPLIES: Record<TelegramCommand, string> = {
 	start:
-		"*Welcome to snscoder* 🤖\n\n" +
+		"*Welcome to snsagent* 🤖\n\n" +
 		"I'm a Telegram front-end for the SNS-MyAgent coding agent. " +
 		"Send me any task or question; I'll route it to the agent and reply here.\n\n" +
 		"Type /help for the full command list.",

package/src/agents/ensemble.ts

@@ -62,7 +62,7 @@ export async function executeEnsemble(
 
   // Execute with resilience if enabled
   const executeWithResilience = options.resilient !== false
-    ? createResilientExecutor(config, options)
+    ? createResilientExecutor(config, options, executeAgent)
     : executeAgent;
 
   const result = await strategy.execute(prompt, agentRoles, executeWithResilience);
@@ -147,6 +147,7 @@ function createStrategy(name: string, options: Record<string, unknown>): Ensembl
 function createResilientExecutor(
 	config: ReturnType<typeof getAgentsConfig>["config"],
 	options: EnsembleOptions,
+	executeAgent: (role: string, prompt: string) => Promise<AgentResponse>,
 ) {
 	return async (role: string, prompt: string): Promise<AgentResponse> => {
 		const agentConfig = config.agents[role];
@@ -158,8 +159,7 @@ function createResilientExecutor(
 			async () => {
 				return resilience.withTimeout(
 					async () => {
-						// This will be replaced by actual agent execution via the wrapper
-						throw new Error("executeAgent must be provided by caller");
+						return executeAgent(role, prompt);
 					},
 					options.taskTimeoutMs ?? config.task_timeout_ms ?? 120_000,
 					`ensemble:${role}`,
@@ -171,7 +171,6 @@ function createResilientExecutor(
 			},
 		);
 		if (!result.success) throw result.error ?? new Error("resilient executor failed");
-		// Type guard: caller must inject a real AgentResponse executor.
 		return result.result as unknown as AgentResponse;
 	};
 }

package/src/agents/executor.ts

@@ -0,0 +1,129 @@
+/**
+ * Ensemble Agent Executor — SNS-MyAgent Phase 5.1d
+ *
+ * Bridges the ensemble orchestrator (src/agents/ensemble.ts) to the
+ * actual LLM execution (src/task/executor.ts).
+ *
+ * Provides `executeAgentForEnsemble(role, prompt) → AgentResponse`
+ * which resolves agent config from agents.yaml, builds an AgentDefinition,
+ * calls runSubprocess, and returns the typed response.
+ */
+
+import { randomBytes } from "node:crypto";
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import { getAgentsConfig, type AgentRoleConfig } from "./config.js";
+import { runSubprocess, type ExecutorOptions } from "../task/executor.js";
+import type { AgentDefinition, SingleResult } from "../task/types.js";
+import type { AgentResponse } from "./strategies/types.js";
+
+// ─── Default agent definition ───────────────────────────────────────────────
+
+const DEFAULT_SYSTEM_PROMPT = `You are a helpful AI assistant. Answer the user's request directly and concisely.
+Do not use any tools. Do not spawn subagents. Just answer.`;
+
+const DEFAULT_AGENT: AgentDefinition = {
+  name: "task",
+  description: "General-purpose agent for ensemble tasks",
+  systemPrompt: DEFAULT_SYSTEM_PROMPT,
+  source: "bundled",
+};
+
+// ─── Executor ───────────────────────────────────────────────────────────────
+
+/**
+ * Execute a single agent call for the ensemble orchestrator.
+ *
+ * @param role  - Agent role name (from agents.yaml or "task")
+ * @param prompt - The user prompt to send
+ * @returns AgentResponse compatible with ensemble strategies
+ */
+export async function executeAgentForEnsemble(
+  role: string,
+  prompt: string,
+): Promise<AgentResponse> {
+  const startTime = Date.now();
+  const config = getAgentsConfig();
+  const roleConfig = config.resolveRole(role);
+
+  // Build AgentDefinition from config (or use default)
+  const agentDef = buildAgentDefinition(role, roleConfig);
+
+  // Resolve model string for display
+  const modelStr = roleConfig?.model ?? "default";
+
+  // Generate unique ID for this execution
+  const execId = `ensemble-${role}-${randomBytes(4).toString("hex")}`;
+
+  // Build executor options
+  const cwd = process.cwd();
+  const options: ExecutorOptions = {
+    cwd,
+    agent: agentDef,
+    task: prompt,
+    index: 0,
+    id: execId,
+    role,
+    // Use model override from agents.yaml if specified
+    modelOverride: roleConfig?.model,
+    thinkingLevel: resolveThinkingLevel(roleConfig?.thinking_level),
+  };
+
+  try {
+    const result: SingleResult = await runSubprocess(options);
+
+    return {
+      role,
+      model: result.resolvedModel ?? modelStr,
+      content: result.output || result.error || "(no output)",
+      tokens: result.usage
+        ? { input: result.usage.input ?? 0, output: result.usage.output ?? 0 }
+        : undefined,
+      timeMs: Date.now() - startTime,
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      role,
+      model: modelStr,
+      content: `[executor error] ${msg}`,
+      timeMs: Date.now() - startTime,
+    };
+  }
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function buildAgentDefinition(
+  role: string,
+  roleConfig: AgentRoleConfig | null,
+): AgentDefinition {
+  return {
+    name: role,
+    description: roleConfig?.system_prompt
+      ? `Custom agent: ${role}`
+      : `Ensemble agent: ${role}`,
+    systemPrompt: roleConfig?.system_prompt ?? DEFAULT_SYSTEM_PROMPT,
+    tools: roleConfig?.tools,
+    source: roleConfig ? "user" : "bundled",
+  };
+}
+
+/**
+ * Map a string thinking_level from agents.yaml to the actual ThinkingLevel const.
+ * Returns undefined if not set or unrecognized.
+ */
+function resolveThinkingLevel(
+  level: string | undefined,
+): ThinkingLevel | undefined {
+  if (!level) return undefined;
+  const map: Record<string, ThinkingLevel> = {
+    inherit: "inherit" as ThinkingLevel,
+    off: "off" as ThinkingLevel,
+    minimal: "minimal" as ThinkingLevel,
+    low: "low" as ThinkingLevel,
+    medium: "medium" as ThinkingLevel,
+    high: "high" as ThinkingLevel,
+    xhigh: "xhigh" as ThinkingLevel,
+  };
+  return map[level.toLowerCase()] ?? undefined;
+}

package/src/async/notifier.ts

@@ -10,7 +10,7 @@ const STATUS_COLORS: Record<string, (text: string) => string> = {
   completed: (t) => chalk.green(t),
   failed: (t) => chalk.red(t),
   cancelled: (t) => chalk.yellow(t),
-  running: (t) => chalk.cyan(t),
+  running: (t) => chalk.hex("#F97316")(t),
   pending: (t) => chalk.dim(t),
 };
 

package/src/cli/config-cli.ts

@@ -132,7 +132,7 @@ function formatValue(value: unknown): string {
 		return value ? chalk.green("true") : chalk.red("false");
 	}
 	if (typeof value === "number") {
-		return chalk.cyan(String(value));
+		return chalk.hex("#F97316")(String(value));
 	}
 	if (typeof value === "string") {
 		return chalk.yellow(value);

package/src/cli/entry.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 // Single-file CLI entry for `bun build --compile`.
-// Mirrors bin/snscoder (Node dev shim) but is a TS module so Bun can bundle
+// Mirrors bin/snsagent (Node dev shim) but is a TS module so Bun can bundle
 // all transitive imports into the binary.
 
 import { ensureConfig } from "../config/loader.js";
@@ -34,7 +34,7 @@ try {
 } catch (err) {
 	const e = err as Error;
 	const msg = e.message ? e.message : String(err);
-	process.stderr.write(`\u2717 snscoder crashed: ${msg}\n`);
+	process.stderr.write(`\u2717 snsagent crashed: ${msg}\n`);
 	if (process.env.SNS_DEBUG) {
 		process.stderr.write("\n" + (e.stack ?? "") + "\n");
 	}

package/src/cli/gallery-fixtures/misc.ts

@@ -119,14 +119,14 @@ export const miscFixtures: Record<string, GalleryFixture> = {
 				{
 					type: "text",
 					text: [
-						"● omp-api.service - Oh My Pi API",
-						"     Loaded: loaded (/etc/systemd/system/omp-api.service; enabled)",
+						"● snsagent-api.service - snsagent API",
+						"     Loaded: loaded (/etc/systemd/system/snsagent-api.service; enabled)",
 						"     Active: active (running) since Sat 2026-06-06 09:14:02 UTC; 3h 21min ago",
 						"   Main PID: 4812 (bun)",
 						"      Tasks: 17 (limit: 4915)",
 						"     Memory: 142.6M",
 						"        CPU: 38.214s",
-						"     CGroup: /system.slice/omp-api.service",
+						"     CGroup: /system.slice/snsagent-api.service",
 						"             └─4812 /usr/local/bin/bun run dist/server.js",
 					].join("\n"),
 				},

package/src/cli/grep-cli.ts

@@ -111,7 +111,7 @@ export async function runGrepCommand(cmd: GrepCommandArgs): Promise<void> {
 						console.log(chalk.dim(`${displayPath}-${ctx.lineNumber}- ${ctx.line}`));
 					}
 				}
-				console.log(`${chalk.cyan(displayPath)}:${chalk.yellow(String(match.lineNumber))}: ${match.line}`);
+				console.log(`${chalk.hex("#F97316")(displayPath)}:${chalk.yellow(String(match.lineNumber))}: ${match.line}`);
 				if (match.contextAfter) {
 					for (const ctx of match.contextAfter) {
 						console.log(chalk.dim(`${displayPath}-${ctx.lineNumber}- ${ctx.line}`));
@@ -119,9 +119,9 @@ export async function runGrepCommand(cmd: GrepCommandArgs): Promise<void> {
 				}
 				console.log("");
 			} else if (cmd.mode === GrepOutputMode.Count) {
-				console.log(`${chalk.cyan(displayPath)}: ${match.matchCount ?? 0} matches`);
+				console.log(`${chalk.hex("#F97316")(displayPath)}: ${match.matchCount ?? 0} matches`);
 			} else {
-				console.log(chalk.cyan(displayPath));
+				console.log(chalk.hex("#F97316")(displayPath));
 			}
 		}
 	} catch (err) {

package/src/cli/grievances-cli.ts

@@ -71,7 +71,7 @@ export async function listGrievances(options: ListGrievancesOptions): Promise<vo
 
 		for (const row of rows) {
 			console.log(
-				`${chalk.dim(`#${row.id}`)} ${chalk.cyan(row.tool)} ${chalk.dim(`(${row.model} v${row.version})`)}`,
+				`${chalk.dim(`#${row.id}`)} ${chalk.hex("#F97316")(row.tool)} ${chalk.dim(`(${row.model} v${row.version})`)}`,
 			);
 			console.log(`  ${row.report}`);
 			console.log();
@@ -181,7 +181,7 @@ function makeProgressBar(total: number, width = 30): ProgressBar {
 		const pct = `${Math.floor(ratio * 100)
 			.toString()
 			.padStart(3, " ")}%`;
-		process.stdout.write(`\r${chalk.cyan("Pushing")} [${bar}] ${pct} ${done}/${total}`);
+		process.stdout.write(`\r${chalk.hex("#F97316")("Pushing")} [${bar}] ${pct} ${done}/${total}`);
 	};
 	render(0);
 	return {

package/src/cli/index.ts

@@ -14,15 +14,20 @@
 import { loadConfig, saveConfig, configPath, ensureConfig } from "../config/loader.js";
 import type { Config } from "../config/schema.js";
 import { defaultConfigFn } from "../config/loader.js";
+import { getAgentDir } from "@oh-my-pi/pi-utils";
 import { startTelegramAdapter, stopTelegramAdapter } from "../adapters/telegram/index.js";
 import { createForwardToAgent, resetChatSession, getBridgeStats } from "../adapters/telegram/bridge.js";
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import chalk from "chalk";
 
 // ---------- package version (single source of truth) ----------
 
 // Inline version — kept in sync with package.json. Read from package.json at
 // runtime so the bin script does not need a second copy.
-import { readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 /**
@@ -61,17 +66,206 @@ function cmdVersion(): number {
 	return 0;
 }
 
-function cmdInit(): number {
+/** Derive a provider name from base URL for models.yml key. */
+function deriveProviderName(baseUrl: string): string {
+	try {
+		const url = new URL(baseUrl);
+		return url.hostname.replace(/^api\./, "").replace(/\./g, "-") || "custom-provider";
+	} catch {
+		return "custom-provider";
+	}
+}
+
+/** BYOK provider setup — reusable for first-run and re-init. */
+async function byokProviderSetup(rl: ReturnType<typeof createInterface>): Promise<void> {
+	process.stdout.write("\n");
+	process.stdout.write(`  ${chalk.hex("#F97316")("●")} ${chalk.bold("AI Provider Setup")}\n`);
+	process.stdout.write(`  ${chalk.dim("Connect your LLM provider (skip to set via env vars later):")}\n`);
+
+	// Base URL
+	process.stdout.write(`  ${chalk.hex("#F97316")("●")} Base URL [https://api.openai.com/v1]: `);
+	const baseUrlRaw = await rl.question("");
+	const baseUrl = (baseUrlRaw.trim() || "https://api.openai.com/v1").replace(/\/+$/, "");
+
+	// API Key
+	process.stdout.write(`  ${chalk.hex("#F97316")("●")} API Key: `);
+	const apiKey = await rl.question("");
+
+	// API type
+	process.stdout.write(`  ${chalk.hex("#F97316")("●")} API Type:\n`);
+	process.stdout.write(`    ${chalk.hex("#F97316")("1")} openai-completions (default — OpenAI, OpenRouter, Ollama, vLLM)\n`);
+	process.stdout.write(`    ${chalk.hex("#F97316")("2")} openai-responses\n`);
+	process.stdout.write(`    ${chalk.hex("#F97316")("3")} anthropic-messages\n`);
+	process.stdout.write(`    ${chalk.hex("#F97316")("4")} google-generative-ai\n`);
+	process.stdout.write(`    ${chalk.hex("#F97316")("5")} azure-openai-responses\n`);
+	process.stdout.write(`  [1] `);
+	const apiTypeAnswer = await rl.question("");
+
+	const apiTypeMap: Record<string, string> = {
+		"1": "openai-completions",
+		"2": "openai-responses",
+		"3": "anthropic-messages",
+		"4": "google-generative-ai",
+		"5": "azure-openai-responses",
+	};
+	const apiType = apiTypeMap[apiTypeAnswer.trim()] || "openai-completions";
+
+	// Save provider to models.yml
+	const apiKeyTrimmed = apiKey.trim();
+	if (apiKeyTrimmed || baseUrl.includes("localhost") || baseUrl.includes("127.0.0.1")) {
+		try {
+			const { YAML } = await import("bun");
+			const agentDir = getAgentDir();
+			const modelsPath = join(agentDir, "models.yml");
+
+			let existing: Record<string, unknown> = {};
+			if (existsSync(modelsPath)) {
+				try {
+					const content = readFileSync(modelsPath, "utf-8");
+					existing = (YAML.parse(content) as Record<string, unknown>) ?? {};
+				} catch { existing = {}; }
+			}
+
+			const providers = (existing.providers ?? {}) as Record<string, unknown>;
+			const providerName = deriveProviderName(baseUrl);
+
+			// Determine auth mode — no API key + localhost = auth "none"
+			const isNoAuth = !apiKeyTrimmed;
+			const providerConfig: Record<string, unknown> = {
+				baseUrl,
+				api: apiType,
+				auth: isNoAuth ? "none" : "apiKey",
+			};
+			if (apiKeyTrimmed) providerConfig.apiKey = apiKeyTrimmed;
+
+			// Auto-detect models for OpenAI-compatible
+			if (!isNoAuth && (apiType === "openai-completions" || apiType === "openai-responses")) {
+				process.stdout.write(`  ${chalk.dim("Detecting models…")}\n`);
+				try {
+					const headers: Record<string, string> = {};
+					if (apiKeyTrimmed) headers["Authorization"] = `Bearer ${apiKeyTrimmed}`;
+					const res = await fetch(`${baseUrl}/models`, { headers, signal: AbortSignal.timeout(10_000) });
+					if (res.ok) {
+						const data = (await res.json()) as { data?: { id: string }[] };
+						if (data.data?.length) {
+							const models = data.data.map(m => m.id).filter(Boolean).sort();
+							providerConfig.models = models.map(id => ({
+								id,
+								api: apiType,
+								contextWindow: 128000,
+								supportsTools: true,
+							}));
+							process.stdout.write(`  ${chalk.green("✓")} ${models.length} model${models.length !== 1 ? "s" : ""} detected\n`);
+						} else {
+							process.stdout.write(`  ${chalk.dim("No models listed at /models endpoint (provider may not support it)")}\n`);
+						}
+					} else {
+						process.stdout.write(`  ${chalk.dim(`Could not detect models (HTTP ${res.status}) — manual config may be needed`)}\n`);
+					}
+				} catch {
+					process.stdout.write(`  ${chalk.dim("Could not reach /models endpoint — saved without model list")}\n`);
+				}
+			}
+
+			providers[providerName] = providerConfig;
+			existing.providers = providers;
+
+			if (!existsSync(agentDir)) mkdirSync(agentDir, { recursive: true });
+			writeFileSync(modelsPath, YAML.stringify(existing), "utf-8");
+			process.stdout.write(`  ${chalk.green("✓")} Provider saved to ${modelsPath}\n`);
+		} catch (err) {
+			process.stdout.write(`  ${chalk.dim(`Could not save provider config: ${(err as Error).message}`)}\n`);
+		}
+	} else {
+		process.stdout.write(`  ${chalk.dim("Skipped — set OPENAI_API_KEY or ANTHROPIC_API_KEY env var to connect later")}\n`);
+	}
+}
+
+async function cmdInit(): Promise<number> {
 	const path = configPath();
 	try {
 		const existing = loadConfig();
 		if (existing) {
 			process.stdout.write(`✓ config already exists at ${path}\n`);
+			// Still allow BYOK provider re-configuration
+			process.stdout.write(`  ${chalk.dim("Re-run provider setup? [y/N] ")}`);
+			const rl = createInterface({ input: stdin, output: stdout });
+			const reconfigure = await rl.question("");
+			if (reconfigure.trim().toLowerCase() !== "y") {
+				rl.close();
+				return 0;
+			}
+			await byokProviderSetup(rl);
+			rl.close();
 			return 0;
 		}
+
+		// Interactive memory backend selection
+		const rl = createInterface({ input: stdin, output: stdout });
+
+		process.stdout.write("\n");
+		process.stdout.write(`  ${chalk.hex("#F97316")("●")} ${chalk.bold("Memory Backend Selection")}\n`);
+		process.stdout.write(`  ${chalk.dim("Select memory backend (default: mnemopi):")}\n`);
+		process.stdout.write(`    ${chalk.hex("#F97316")("1")} mnemopi (default) — SQLite + vector + graph, offline, no config\n`);
+		process.stdout.write(`    ${chalk.hex("#F97316")("2")} local — rollout summary only\n`);
+		process.stdout.write(`    ${chalk.hex("#F97316")("3")} mnemosyne — advanced local (Python daemon)\n`);
+		process.stdout.write(`    ${chalk.hex("#F97316")("4")} mem0 — cloud API (needs MEM0_API_KEY)\n`);
+		process.stdout.write(`    ${chalk.hex("#F97316")("5")} lcm — local server (needs LCM_HOST)\n`);
+		process.stdout.write(`    ${chalk.hex("#F97316")("6")} hindsight — cloud (needs HINDSIGHT_API_KEY)\n`);
+		process.stdout.write(`    ${chalk.hex("#F97316")("7")} off — disabled\n`);
+		process.stdout.write(`  [1] `);
+
+		const answer = await rl.question("");
+
+		let backend: "mnemopi" | "hindsight" | "mnemosyne" | "mem0" | "lcm" | "local" | "off" = "mnemopi";
+		switch (answer.trim()) {
+			case "1":
+			case "":
+				backend = "mnemopi";
+				break;
+			case "2":
+				backend = "local";
+				break;
+			case "3":
+				backend = "mnemosyne";
+				break;
+			case "4":
+				backend = "mem0";
+				break;
+			case "5":
+				backend = "lcm";
+				break;
+			case "6":
+				backend = "hindsight";
+				break;
+			case "7":
+				backend = "off";
+				break;
+			default:
+				process.stdout.write(`  ${chalk.dim("unknown option, using default (mnemopi)")}\n`);
+				backend = "mnemopi";
+		}
+
+		// Mnemosyne needs Python daemon
+		if (backend === "mnemosyne") {
+			process.stdout.write(`\n  ${chalk.hex("#F97316")("●")} mnemosyne requires Python daemon.\n`);
+			process.stdout.write(`  ${chalk.dim("Install now? (pip install mnemosyne) [Y/n] ")}`);
+			const yn = await rl.question("");
+			if (!yn || yn.toLowerCase() === "y") {
+				process.stdout.write(`  ${chalk.dim("installing mnemosyne... (placeholder)")}\n`);
+				// TODO: actual pip install
+			}
+		}
+
+		// ── BYOK Provider Setup ─────────────────────────────────────
+		await byokProviderSetup(rl);
+
+		rl.close();
+
 		const cfg = defaultConfigFn();
+		cfg.memory = { ...cfg.memory, backend };
 		saveConfig(cfg);
-		process.stdout.write(`✓ created ${path}\n`);
+		process.stdout.write(`✓ created ${path} (memory backend: ${backend})\n`);
 		return 0;
 	} catch (err) {
 		process.stderr.write(`✗ init failed: ${(err as Error).message}\n`);
@@ -341,14 +535,15 @@ Commands:
   (none)                      start full agent interactive mode (default)
   agent                       alias for default
   version                     print package version
-  init                        create .sns-myagent/config.json (defaults)
+  init                        create .sns-myagent/config.json + connect AI provider
+  setup                       alias for init (BYOK provider setup)
   chat [--stub]               start interactive chat (stub for Phase 2B)
   launch                      alias for default
   config show                 print current config
   config get <key>            read a dot-path value (e.g. model.provider)
   config set <key> <value>    update a dot-path value
   telegram start|stop|status  manage the Telegram polling adapter
-  orchestrate <prompt>        multi-agent ensemble run (Phase 5)
+  orchestrate <prompt>        multi-agent ensemble run
   help                        print this help
 `;
 
@@ -370,6 +565,7 @@ export async function runCliAsync(argv: string[]): Promise<number> {
 		case "-v":
 			return cmdVersion();
 		case "init":
+		case "setup":
 			return cmdInit();
 		case "chat":
 			return cmdChat(rest);
@@ -377,8 +573,6 @@ export async function runCliAsync(argv: string[]): Promise<number> {
 			return cmdConfig(rest);
 		case "telegram":
 			return cmdTelegram(rest);
-		case "launch":
-			return cmdLaunch(rest);
 		case "orchestrate":
 			return cmdOrchestrate(rest);
 		default:
@@ -392,30 +586,55 @@ async function cmdOrchestrate(args: string[]): Promise<number> {
 	if (args.length === 0) {
 		process.stderr.write("✗ orchestrate requires a prompt\n");
 		process.stderr.write("  usage: snsagent orchestrate <prompt>\n");
-		process.stderr.write("  flags:  --strategy consensus|critic|best_of_n\n");
+		process.stderr.write("  flags:  --strategy consensus|critic|best_of_n|single\n");
 		process.stderr.write("          --agents role1,role2\n");
 		process.stderr.write("          --ensemble <name>   (from agents.yaml)\n");
 		return 1;
 	}
-	const prompt = args.join(" ");
-	const opts: Record<string, unknown> = {};
+
+	// Parse flags and build prompt
+	const promptParts: string[] = [];
+	let strategy: string | undefined;
+	let agents: string[] | undefined;
+	let ensemble: string | undefined;
+
 	for (let i = 0; i < args.length; i++) {
 		const a = args[i];
-		if (a === "--strategy") opts.strategy = args[++i];
-		else if (a === "--agents") opts.agents = (args[++i] ?? "").split(",").filter(Boolean);
-		else if (a === "--ensemble") opts.ensemble = args[++i];
+		if (a === "--strategy") { strategy = args[++i]; }
+		else if (a === "--agents") { agents = (args[++i] ?? "").split(",").filter(Boolean); }
+		else if (a === "--ensemble") { ensemble = args[++i]; }
+		else { promptParts.push(a); }
 	}
-	void prompt; void opts; // parsed for future executor wiring (Task 5.1d)
+
+	const prompt = promptParts.join(" ");
+	if (!prompt) {
+		process.stderr.write("✗ orchestrate requires a prompt\n");
+		return 1;
+	}
+
 	try {
-		// CLI wrapper: no real LLM executor yet (Phase 5 stub).
-		// Until agent invocation is wired, surface a clear message instead of silently failing.
-		process.stderr.write(
-			"✗ orchestrate: agent executor not wired in CLI yet.\n" +
-				"  Phase 5 ships the orchestrator module; the CLI integration lands once\n" +
-				"  the LLM agent executor (src/agents/executor.ts) is implemented.\n" +
-				"  For now use the ensemble module directly: import { executeEnsemble } from \"../agents/ensemble.js\".\n",
-		);
-		return 2;
+		const { executeEnsemble } = await import("../agents/ensemble.js");
+		const { executeAgentForEnsemble } = await import("../agents/executor.js");
+
+		const result = await executeEnsemble(prompt, executeAgentForEnsemble, {
+			strategy: strategy as "consensus" | "critic" | "best_of_n" | undefined,
+			agents,
+			ensemble,
+		});
+
+		// Output result
+		console.log(result.final);
+
+		// Cost summary to stderr
+		if (result.costBreakdown.length > 0) {
+			process.stderr.write(`\n── ensemble: ${result.strategy} | ${result.rounds} round(s) | ${result.totalTimeMs}ms ──\n`);
+			for (const row of result.costBreakdown) {
+				const tokens = row.inputTokens + row.outputTokens;
+				process.stderr.write(`  ${row.role}: ${row.model} (${tokens} tokens)\n`);
+			}
+		}
+
+		return 0;
 	} catch (err) {
 		process.stderr.write(`✗ orchestrate failed: ${(err as Error).message}\n`);
 		return 1;