@bastani/atomic 0.5.34-0 → 0.6.0-0

package/src/commands/cli/workflow-command.test.ts

@@ -1,154 +1,65 @@
 /**
- * Integration-style tests for `workflowCommand` — the CLI entry point that
- * wires list/picker/named-mode branching together. Three modules are stubbed:
- * the workflows SDK (executor + tmux probe + discovery), the system detector
- * (command-presence checks), and the spawn helpers (best-effort installers).
- * Every one of these is a side-effectful dependency — tmux spawn, disk I/O,
- * agent CLI spawn — and replacing them with controlled fakes lets us hit the
- * CLI's error/success branches without actually touching the real system.
+ * Tests for `workflowCommand` — the Commander Command returned by
+ * `createWorkflowCli(createBuiltinRegistry()).command("workflow")`.
  *
- * Two patterns make this file work:
+ * Mocking strategy: mock.module("../../sdk/runtime/executor.ts") replaces
+ * executeWorkflow with a spy BEFORE the dynamic import of workflow.ts.
  *
- *   1. `mock.module(…)` replaces each dependency module BEFORE the first
- *      dynamic `import("./workflow.ts")` so the module-under-test binds to
- *      the mocked references. Top-level await is required — a static import
- *      would hoist above the mocks and defeat them.
+ * Module load order:
+ *   1. Static imports execute first (hoisted by ES module semantics) —
+ *      this loads registry.ts → providers/claude.ts → executor.ts (REAL),
+ *      so `escBash` and all other executor exports are cached before the mock.
+ *   2. `mock.module` replaces executor.ts for SUBSEQUENT imports — only
+ *      `worker.ts` picks up the mocked executeWorkflow/runOrchestrator.
+ *   3. Dynamic import of workflow.ts uses the mocked executor via worker.ts.
  *
- *   2. Every test runs against a fresh `mkdtemp`ed cwd plumbed through the
- *      `cwd` option. That lets us control which workflows the command sees
- *      without touching the repo's own `.atomic/workflows` tree.
+ * Commander error handling: `exitOverride()` is called on the command before
+ * tests that expect rejection, converting process.exit(1) into a thrown Error.
  */
 
 import {
   describe,
   test,
   expect,
-  beforeAll,
-  afterAll,
   beforeEach,
   afterEach,
   mock,
 } from "bun:test";
-import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import * as realWorkflows from "../../sdk/workflows/index.ts";
-import * as realDetect from "../../services/system/detect.ts";
-import * as realAuth from "../../services/system/auth.ts";
-import * as realSpawn from "../../lib/spawn.ts";
-import { AGENT_CONFIG } from "../../services/config/index.ts";
-import type {
-  WorkflowDefinition,
-  WorkflowRunOptions,
-  DiscoveredWorkflow,
-} from "../../sdk/workflows/index.ts";
-
-// Capture original function references BEFORE `mock.module` replaces the
-// module exports. `import * as realWorkflows` gives a LIVE namespace — after
-// mock.module rebinds the exports, `realWorkflows.discoverWorkflows` would
-// resolve to our own mock and a pass-through would recurse infinitely. These
-// constants lock in the real implementations so pass-through defaults work.
-const realDiscoverWorkflows = realWorkflows.discoverWorkflows;
-const realLoadWorkflowsMetadata = realWorkflows.loadWorkflowsMetadata;
-const realIsCommandInstalled = realDetect.isCommandInstalled;
-// Snapshot the real `auth.ts` exports before `mock.module` rebinds them.
-// Bun 1.3.13 canonicalizes `mock.module` specifiers to an absolute path, so
-// our registration for `"../../services/system/auth.ts"` now shares a key with
-// `auth.test.ts`'s `"./auth.ts"` — the mock leaks across files unless we
-// explicitly restore on teardown. See `afterAll` at the bottom of this file.
-const realAuthSnapshot = { ...realAuth };
-
-// ─── Dependency mocks ───────────────────────────────────────────────────────
-// Every mock is a wrapper around the real implementation by default so
-// unrelated tests that don't care about a given mock still see the real
-// behaviour. Tests override specific mocks via `mockImplementationOnce` (or a
-// longer-lived `mockImplementation` inside a describe block) to exercise
-// failure branches. `beforeEach` resets everything to the default pass-through.
-
-const executeWorkflowMock =
-  mock<(opts: WorkflowRunOptions) => Promise<void>>(async () => {});
-
-// Default: real discovery so the filesystem-level branches still work.
-const discoverWorkflowsMock = mock<typeof realWorkflows.discoverWorkflows>(
-  (...args) => realDiscoverWorkflows(...args),
-);
-
-// Default: real metadata load — supports the picker branches that need
-// compiled metadata from a real workflow on disk.
-const loadWorkflowsMetadataMock = mock<
-  typeof realWorkflows.loadWorkflowsMetadata
->((...args) => realLoadWorkflowsMetadata(...args));
-
-// Default: pretend tmux is installed. The test env has it, but we want the
-// coverage test to be deterministic regardless of host config — if the host
-// removed tmux we'd still want these tests to cover the happy path.
-const isTmuxInstalledMock =
-  mock<typeof realWorkflows.isTmuxInstalled>(() => true);
-
-// Default: delegate to the real check, but pretend agent CLIs are installed.
-// CI runners won't have copilot/opencode/claude on PATH; without this
-// override every test that passes through runPrereqChecks would bail early.
-// Non-agent commands still hit the real check so mock.module doesn't break
-// detect.test.ts (Bun shares one process across test files).
-const AGENT_CMDS = new Set(Object.values(AGENT_CONFIG).map((c) => c.cmd));
-const defaultIsCommandInstalled = (cmd: string) =>
-  AGENT_CMDS.has(cmd) || realIsCommandInstalled(cmd);
-const isCommandInstalledMock = mock<typeof realDetect.isCommandInstalled>(
-  defaultIsCommandInstalled,
-);
-
-// Default: no-op so the best-effort installer branch in runPrereqChecks
-// doesn't try to actually install tmux/bun on the test machine.
-const ensureTmuxInstalledMock = mock<typeof realSpawn.ensureTmuxInstalled>(
-  async () => {},
-);
-const ensureBunInstalledMock = mock<typeof realSpawn.ensureBunInstalled>(
-  async () => {},
-);
-
-// Default: pretend auth succeeded. Real probes spawn the agent CLI via
-// its SDK to talk to an auth RPC — that's network/process-heavy and
-// non-deterministic on CI runners, so the auth branch is faked here and
-// exercised directly by `auth.test.ts`.
-const checkAgentAuthMock = mock<typeof realAuth.checkAgentAuth>(async () => ({
-  loggedIn: true,
-}));
+import type { WorkflowRunOptions } from "../../sdk/runtime/executor.ts";
+// Static import — loads providers/claude.ts → real executor.ts into module cache
+// BEFORE mock.module replaces it for subsequent imports.
+import "../../sdk/registry.ts";
+
+// ─── Module-level mock ────────────────────────────────────────────────────────
+// Must be declared AFTER the static imports above (which load the real executor)
+// but BEFORE the dynamic import of workflow.ts below (which uses worker.ts → mock).
+
+const executeWorkflowCalls: WorkflowRunOptions[] = [];
+const executeWorkflowMock = mock(async (opts: WorkflowRunOptions): Promise<void> => {
+  executeWorkflowCalls.push(opts);
+});
 
-mock.module("../../sdk/workflows/index.ts", () => ({
-  ...realWorkflows,
+// Spread real module to preserve all exports (escBash, discoverCopilotBinary, etc.)
+// so this mock doesn't break other test files that import those exports.
+const realExecutor = await import("../../sdk/runtime/executor.ts");
+await mock.module("../../sdk/runtime/executor.ts", () => ({
+  ...realExecutor,
   executeWorkflow: executeWorkflowMock,
-  discoverWorkflows: discoverWorkflowsMock,
-  loadWorkflowsMetadata: loadWorkflowsMetadataMock,
-  isTmuxInstalled: isTmuxInstalledMock,
-}));
-mock.module("../../services/system/detect.ts", () => ({
-  ...realDetect,
-  isCommandInstalled: isCommandInstalledMock,
-}));
-mock.module("../../services/system/auth.ts", () => ({
-  ...realAuth,
-  checkAgentAuth: checkAgentAuthMock,
-}));
-mock.module("../../lib/spawn.ts", () => ({
-  ...realSpawn,
-  ensureTmuxInstalled: ensureTmuxInstalledMock,
-  ensureBunInstalled: ensureBunInstalledMock,
+  runOrchestrator: async () => {},
 }));
 
-// Dynamic import — must happen AFTER `mock.module` so the module-under-test
-// binds to the mocked dependencies. Top-level await is fine under Bun.
-const { workflowCommand } = await import("./workflow.ts");
-
-// Restore `auth.ts` to its real exports once this file's tests finish so the
-// leaked `checkAgentAuthMock` doesn't hijack `auth.test.ts` when it loads next.
-afterAll(() => {
-  mock.module("../../services/system/auth.ts", () => realAuthSnapshot);
-});
+// Build a fresh workflowCommand using the real builtin registry directly.
+// This avoids stale-cache issues when workflow.ts was previously loaded by
+// cli.ts with a mocked (fake) builtin-registry in earlier test files.
+const { createWorkflowCli } = await import("../../sdk/workflow-cli.ts");
+const { toCommand } = await import("../../sdk/commander.ts");
+const { createBuiltinRegistry } = await import("../../sdk/workflows/builtin-registry.ts");
+const workflowCommand = toCommand(
+  createWorkflowCli(createBuiltinRegistry()),
+  "workflow",
+);
 
-// ─── Output capture ─────────────────────────────────────────────────────────
-// The CLI writes error banners to stderr via `console.error`, success content
-// to stdout via `process.stdout.write`. Wrap both so tests can snapshot the
-// emitted text without leaking it into the test runner's own output.
+// ─── Output capture ──────────────────────────────────────────────────────────
 
 interface CapturedOutput {
   stdout: string;
@@ -157,887 +68,317 @@ interface CapturedOutput {
 }
 
 function captureOutput(): CapturedOutput {
-  const captured: CapturedOutput = {
-    stdout: "",
-    stderr: "",
-    restore: () => {},
-  };
-  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
-  const originalConsoleError = console.error;
-  const originalConsoleLog = console.log;
-  const originalConsoleWarn = console.warn;
+  const captured: CapturedOutput = { stdout: "", stderr: "", restore: () => {} };
+  const origStdout = process.stdout.write.bind(process.stdout);
+  const origConsoleLog = console.log;
+  const origConsoleError = console.error;
+  const origConsoleWarn = console.warn;
 
-  // Typed as never so the loose commander signature doesn't widen.
   process.stdout.write = ((chunk: string | Uint8Array): boolean => {
-    captured.stdout +=
-      typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+    captured.stdout += typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
     return true;
   }) as typeof process.stdout.write;
-  console.error = (...args: unknown[]) => {
-    captured.stderr += args.map((a) => String(a)).join(" ") + "\n";
-  };
   console.log = (...args: unknown[]) => {
-    captured.stdout += args.map((a) => String(a)).join(" ") + "\n";
+    captured.stdout += args.map(String).join(" ") + "\n";
+  };
+  console.error = (...args: unknown[]) => {
+    captured.stderr += args.map(String).join(" ") + "\n";
   };
   console.warn = (...args: unknown[]) => {
-    captured.stderr += args.map((a) => String(a)).join(" ") + "\n";
+    captured.stderr += args.map(String).join(" ") + "\n";
   };
 
   captured.restore = () => {
-    process.stdout.write = originalStdoutWrite;
-    console.error = originalConsoleError;
-    console.log = originalConsoleLog;
-    console.warn = originalConsoleWarn;
+    process.stdout.write = origStdout;
+    console.log = origConsoleLog;
+    console.error = origConsoleError;
+    console.warn = origConsoleWarn;
   };
   return captured;
 }
 
-// ─── Colour handling ────────────────────────────────────────────────────────
-// `NO_COLOR` flips both COLORS (module load time) and createPainter (call
-// time) into plain-text mode so assertions can match against readable
-// substrings rather than SGR escape noise. COLORS is baked at module load
-// so the env var must already be set by the time workflow.ts gets imported.
+// ─── Colour suppression ──────────────────────────────────────────────────────
 
-let originalNoColor: string | undefined;
-let originalAtomicAgent: string | undefined;
-beforeAll(() => {
-  originalNoColor = process.env.NO_COLOR;
+let savedNoColor: string | undefined;
+beforeEach(() => {
+  savedNoColor = process.env.NO_COLOR;
   process.env.NO_COLOR = "1";
-  // Snapshot once so tests can freely set/unset ATOMIC_AGENT without
-  // leaking into unrelated suites in the same bun-test process.
-  originalAtomicAgent = process.env.ATOMIC_AGENT;
-});
-afterAll(() => {
-  if (originalNoColor === undefined) delete process.env.NO_COLOR;
-  else process.env.NO_COLOR = originalNoColor;
-  if (originalAtomicAgent === undefined) delete process.env.ATOMIC_AGENT;
-  else process.env.ATOMIC_AGENT = originalAtomicAgent;
-});
-
-// ─── Temp workspace plumbing ────────────────────────────────────────────────
-// Each test gets a fresh cwd so one test's workflows can't leak into another.
-// The actual workflow files live under `.atomic/workflows/<name>/<agent>/index.ts`
-// — matching the layout that `discoverWorkflows` scans.
-
-let tempDir: string;
-
-beforeEach(async () => {
-  tempDir = await mkdtemp(join(tmpdir(), "atomic-workflow-cmd-test-"));
-  // Clear ATOMIC_AGENT by default — `workflowCommand` falls back to this
-  // env var when `-a` is omitted, and we don't want the ambient env (e.g.
-  // a developer running tests from inside an atomic chat pane) to silently
-  // change the agent any given test sees. Tests that need it explicitly
-  // set it themselves.
-  delete process.env.ATOMIC_AGENT;
-  // Reset every mock to its default pass-through / no-op so tests are
-  // independent — no leftover state from prior overrides. `mockClear` wipes
-  // call history; `mockImplementation` replaces the queued implementation
-  // (including anything set via `mockImplementationOnce`) with the default.
+  executeWorkflowCalls.length = 0;
   executeWorkflowMock.mockClear();
-  executeWorkflowMock.mockImplementation(async () => {});
-  discoverWorkflowsMock.mockClear();
-  discoverWorkflowsMock.mockImplementation((...args) =>
-    realDiscoverWorkflows(...args),
-  );
-  loadWorkflowsMetadataMock.mockClear();
-  loadWorkflowsMetadataMock.mockImplementation((...args) =>
-    realLoadWorkflowsMetadata(...args),
-  );
-  isTmuxInstalledMock.mockClear();
-  isTmuxInstalledMock.mockImplementation(() => true);
-  isCommandInstalledMock.mockClear();
-  isCommandInstalledMock.mockImplementation(defaultIsCommandInstalled);
-  ensureTmuxInstalledMock.mockClear();
-  ensureTmuxInstalledMock.mockImplementation(async () => {});
-  ensureBunInstalledMock.mockClear();
-  ensureBunInstalledMock.mockImplementation(async () => {});
-  checkAgentAuthMock.mockClear();
-  checkAgentAuthMock.mockImplementation(async () => ({ loggedIn: true }));
-});
-
-afterEach(async () => {
-  await rm(tempDir, { recursive: true, force: true });
-});
-
-/**
- * Write a real workflow file that compiles through `defineWorkflow()`.
- * Tests import a real SDK so the module under test sees a live
- * `WorkflowDefinition`, not a mock shape — this keeps the coverage
- * line-level on `runNamedMode`'s resolution of the compiled definition.
- */
-async function writeCompiledWorkflow(
-  opts: {
-    name: string;
-    agent: "claude" | "copilot" | "opencode";
-    source?: string;
-  },
-): Promise<string> {
-  const dir = join(tempDir, ".atomic", "workflows", opts.name, opts.agent);
-  await mkdir(dir, { recursive: true });
-  const filePath = join(dir, "index.ts");
-  const defaultBody =
-    opts.source ??
-    `
-import { defineWorkflow } from "${join(process.cwd(), "src/sdk/workflows/index.ts")}";
-
-export default defineWorkflow({ name: "${opts.name}" })
-  .run(async () => {})
-  .compile();
-`;
-  await writeFile(filePath, defaultBody);
-  return filePath;
-}
-
-// ─── List mode ──────────────────────────────────────────────────────────────
-
-describe("workflowCommand --list", () => {
-  test("prints the rendered list and returns 0", async () => {
-    await writeCompiledWorkflow({ name: "alpha", agent: "copilot" });
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      list: true,
-      agent: "copilot",
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(0);
-    // Singular noun because only our one workflow is filtered in, and builtins
-    // discovered via `{ merge: false }` may still show up — so assert on the
-    // name we wrote instead of a count.
-    expect(cap.stdout).toContain("alpha");
-    expect(cap.stdout).toContain("run: atomic workflow -n <name> -a <agent>");
-  });
-
-  test("filters by the provided agent", async () => {
-    await writeCompiledWorkflow({ name: "claude-only", agent: "claude" });
-    await writeCompiledWorkflow({ name: "copilot-only", agent: "copilot" });
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      list: true,
-      agent: "claude",
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(0);
-    expect(cap.stdout).toContain("claude-only");
-    expect(cap.stdout).not.toContain("copilot-only");
-  });
-
-  test("shows workflows missing .compile() with a broken marker", async () => {
-    // Broken workflows used to vanish from the list silently. Surfacing
-    // them with a visible "✗ broken" badge is the remediation for the
-    // "my workflow disappeared after upgrading" class of bug reports —
-    // the user can now see the file still exists and needs a fix.
-    await writeCompiledWorkflow({ name: "good", agent: "copilot" });
-    await writeCompiledWorkflow({
-      name: "not-compiled",
-      agent: "copilot",
-      source: `
-import { defineWorkflow } from "${join(process.cwd(), "src/sdk/workflows/index.ts")}";
-
-export default defineWorkflow({ name: "not-compiled" })
-  .run(async () => {});
-// intentionally missing .compile()
-`,
-    });
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      list: true,
-      agent: "copilot",
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(0);
-    expect(cap.stdout).toContain("good");
-    expect(cap.stdout).toContain("not-compiled");
-    expect(cap.stdout).toContain("✗ broken");
-  });
-
-  test("shows workflows with type errors with a broken marker", async () => {
-    await writeCompiledWorkflow({ name: "valid", agent: "copilot" });
-    await writeCompiledWorkflow({
-      name: "broken-syntax",
-      agent: "copilot",
-      source: `this is not valid typescript }{}{`,
-    });
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      list: true,
-      agent: "copilot",
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(0);
-    expect(cap.stdout).toContain("valid");
-    expect(cap.stdout).toContain("broken-syntax");
-    expect(cap.stdout).toContain("✗ broken");
-  });
-
-  test("renders the empty state when no workflows exist and no agent filter is set", async () => {
-    // No agent filter + a fresh tempdir means `discoverWorkflows` only
-    // returns builtins for whichever agents exist on disk; to exercise
-    // the real empty-state branch we filter to an agent with no builtin
-    // coverage for the tempdir — `opencode` has builtins too, so instead
-    // point at an empty workflows directory.
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      list: true,
-      agent: "copilot",
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(0);
-    // Either the builtin ralph shows up or we get the "no workflows" banner.
-    // We only need to verify the code path completes and writes *something*.
-    expect(cap.stdout.length).toBeGreaterThan(0);
+  executeWorkflowMock.mockImplementation(async (opts) => {
+    executeWorkflowCalls.push(opts);
   });
 });
-
-// ─── Agent validation ──────────────────────────────────────────────────────
-
-describe("workflowCommand agent validation", () => {
-  test("missing agent returns 1 and logs a targeted error", async () => {
-    const cap = captureOutput();
-    const code = await workflowCommand({ cwd: tempDir });
-    cap.restore();
-
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("Missing agent");
-  });
-
-  test("unknown agent returns 1 and lists valid agents", async () => {
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      agent: "bogus-agent",
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("Unknown agent");
-    // Error helper lists valid agents — spot-check one.
-    expect(cap.stderr).toContain("claude");
-  });
-});
-
-// ─── Picker mode error paths ───────────────────────────────────────────────
-
-describe("workflowCommand picker mode", () => {
-  test("rejects passthrough args in picker mode", async () => {
-    // No `-n` means picker mode; any extra args are ambiguous (would the
-    // user want them fed into the picker's form, or straight through?), so
-    // the command bails early rather than guessing.
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      agent: "copilot",
-      passthroughArgs: ["oops", "--mode=fast"],
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("unexpected arguments");
-    // The hint points the user at the right place.
-    expect(cap.stderr).toContain("-n <name>");
-  });
+afterEach(() => {
+  if (savedNoColor === undefined) delete process.env.NO_COLOR;
+  else process.env.NO_COLOR = savedNoColor;
 });
 
-// ─── Named mode error paths ────────────────────────────────────────────────
-
-describe("workflowCommand named-mode error paths", () => {
-  test("unknown workflow name returns 1 and lists available options", async () => {
-    // Seed one workflow so the "Available" section renders.
-    await writeCompiledWorkflow({ name: "real-one", agent: "copilot" });
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "does-not-exist",
-      agent: "copilot",
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("does-not-exist");
-    expect(cap.stderr).toContain("not found");
-    // Lists the real workflow we wrote so users can copy-paste a valid name.
-    expect(cap.stderr).toContain("real-one");
-    // executeWorkflow should never be called on the error path.
-    expect(executeWorkflowMock).not.toHaveBeenCalled();
-  });
-
-  test("available workflows hint excludes uncompiled workflows", async () => {
-    await writeCompiledWorkflow({ name: "real-one", agent: "copilot" });
-    await writeCompiledWorkflow({
-      name: "uncompiled",
-      agent: "copilot",
-      source: `
-import { defineWorkflow } from "${join(process.cwd(), "src/sdk/workflows/index.ts")}";
-
-export default defineWorkflow({ name: "uncompiled" })
-  .run(async () => {});
-`,
-    });
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "does-not-exist",
-      agent: "copilot",
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("real-one");
-    expect(cap.stderr).not.toContain("uncompiled");
-  });
-
-  test("parse errors in passthrough args abort before loading", async () => {
-    await writeCompiledWorkflow({ name: "parse-err", agent: "copilot" });
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "parse-err",
-      agent: "copilot",
-      // Trailing --flag with no value is the canonical parse error.
-      passthroughArgs: ["--orphan"],
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("--orphan");
-    expect(executeWorkflowMock).not.toHaveBeenCalled();
-  });
-
-  test("load errors from WorkflowLoader surface cleanly", async () => {
-    // Write a workflow file that lacks `.compile()` — the loader treats
-    // this as a hard error and the CLI must return 1 rather than crash.
-    await writeCompiledWorkflow({
-      name: "broken",
-      agent: "copilot",
-      source: `
-import { defineWorkflow } from "${join(process.cwd(), "src/sdk/workflows/index.ts")}";
-
-export default defineWorkflow({ name: "broken" })
-  .run(async () => {});
-// intentionally missing .compile()
-`,
-    });
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "broken",
-      agent: "copilot",
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("not compiled");
-    expect(executeWorkflowMock).not.toHaveBeenCalled();
-  });
-
-  test("free-form workflow rejects stray --flags", async () => {
-    // A workflow with no declared `inputs` takes a positional prompt; any
-    // `--<name>` flag is definitionally wrong because there's nothing for
-    // it to bind to.
-    await writeCompiledWorkflow({ name: "free-form", agent: "copilot" });
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "free-form",
-      agent: "copilot",
-      passthroughArgs: ["--mode=fast"],
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("no declared inputs");
-    expect(cap.stderr).toContain("--mode");
-    expect(executeWorkflowMock).not.toHaveBeenCalled();
-  });
-
-  test("structured workflow rejects positional prompt tokens", async () => {
-    await writeCompiledWorkflow({
-      name: "structured",
-      agent: "copilot",
-      source: `
-import { defineWorkflow } from "${join(process.cwd(), "src/sdk/workflows/index.ts")}";
-
-export default defineWorkflow({
-  name: "structured",
-  inputs: [
-    { name: "topic", type: "string", required: true },
-  ],
-})
-  .run(async () => {})
-  .compile();
-`,
-    });
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "structured",
-      agent: "copilot",
-      // Positional-only invocation is ambiguous against a structured
-      // schema, so the command refuses to guess.
-      passthroughArgs: ["just", "a", "prompt"],
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("structured inputs");
-    expect(cap.stderr).toContain("--topic");
-    expect(executeWorkflowMock).not.toHaveBeenCalled();
-  });
-
-  test("structured workflow surfaces schema validation errors", async () => {
-    await writeCompiledWorkflow({
-      name: "validated",
-      agent: "copilot",
-      source: `
-import { defineWorkflow } from "${join(process.cwd(), "src/sdk/workflows/index.ts")}";
+// ─── exitOverride helper ──────────────────────────────────────────────────────
+// Calling exitOverride() converts Commander's process.exit(1) into a thrown
+// Error so tests can assert on rejection without killing the process.
 
-export default defineWorkflow({
-  name: "validated",
-  inputs: [
-    { name: "topic", type: "string", required: true },
-  ],
-})
-  .run(async () => {})
-  .compile();
-`,
-    });
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "validated",
-      agent: "copilot",
-      // Empty flag set — required `topic` is missing.
-      passthroughArgs: [],
-      cwd: tempDir,
-    });
-    cap.restore();
+function enableExitOverride(): void {
+  workflowCommand.exitOverride();
+}
 
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("--topic");
+// ─── Listing removed from dispatcher flags ──────────────────────────────────
+//
+// `--list` / `-l` used to live on the dispatcher command as a flag. It's
+// since moved to a dedicated `atomic workflow list` subcommand (registered
+// in src/cli.ts, implemented in ./workflow-list.ts) because the flag form
+// had confusing interactions with argv parsing. The dispatcher itself no
+// longer accepts the flag.
+
+describe("workflowCommand: --list flag removed", () => {
+  test("--list is not a recognised dispatcher option", async () => {
+    enableExitOverride();
+    let threw = false;
+    const cap = captureOutput();
+    try {
+      await workflowCommand.parseAsync(["node", "cli", "--list"]);
+    } catch {
+      threw = true;
+    } finally {
+      cap.restore();
+    }
+    expect(threw).toBe(true);
     expect(executeWorkflowMock).not.toHaveBeenCalled();
   });
 });
 
-// ─── Named mode success paths (via mocked executor) ────────────────────────
+// ─── Named mode success ───────────────────────────────────────────────────────
 
-describe("workflowCommand named-mode success paths", () => {
-  test("free-form workflow runs through the executor with the prompt as input", async () => {
-    await writeCompiledWorkflow({ name: "runs", agent: "copilot" });
+describe("workflowCommand named mode — success", () => {
+  test("dispatches ralph/claude with prompt to executor", async () => {
+    await workflowCommand.parseAsync([
+      "node", "cli",
+      "-n", "ralph",
+      "-a", "claude",
+      "--prompt", "fix the auth bug",
+    ]);
 
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "runs",
-      agent: "copilot",
-      passthroughArgs: ["fix", "the", "bug"],
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(0);
     expect(executeWorkflowMock).toHaveBeenCalledTimes(1);
-    const call = executeWorkflowMock.mock.calls[0]![0];
-    expect(call.agent).toBe("copilot");
-    // Free-form prompt is threaded under the `prompt` key so workflow
-    // authors can read `ctx.inputs.prompt` uniformly.
-    expect(call.inputs).toEqual({ prompt: "fix the bug" });
-    expect((call.definition as WorkflowDefinition).name).toBe("runs");
+    const call = executeWorkflowCalls[0]!;
+    expect(call.agent).toBe("claude");
+    expect(call.inputs?.["prompt"]).toBe("fix the auth bug");
+    expect(call.workflowKey).toBe("claude/ralph");
   });
 
-  test("free-form workflow with no prompt forwards an empty inputs record", async () => {
-    await writeCompiledWorkflow({ name: "silent", agent: "copilot" });
+  test("dispatches ralph/copilot successfully", async () => {
+    await workflowCommand.parseAsync([
+      "node", "cli",
+      "-n", "ralph",
+      "-a", "copilot",
+      "--prompt", "review this PR",
+    ]);
 
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "silent",
-      agent: "copilot",
-      passthroughArgs: [],
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(0);
     expect(executeWorkflowMock).toHaveBeenCalledTimes(1);
-    expect(executeWorkflowMock.mock.calls[0]![0].inputs).toEqual({});
+    const call = executeWorkflowCalls[0]!;
+    expect(call.agent).toBe("copilot");
+    expect(call.inputs?.["prompt"]).toBe("review this PR");
   });
 
-  test("detach flag is threaded through to the executor", async () => {
-    await writeCompiledWorkflow({ name: "detached", agent: "copilot" });
+  test("dispatches ralph/opencode successfully", async () => {
+    await workflowCommand.parseAsync([
+      "node", "cli",
+      "-n", "ralph",
+      "-a", "opencode",
+      "--prompt", "refactor the service layer",
+    ]);
 
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "detached",
-      agent: "copilot",
-      detach: true,
-      passthroughArgs: ["run", "in", "bg"],
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(0);
     expect(executeWorkflowMock).toHaveBeenCalledTimes(1);
-    expect(executeWorkflowMock.mock.calls[0]![0].detach).toBe(true);
+    expect(executeWorkflowCalls[0]!.agent).toBe("opencode");
   });
 
-  test("detach defaults to false when not provided", async () => {
-    await writeCompiledWorkflow({ name: "default-attach", agent: "copilot" });
+  test("dispatches deep-research-codebase/claude with prompt", async () => {
+    await workflowCommand.parseAsync([
+      "node", "cli",
+      "-n", "deep-research-codebase",
+      "-a", "claude",
+      "--prompt", "how does auth work",
+    ]);
 
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "default-attach",
-      agent: "copilot",
-      passthroughArgs: [],
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(0);
     expect(executeWorkflowMock).toHaveBeenCalledTimes(1);
-    expect(executeWorkflowMock.mock.calls[0]![0].detach).toBe(false);
+    expect(executeWorkflowCalls[0]!.workflowKey).toBe("claude/deep-research-codebase");
   });
 
-  test("structured workflow resolves flags and calls executor with merged inputs", async () => {
-    await writeCompiledWorkflow({
-      name: "struct-run",
-      agent: "copilot",
-      source: `
-import { defineWorkflow } from "${join(process.cwd(), "src/sdk/workflows/index.ts")}";
-
-export default defineWorkflow({
-  name: "struct-run",
-  inputs: [
-    { name: "topic", type: "string", required: true },
-    { name: "depth", type: "enum", values: ["shallow", "deep"], default: "shallow" },
-  ],
-})
-  .run(async () => {})
-  .compile();
-`,
-    });
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "struct-run",
-      agent: "copilot",
-      passthroughArgs: ["--topic=authz", "--depth=deep"],
-      cwd: tempDir,
-    });
-    cap.restore();
+  test("--detach flag threads detach=true to executor", async () => {
+    await workflowCommand.parseAsync([
+      "node", "cli",
+      "-n", "ralph",
+      "-a", "claude",
+      "--prompt", "test",
+      "--detach",
+    ]);
 
-    expect(code).toBe(0);
     expect(executeWorkflowMock).toHaveBeenCalledTimes(1);
-    expect(executeWorkflowMock.mock.calls[0]![0].inputs).toEqual({
-      topic: "authz",
-      depth: "deep",
-    });
-  });
-
-  test("runLoadedWorkflow surfaces executor failures as exit code 1", async () => {
-    await writeCompiledWorkflow({ name: "boom", agent: "copilot" });
-
-    executeWorkflowMock.mockImplementationOnce(async () => {
-      throw new Error("tmux is on fire");
-    });
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "boom",
-      agent: "copilot",
-      passthroughArgs: ["try", "it"],
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("Workflow failed");
-    expect(cap.stderr).toContain("tmux is on fire");
-  });
-
-  test("runLoadedWorkflow stringifies non-Error throwns", async () => {
-    await writeCompiledWorkflow({ name: "non-err", agent: "copilot" });
-
-    executeWorkflowMock.mockImplementationOnce(async () => {
-      // Thrown value is a plain string — the catch branch falls back to
-      // `String(error)` rather than reading `.message`.
-      throw "raw string failure";
-    });
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "non-err",
-      agent: "copilot",
-      passthroughArgs: [],
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("raw string failure");
+    expect(executeWorkflowCalls[0]!.detach).toBe(true);
   });
-});
 
-// ─── ATOMIC_AGENT env var inference ────────────────────────────────────────
+  test("-d shorthand also sets detach=true", async () => {
+    await workflowCommand.parseAsync([
+      "node", "cli",
+      "-n", "ralph",
+      "-a", "claude",
+      "--prompt", "test",
+      "-d",
+    ]);
 
-describe("workflowCommand ATOMIC_AGENT inference", () => {
-  // Top-level beforeEach already clears ATOMIC_AGENT; tests that need it
-  // set it explicitly and rely on the next test's clear to reset.
-
-  test("infers -a from ATOMIC_AGENT when omitted", async () => {
-    // Agents spawned inside an atomic chat/workflow pane inherit
-    // ATOMIC_AGENT. Re-passing their own provider back through `-a` is
-    // boilerplate we can eliminate.
-    await writeCompiledWorkflow({ name: "inferred", agent: "claude" });
-    process.env.ATOMIC_AGENT = "claude";
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "inferred",
-      // no agent passed
-      passthroughArgs: ["go"],
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(0);
     expect(executeWorkflowMock).toHaveBeenCalledTimes(1);
-    expect(executeWorkflowMock.mock.calls[0]![0].agent).toBe("claude");
-  });
-
-  test("forces detach=true when ATOMIC_AGENT is set", async () => {
-    // Attaching from inside the atomic socket would switch-client the
-    // caller's own terminal onto the new workflow session — hijacking the
-    // very pane the agent is running in. Force detach so the command
-    // returns immediately and the caller can attach on their own terms.
-    await writeCompiledWorkflow({ name: "auto-detach", agent: "copilot" });
-    process.env.ATOMIC_AGENT = "copilot";
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "auto-detach",
-      agent: "copilot",
-      // detach intentionally omitted
-      passthroughArgs: [],
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(0);
-    expect(executeWorkflowMock.mock.calls[0]![0].detach).toBe(true);
+    expect(executeWorkflowCalls[0]!.detach).toBe(true);
   });
 
-  test("explicit -a wins over ATOMIC_AGENT", async () => {
-    // Users running on Claude who want to invoke a Copilot workflow must
-    // be able to override — the env var is a fallback, not a pin.
-    await writeCompiledWorkflow({ name: "override", agent: "copilot" });
-    process.env.ATOMIC_AGENT = "claude";
+  test("detach defaults to false when flag omitted", async () => {
+    await workflowCommand.parseAsync([
+      "node", "cli",
+      "-n", "ralph",
+      "-a", "claude",
+      "--prompt", "test",
+    ]);
 
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "override",
-      agent: "copilot",
-      passthroughArgs: [],
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(0);
-    expect(executeWorkflowMock.mock.calls[0]![0].agent).toBe("copilot");
+    expect(executeWorkflowMock).toHaveBeenCalledTimes(1);
+    expect(executeWorkflowCalls[0]!.detach).toBe(false);
   });
 
-  test("no ATOMIC_AGENT + no -a still errors", async () => {
-    // Baseline: outside an atomic session, `-a` is still required.
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "anything",
-      cwd: tempDir,
-    });
-    cap.restore();
+  test("integer input --max_loops is forwarded to executor", async () => {
+    await workflowCommand.parseAsync([
+      "node", "cli",
+      "-n", "ralph",
+      "-a", "claude",
+      "--prompt", "test",
+      "--max_loops", "3",
+    ]);
 
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("Missing agent");
+    expect(executeWorkflowMock).toHaveBeenCalledTimes(1);
+    expect(executeWorkflowCalls[0]!.inputs?.["max_loops"]).toBe("3");
   });
 
-  test("empty ATOMIC_AGENT is treated as unset", async () => {
-    // Shells sometimes export empty strings; don't let that poison the
-    // agent fallback with an empty value that fails validation with a
-    // misleading "unknown agent ''" message.
-    process.env.ATOMIC_AGENT = "";
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "anything",
-      cwd: tempDir,
-    });
-    cap.restore();
+  test("workflowKey is always <agent>/<name>", async () => {
+    await workflowCommand.parseAsync([
+      "node", "cli",
+      "-n", "deep-research-codebase",
+      "-a", "copilot",
+      "--prompt", "research something",
+    ]);
 
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("Missing agent");
+    expect(executeWorkflowMock).toHaveBeenCalledTimes(1);
+    expect(executeWorkflowCalls[0]!.workflowKey).toBe("copilot/deep-research-codebase");
   });
 });
 
-// ─── Prereq checks (runPrereqChecks) ───────────────────────────────────────
-
-describe("workflowCommand prereq checks", () => {
-  test("missing agent CLI returns 1 with an install hint", async () => {
-    // `isCommandInstalled` is the first gate in runPrereqChecks — when it
-    // returns false for the agent binary, the command errors out before
-    // ever touching tmux or bun.
-    isCommandInstalledMock.mockImplementation((cmd) => cmd !== "claude");
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "anything",
-      agent: "claude",
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("'claude' is not installed");
-    expect(cap.stderr).toContain("Install it from");
+// ─── Named mode — error paths ─────────────────────────────────────────────────
+
+describe("workflowCommand named mode — error paths", () => {
+  test("unknown workflow name throws (Commander exits via exitOverride)", async () => {
+    enableExitOverride();
+    let threw = false;
+    const cap = captureOutput();
+    try {
+      await workflowCommand.parseAsync([
+        "node", "cli",
+        "-n", "bogus-workflow",
+        "-a", "claude",
+      ]);
+    } catch (_e) {
+      threw = true;
+    } finally {
+      cap.restore();
+    }
+    expect(threw).toBe(true);
+    expect(executeWorkflowMock).not.toHaveBeenCalled();
   });
 
-  test("missing tmux attempts installer then errors when still absent", async () => {
-    // Force tmux to never appear even after the installer runs. The
-    // installer itself resolves cleanly, so we exercise the post-installer
-    // recheck + error-branch combination.
-    isTmuxInstalledMock.mockImplementation(() => false);
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "anything",
-      agent: "copilot",
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(1);
-    expect(ensureTmuxInstalledMock).toHaveBeenCalledTimes(1);
-    // Platform-specific message — both tmux and psmux acceptable.
-    expect(cap.stderr).toMatch(/(tmux|psmux) is not installed/);
+  test("unknown agent throws (Commander exits via exitOverride)", async () => {
+    enableExitOverride();
+    let threw = false;
+    const cap = captureOutput();
+    try {
+      await workflowCommand.parseAsync([
+        "node", "cli",
+        "-n", "ralph",
+        "-a", "bogus-agent",
+      ]);
+    } catch (_e) {
+      threw = true;
+    } finally {
+      cap.restore();
+    }
+    expect(threw).toBe(true);
+    expect(executeWorkflowMock).not.toHaveBeenCalled();
   });
 
-  test("returns 1 with a login hint when the user isn't authenticated", async () => {
-    // Auth probe runs after `isCommandInstalled` and before tmux/bun
-    // installer checks — the workflow must bail before spawning a tmux
-    // session users would then have to kill manually.
-    checkAgentAuthMock.mockImplementationOnce(async () => ({
-      loggedIn: false,
-      detail: "oauth token missing",
-    }));
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "anything",
-      agent: "copilot",
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("Not logged in to GitHub Copilot CLI");
-    expect(cap.stderr).toContain("oauth token missing");
-    expect(cap.stderr).toContain("copilot");
-    // Downstream installers never run — the auth gate short-circuits.
-    expect(ensureTmuxInstalledMock).not.toHaveBeenCalled();
+  test("missing required prompt for ralph throws from validateAndResolve", async () => {
+    enableExitOverride();
+    let threw = false;
+    const cap = captureOutput();
+    try {
+      await workflowCommand.parseAsync([
+        "node", "cli",
+        "-n", "ralph",
+        "-a", "claude",
+        // --prompt intentionally omitted
+      ]);
+    } catch (_e) {
+      threw = true;
+    } finally {
+      cap.restore();
+    }
+    expect(threw).toBe(true);
+    expect(executeWorkflowMock).not.toHaveBeenCalled();
   });
 
-  test("best-effort tmux installer errors are swallowed", async () => {
-    // Even if the installer throws, runPrereqChecks falls through to a
-    // second `isTmuxInstalled()` check — if that still says false, we
-    // return the same error. The installer failure itself must not
-    // propagate.
-    isTmuxInstalledMock.mockImplementation(() => false);
-    ensureTmuxInstalledMock.mockImplementationOnce(async () => {
-      throw new Error("installer crashed");
-    });
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      name: "anything",
-      agent: "copilot",
-      cwd: tempDir,
-    });
-    cap.restore();
-
-    expect(code).toBe(1);
-    // The crash message never surfaces — the catch block just swallows it.
-    expect(cap.stderr).not.toContain("installer crashed");
-    expect(cap.stderr).toMatch(/(tmux|psmux) is not installed/);
+  test("non-integer value for --max_loops throws from validateAndResolve", async () => {
+    enableExitOverride();
+    let threw = false;
+    const cap = captureOutput();
+    try {
+      await workflowCommand.parseAsync([
+        "node", "cli",
+        "-n", "ralph",
+        "-a", "claude",
+        "--prompt", "test",
+        "--max_loops", "not-an-int",
+      ]);
+    } catch (_e) {
+      threw = true;
+    } finally {
+      cap.restore();
+    }
+    expect(threw).toBe(true);
+    expect(executeWorkflowMock).not.toHaveBeenCalled();
   });
 });
 
-// ─── Picker mode discovery branches ────────────────────────────────────────
-
-describe("workflowCommand picker discovery branches", () => {
-  test("returns 1 when discovery finds zero workflows", async () => {
-    // Picker mode without any workflows on disk — the CLI should explain
-    // where to put a new workflow rather than render an empty picker.
-    discoverWorkflowsMock.mockImplementationOnce(async () => []);
+// ─── Enum input coercion ──────────────────────────────────────────────────────
 
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      agent: "copilot",
-      cwd: tempDir,
-    });
-    cap.restore();
+describe("workflowCommand enum input coercion", () => {
+  test("valid enum value accepted for open-claude-design --output-type", async () => {
+    await workflowCommand.parseAsync([
+      "node", "cli",
+      "-n", "open-claude-design",
+      "-a", "claude",
+      "--prompt", "design a button",
+      "--output-type", "prototype",
+    ]);
 
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("No workflows found");
-    expect(cap.stderr).toContain(".atomic/workflows/<name>/copilot/index.ts");
+    expect(executeWorkflowMock).toHaveBeenCalledTimes(1);
+    expect(executeWorkflowCalls[0]!.inputs?.["output-type"]).toBe("prototype");
   });
 
-  test("returns 1 when every discovered workflow fails to load metadata", async () => {
-    // Discovery found entries but metadata load returned nothing — that's
-    // the "all workflows on disk are broken" branch. We fake a single
-    // discovered entry and then make the metadata loader drop it.
-    const fakeEntry: DiscoveredWorkflow = {
-      name: "broken",
-      agent: "copilot",
-      source: "local",
-      path: join(tempDir, ".atomic/workflows/broken/copilot/index.ts"),
-    };
-    discoverWorkflowsMock.mockImplementationOnce(async () => [fakeEntry]);
-    loadWorkflowsMetadataMock.mockImplementationOnce(async () => []);
-
-    const cap = captureOutput();
-    const code = await workflowCommand({
-      agent: "copilot",
-      cwd: tempDir,
-    });
-    cap.restore();
+  test("default enum value applied when --output-type omitted", async () => {
+    // output-type has default "prototype" — validateAndResolve fills it in.
+    // Note: Commander camelCases hyphenated flags (output-type → outputType),
+    // so the CLI flag lookup for "output-type" falls through to the default.
+    await workflowCommand.parseAsync([
+      "node", "cli",
+      "-n", "open-claude-design",
+      "-a", "claude",
+      "--prompt", "design a button",
+      // --output-type intentionally omitted
+    ]);
 
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("All discovered workflows failed to load");
+    expect(executeWorkflowMock).toHaveBeenCalledTimes(1);
+    expect(executeWorkflowCalls[0]!.inputs?.["output-type"]).toBe("prototype");
   });
 });
-
-// Note on the picker success path: the branches that actually open the
-// interactive picker (runPickerMode lines after the "no workflows found" and
-// "all failed to load" guards, plus all of runResolvedSelection) are not
-// covered from this file. Exercising them requires mocking
-// `WorkflowPickerPanel`, which is a side-effectful class that spins up a
-// real CliRenderer on stdin/stdout. Mocking it process-wide via mock.module
-// leaks into the WorkflowPickerPanel's own unit tests (they share the same
-// bun test process) and breaks them — the same live-binding issue that
-// mock.module has with other consumers in the suite. Rather than fight the
-// tooling, we accept a small amount of uncovered code in the picker success
-// path; the remaining coverage comfortably clears the per-file threshold.