@intentius/chant 0.1.7 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Declarative infrastructure-as-code toolkit — TypeScript on Node.js",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",

package/src/cli/commands/build.test.ts

@@ -132,18 +132,71 @@ export const testEntity = {
     expect(result.fileCount).toBeDefined();
   });
 
-  test("handles invalid output path", async () => {
+  test("creates parent directories for the primary output path (#38)", async () => {
+    // Write into a nested temp path whose parent dirs don't yet exist —
+    // chant build should mkdir -p the parents rather than fail with ENOENT.
+    const nestedOutput = join(testDir, "deep", "nested", "out", "file.json");
+
     const options: BuildOptions = {
       path: testDir,
-      output: "/nonexistent/directory/file.json",
+      output: nestedOutput,
       format: "json",
       serializers: [mockSerializer],
     };
 
     const result = await buildCommand(options);
 
-    // Should report error about output file
-    expect(result.errors.length).toBeGreaterThan(0);
-    expect(result.errors.some((e) => e.includes("output"))).toBe(true);
+    expect(result.errors).toEqual([]);
+    expect(existsSync(nestedOutput)).toBe(true);
+  });
+
+  test("creates parent directories for nested additional-files (#38)", async () => {
+    // Simulate a multi-file serializer (like the Op codegen) that emits
+    // additional files under nested subpaths.
+    const multiFileSerializer: Serializer = {
+      name: "multi",
+      rulePrefix: "MULTI",
+      serialize: () => ({
+        primary: "{}",
+        files: {
+          "ops/alb-deploy/workflow.ts": "// workflow\n",
+          "ops/alb-deploy/activities.ts": "// activities\n",
+          "ops/alb-deploy/worker.ts": "// worker\n",
+        },
+      }),
+    };
+
+    // Need at least one entity in the "multi" lexicon so the build pipeline
+    // invokes the serializer and the additional files surface.
+    await writeFile(
+      join(testDir, "infra.ts"),
+      [
+        `export const x = {`,
+        `  [Symbol.for("chant.declarable")]: true,`,
+        `  entityType: "X",`,
+        `  lexicon: "multi",`,
+        `  kind: "resource",`,
+        `  props: {},`,
+        `  attributes: {},`,
+        `};`,
+      ].join("\n"),
+    );
+
+    const outputPath = join(testDir, "dist", "manifest.json");
+
+    const options: BuildOptions = {
+      path: testDir,
+      output: outputPath,
+      format: "json",
+      serializers: [multiFileSerializer],
+    };
+
+    const result = await buildCommand(options);
+
+    expect(result.errors).toEqual([]);
+    expect(existsSync(outputPath)).toBe(true);
+    expect(existsSync(join(testDir, "dist", "ops", "alb-deploy", "workflow.ts"))).toBe(true);
+    expect(existsSync(join(testDir, "dist", "ops", "alb-deploy", "activities.ts"))).toBe(true);
+    expect(existsSync(join(testDir, "dist", "ops", "alb-deploy", "worker.ts"))).toBe(true);
   });
 });

package/src/cli/commands/build.ts

@@ -5,7 +5,7 @@ import { runPostSynthChecks } from "../../lint/post-synth";
 import type { PostSynthCheck } from "../../lint/post-synth";
 import { sortedJsonReplacer } from "../../utils";
 import { formatError, formatWarning, formatSuccess, formatBold, formatInfo } from "../format";
-import { writeFileSync } from "fs";
+import { writeFileSync, mkdirSync } from "fs";
 import { resolve, dirname, join } from "path";
 import { watchDirectory, formatTimestamp, formatChangedFiles } from "../watch";
 
@@ -188,9 +188,11 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
     }
 
     if (options.output) {
-      // Write to file
+      // Write to file — ensure parent directories exist for both the primary
+      // output path and any nested additional-file paths (e.g. ops/<name>/...).
       try {
         const outputPath = resolve(options.output);
+        mkdirSync(dirname(outputPath), { recursive: true });
         writeFileSync(outputPath, output);
 
         // Write additional files (e.g. nested stack templates) alongside the primary output
@@ -208,7 +210,9 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
             } catch {
               // If not JSON, write as-is
             }
-            writeFileSync(join(outputDir, filename), fileContent);
+            const targetPath = join(outputDir, filename);
+            mkdirSync(dirname(targetPath), { recursive: true });
+            writeFileSync(targetPath, fileContent);
           }
         }
       } catch (err) {

package/src/cli/handlers/graph.test.ts

@@ -0,0 +1,91 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+import type { ParsedArgs } from "../registry";
+
+const discoverOpsMock = vi.fn();
+vi.mock("../../op/discover", () => ({
+  discoverOps: () => discoverOpsMock(),
+}));
+
+const { runGraph } = await import("./graph");
+
+function makeArgs(overrides: Partial<ParsedArgs> = {}): ParsedArgs {
+  return {
+    command: "graph", path: ".",
+    format: "", fix: false, watch: false, verbose: false, help: false, live: false,
+    ...overrides,
+  };
+}
+
+function makeOp(name: string, depends: string[] = []): [string, { config: { name: string; depends?: string[] } }] {
+  return [name, { config: { name, depends } }];
+}
+
+describe("runGraph", () => {
+  let stdoutBuf: string[];
+  let stderrBuf: string[];
+
+  beforeEach(() => {
+    stdoutBuf = [];
+    stderrBuf = [];
+    vi.spyOn(console, "log").mockImplementation((s: string) => { stdoutBuf.push(s); });
+    vi.spyOn(console, "error").mockImplementation((s: string) => { stderrBuf.push(s); });
+    discoverOpsMock.mockReset();
+  });
+
+  test("prints 'No Ops found' when discovery is empty", async () => {
+    discoverOpsMock.mockResolvedValue({ ops: new Map(), errors: [] });
+    const exit = await runGraph({ args: makeArgs(), plugins: [], serializers: [] });
+    expect(exit).toBe(0);
+    expect(stdoutBuf.join("\n")).toContain("No Ops found");
+  });
+
+  test("prints 'No Op dependencies' when ops have no depends", async () => {
+    discoverOpsMock.mockResolvedValue({
+      ops: new Map([makeOp("solo")]),
+      errors: [],
+    });
+    const exit = await runGraph({ args: makeArgs(), plugins: [], serializers: [] });
+    expect(exit).toBe(0);
+    expect(stdoutBuf.join("\n")).toContain("No Op dependencies");
+  });
+
+  test("prints `dep -> name` edge per dependency", async () => {
+    discoverOpsMock.mockResolvedValue({
+      ops: new Map([
+        makeOp("infra"),
+        makeOp("app", ["infra"]),
+      ]),
+      errors: [],
+    });
+    const exit = await runGraph({ args: makeArgs(), plugins: [], serializers: [] });
+    expect(exit).toBe(0);
+    const out = stdoutBuf.join("\n");
+    expect(out).toContain("infra → app");
+  });
+
+  test("handles multi-edge graphs", async () => {
+    discoverOpsMock.mockResolvedValue({
+      ops: new Map([
+        makeOp("a"),
+        makeOp("b", ["a"]),
+        makeOp("c", ["a", "b"]),
+      ]),
+      errors: [],
+    });
+    await runGraph({ args: makeArgs(), plugins: [], serializers: [] });
+    const out = stdoutBuf.join("\n");
+    expect(out).toContain("a → b");
+    expect(out).toContain("a → c");
+    expect(out).toContain("b → c");
+  });
+
+  test("forwards discovery errors to stderr", async () => {
+    discoverOpsMock.mockResolvedValue({
+      ops: new Map(),
+      errors: ["failed to parse ops/bad.op.ts"],
+    });
+    const exit = await runGraph({ args: makeArgs(), plugins: [], serializers: [] });
+    expect(exit).toBe(0);
+    expect(stderrBuf.join("\n")).toContain("failed to parse ops/bad.op.ts");
+  });
+});

package/src/cli/handlers/run.test.ts

@@ -0,0 +1,448 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+import { createMockTemporalClient } from "@intentius/chant-test-utils";
+import type { ParsedArgs } from "../registry";
+import { EventEmitter } from "node:events";
+
+const discoverOpsMock = vi.fn();
+const loadChantConfigMock = vi.fn();
+const loadTemporalClientMock = vi.fn();
+const resolveProfileMock = vi.fn();
+const existsSyncMock = vi.fn();
+const spawnChildMock = vi.fn();
+const generateReportMock = vi.fn();
+const writeReportMock = vi.fn();
+const waitForTemporalSpy = vi.fn();
+
+vi.mock("../../op/discover", () => ({ discoverOps: () => discoverOpsMock() }));
+vi.mock("../../config", () => ({ loadChantConfig: (...args: unknown[]) => loadChantConfigMock(...args) }));
+vi.mock("./run-client", () => ({
+  loadTemporalClient: () => loadTemporalClientMock(),
+  connectionOptions: (profile: { address: string }) => ({ address: profile.address }),
+  resolveProfile: (...args: unknown[]) => resolveProfileMock(...args),
+  resolveWorkflowId: (name: string) => `chant-op-${name}`,
+}));
+vi.mock("node:fs", async () => {
+  const actual = await vi.importActual<typeof import("node:fs")>("node:fs");
+  return { ...actual, existsSync: (p: string) => existsSyncMock(p) };
+});
+vi.mock("node:child_process", async () => {
+  const actual = await vi.importActual<typeof import("node:child_process")>("node:child_process");
+  return { ...actual, spawn: (...args: unknown[]) => spawnChildMock(...args) };
+});
+vi.mock("./run-report", () => ({
+  generateReport: (...args: unknown[]) => generateReportMock(...args),
+  writeReport: (...args: unknown[]) => writeReportMock(...args),
+}));
+
+// Speed up runOp polling — POLL_INTERVAL_MS is 3000 in production. We use
+// fake timers in the runOp suite below; vi.advanceTimersByTime drives the loop.
+
+const { runOpList, runOpStatus, runOpLog, runOpSignal, runOpCancel, runOp } = await import("./run");
+
+function makeArgs(overrides: Partial<ParsedArgs> = {}): ParsedArgs {
+  return {
+    command: "run", path: ".",
+    format: "", fix: false, watch: false, verbose: false, help: false, live: false,
+    ...overrides,
+  };
+}
+
+function makeOp(name: string, depends: string[] = []): [string, { config: { name: string; phases: unknown[]; taskQueue?: string; depends?: string[]; overview: string } }] {
+  return [name, { config: { name, phases: [], depends, overview: `${name} overview` } }];
+}
+
+function setupTemporalClient(mock: ReturnType<typeof createMockTemporalClient>) {
+  loadTemporalClientMock.mockResolvedValue({
+    Connection: { connect: vi.fn(async () => ({})) },
+    Client: vi.fn(() => mock.client) as unknown as new () => unknown,
+  });
+  loadChantConfigMock.mockResolvedValue({ config: {} });
+  resolveProfileMock.mockReturnValue({ address: "localhost:7233", namespace: "default", taskQueue: "q" });
+}
+
+function makeStdoutSpy() {
+  const buf: string[] = [];
+  vi.spyOn(console, "log").mockImplementation((s: string) => { buf.push(s); });
+  return buf;
+}
+
+function makeStderrSpy() {
+  const buf: string[] = [];
+  vi.spyOn(console, "error").mockImplementation((s: string) => { buf.push(s); });
+  return buf;
+}
+
+describe("runOpList", () => {
+  beforeEach(() => {
+    discoverOpsMock.mockReset();
+    loadTemporalClientMock.mockReset();
+    loadChantConfigMock.mockReset();
+    resolveProfileMock.mockReset();
+  });
+
+  test("warns when no Ops discovered, returns 0", async () => {
+    discoverOpsMock.mockResolvedValue({ ops: new Map(), errors: [] });
+    const stderr = makeStderrSpy();
+    const exit = await runOpList({ args: makeArgs(), plugins: [], serializers: [] });
+    expect(exit).toBe(0);
+    expect(stderr.join("\n")).toContain("No Op definitions found");
+  });
+
+  test("prints table with one row per Op when Temporal connection fails", async () => {
+    discoverOpsMock.mockResolvedValue({
+      ops: new Map([makeOp("alb-deploy"), makeOp("infra")]),
+      errors: [],
+    });
+    // No Temporal — make loadTemporalClient throw so degraded path is exercised
+    loadTemporalClientMock.mockRejectedValue(new Error("not installed"));
+    const stdout = makeStdoutSpy();
+    const exit = await runOpList({ args: makeArgs(), plugins: [], serializers: [] });
+    expect(exit).toBe(0);
+    const out = stdout.join("\n");
+    expect(out).toContain("NAME");
+    expect(out).toContain("alb-deploy");
+    expect(out).toContain("infra");
+  });
+
+  test("annotates Ops with Temporal status when client is available", async () => {
+    discoverOpsMock.mockResolvedValue({ ops: new Map([makeOp("alb-deploy")]), errors: [] });
+    setupTemporalClient(createMockTemporalClient({
+      describeByWorkflowId: {
+        "chant-op-alb-deploy": {
+          workflowId: "chant-op-alb-deploy", runId: "r1",
+          status: { name: "RUNNING" }, startTime: new Date(),
+          taskQueue: "alb-deploy", type: { name: "albDeployWorkflow" },
+        },
+      },
+    }));
+    const stdout = makeStdoutSpy();
+    const exit = await runOpList({ args: makeArgs(), plugins: [], serializers: [] });
+    expect(exit).toBe(0);
+    expect(stdout.join("\n")).toContain("RUNNING");
+  });
+});
+
+describe("runOpStatus", () => {
+  beforeEach(() => {
+    discoverOpsMock.mockReset();
+    loadTemporalClientMock.mockReset();
+    loadChantConfigMock.mockReset();
+    resolveProfileMock.mockReset();
+  });
+
+  test("missing op name → exit 1", async () => {
+    const stderr = makeStderrSpy();
+    const exit = await runOpStatus({ args: makeArgs({ extraPositional: undefined }), plugins: [], serializers: [] });
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toContain("Op name is required");
+  });
+
+  test("connection error → exit 1 with message", async () => {
+    loadTemporalClientMock.mockRejectedValue(new Error("UNAVAILABLE"));
+    loadChantConfigMock.mockResolvedValue({ config: {} });
+    resolveProfileMock.mockReturnValue({ address: "localhost:7233", namespace: "default", taskQueue: "q" });
+    const stderr = makeStderrSpy();
+    const exit = await runOpStatus({ args: makeArgs({ extraPositional: "alb-deploy" }), plugins: [], serializers: [] });
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toContain("UNAVAILABLE");
+  });
+
+  test("happy path: prints workflow id, run id, status, activity counts", async () => {
+    setupTemporalClient(createMockTemporalClient({
+      describeByWorkflowId: {
+        "chant-op-alb-deploy": {
+          workflowId: "chant-op-alb-deploy", runId: "r1",
+          status: { name: "COMPLETED" },
+          startTime: new Date("2026-05-01T00:00:00Z"),
+          closeTime: new Date("2026-05-01T01:00:00Z"),
+          taskQueue: "alb-deploy", type: { name: "albDeployWorkflow" },
+        },
+      },
+      historyByWorkflowId: {
+        "chant-op-alb-deploy": [
+          { eventType: "ActivityTaskScheduled" },
+          { eventType: "ActivityTaskScheduled" },
+          { eventType: "ActivityTaskCompleted" },
+        ],
+      },
+    }));
+    const stdout = makeStdoutSpy();
+    const exit = await runOpStatus({ args: makeArgs({ extraPositional: "alb-deploy" }), plugins: [], serializers: [] });
+    expect(exit).toBe(0);
+    const out = stdout.join("\n");
+    expect(out).toContain("chant-op-alb-deploy");
+    expect(out).toContain("COMPLETED");
+    expect(out).toContain("1/2 completed");
+  });
+});
+
+describe("runOpLog", () => {
+  beforeEach(() => {
+    loadTemporalClientMock.mockReset();
+    loadChantConfigMock.mockReset();
+    resolveProfileMock.mockReset();
+  });
+
+  test("missing op name → exit 1", async () => {
+    const stderr = makeStderrSpy();
+    const exit = await runOpLog({ args: makeArgs({ extraPositional: undefined }), plugins: [], serializers: [] });
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toContain("Op name is required");
+  });
+
+  test("prints one row per matching workflow execution", async () => {
+    setupTemporalClient(createMockTemporalClient({
+      list: [
+        { workflowId: "chant-op-alb-deploy", runId: "r1", type: { name: "albDeployWorkflow" }, status: { name: "COMPLETED" }, startTime: new Date("2026-05-01T00:00:00Z"), closeTime: new Date("2026-05-01T01:00:00Z") },
+        { workflowId: "chant-op-alb-deploy", runId: "r2", type: { name: "albDeployWorkflow" }, status: { name: "RUNNING" }, startTime: new Date("2026-05-02T00:00:00Z") },
+      ],
+    }));
+    const stdout = makeStdoutSpy();
+    const exit = await runOpLog({ args: makeArgs({ extraPositional: "alb-deploy" }), plugins: [], serializers: [] });
+    expect(exit).toBe(0);
+    const out = stdout.join("\n");
+    expect(out).toContain("RUN-ID");
+    expect(out).toContain("r1");
+    expect(out).toContain("r2");
+    expect(out).toContain("COMPLETED");
+    expect(out).toContain("RUNNING");
+  });
+});
+
+describe("runOpSignal", () => {
+  beforeEach(() => {
+    loadTemporalClientMock.mockReset();
+    loadChantConfigMock.mockReset();
+    resolveProfileMock.mockReset();
+  });
+
+  test("missing op or signal name → exit 1", async () => {
+    const stderr = makeStderrSpy();
+    const exit = await runOpSignal({ args: makeArgs({ extraPositional: "op-only" }), plugins: [], serializers: [] });
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toContain("Usage:");
+  });
+
+  test("happy path: signal is sent and success message logged", async () => {
+    const mockClient = createMockTemporalClient();
+    setupTemporalClient(mockClient);
+    const stderr = makeStderrSpy();
+    const exit = await runOpSignal({
+      args: makeArgs({ extraPositional: "alb-deploy", extraPositional2: "gate-dns" }),
+      plugins: [], serializers: [],
+    });
+    expect(exit).toBe(0);
+    expect(mockClient.calls.signalCalls).toEqual([
+      { workflowId: "chant-op-alb-deploy", signalName: "gate-dns" },
+    ]);
+    expect(stderr.join("\n")).toContain("Signal");
+    expect(stderr.join("\n")).toContain("gate-dns");
+  });
+});
+
+describe("runOpCancel", () => {
+  beforeEach(() => {
+    loadTemporalClientMock.mockReset();
+    loadChantConfigMock.mockReset();
+    resolveProfileMock.mockReset();
+  });
+
+  test("missing op name → exit 1", async () => {
+    const stderr = makeStderrSpy();
+    const exit = await runOpCancel({ args: makeArgs({ extraPositional: undefined }), plugins: [], serializers: [] });
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toContain("Op name is required");
+  });
+
+  test("requires --force → exit 1 without it", async () => {
+    const stderr = makeStderrSpy();
+    const exit = await runOpCancel({
+      args: makeArgs({ extraPositional: "alb-deploy", force: false }),
+      plugins: [], serializers: [],
+    });
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toContain("--force");
+  });
+
+  test("with --force: cancel is sent and success logged", async () => {
+    const mockClient = createMockTemporalClient();
+    setupTemporalClient(mockClient);
+    const stderr = makeStderrSpy();
+    const exit = await runOpCancel({
+      args: makeArgs({ extraPositional: "alb-deploy", force: true }),
+      plugins: [], serializers: [],
+    });
+    expect(exit).toBe(0);
+    expect(mockClient.calls.cancelCalls).toEqual([{ workflowId: "chant-op-alb-deploy" }]);
+    expect(stderr.join("\n")).toContain("Cancellation requested");
+  });
+});
+
+// ── runOp (the main `chant run <name>` command) ─────────────────────────────
+
+function makeFakeChildProcess(): { proc: EventEmitter & { kill: () => void } } {
+  const proc = Object.assign(new EventEmitter(), { kill: vi.fn() });
+  return { proc };
+}
+
+describe("runOp", () => {
+  beforeEach(() => {
+    discoverOpsMock.mockReset();
+    loadTemporalClientMock.mockReset();
+    loadChantConfigMock.mockReset();
+    resolveProfileMock.mockReset();
+    existsSyncMock.mockReset();
+    spawnChildMock.mockReset();
+    generateReportMock.mockReset();
+    writeReportMock.mockReset();
+    waitForTemporalSpy.mockReset();
+  });
+
+  test("path defaults to '.' → exit 1 with hint", async () => {
+    const stderr = makeStderrSpy();
+    const exit = await runOp({ args: makeArgs({ path: "." }), plugins: [], serializers: [] });
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toContain("Op name is required");
+  });
+
+  test("unknown op name → exit 1 + lists available", async () => {
+    discoverOpsMock.mockResolvedValue({ ops: new Map([makeOp("alb-deploy"), makeOp("infra")]), errors: [] });
+    const stderr = makeStderrSpy();
+    const exit = await runOp({ args: makeArgs({ path: "missing" }), plugins: [], serializers: [] });
+    expect(exit).toBe(1);
+    const out = stderr.join("\n");
+    expect(out).toContain('Op "missing" not found');
+    expect(out).toContain("alb-deploy");
+    expect(out).toContain("infra");
+  });
+
+  test("unknown op + zero discovered ops → exit 1 with create-one hint", async () => {
+    discoverOpsMock.mockResolvedValue({ ops: new Map(), errors: [] });
+    const stderr = makeStderrSpy();
+    const exit = await runOp({ args: makeArgs({ path: "missing" }), plugins: [], serializers: [] });
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toContain("No *.op.ts files found");
+  });
+
+  test("profile resolution failure → exit 1", async () => {
+    discoverOpsMock.mockResolvedValue({ ops: new Map([makeOp("alb-deploy")]), errors: [] });
+    loadChantConfigMock.mockResolvedValue({ config: {} });
+    resolveProfileMock.mockImplementation(() => { throw new Error("Profile not found: prod"); });
+    const stderr = makeStderrSpy();
+    const exit = await runOp({ args: makeArgs({ path: "alb-deploy" }), plugins: [], serializers: [] });
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toContain("Profile not found: prod");
+  });
+
+  test("missing dist/ops/<name>/worker.ts → exit 1 with build hint", async () => {
+    discoverOpsMock.mockResolvedValue({ ops: new Map([makeOp("alb-deploy")]), errors: [] });
+    loadChantConfigMock.mockResolvedValue({ config: {} });
+    resolveProfileMock.mockReturnValue({ address: "localhost:7233", namespace: "default", taskQueue: "q" });
+    existsSyncMock.mockReturnValue(false);
+    const stderr = makeStderrSpy();
+    const exit = await runOp({ args: makeArgs({ path: "alb-deploy" }), plugins: [], serializers: [] });
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toContain("worker.ts not found");
+    expect(stderr.join("\n")).toContain("`chant build` first");
+  });
+
+  test("--report path: prints generated report from describe + history", async () => {
+    discoverOpsMock.mockResolvedValue({ ops: new Map([makeOp("alb-deploy")]), errors: [] });
+    setupTemporalClient(createMockTemporalClient({
+      describeByWorkflowId: {
+        "chant-op-alb-deploy": {
+          workflowId: "chant-op-alb-deploy", runId: "r1",
+          status: { name: "COMPLETED" }, startTime: new Date(),
+          taskQueue: "alb-deploy", type: { name: "albDeployWorkflow" },
+        },
+      },
+      historyByWorkflowId: { "chant-op-alb-deploy": [] },
+    }));
+    generateReportMock.mockReturnValue("# Report\nDeploy completed.");
+    const stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+
+    const exit = await runOp({ args: makeArgs({ path: "alb-deploy", report: true }), plugins: [], serializers: [] });
+
+    expect(exit).toBe(0);
+    expect(generateReportMock).toHaveBeenCalledTimes(1);
+    expect(stdoutSpy).toHaveBeenCalledWith("# Report\nDeploy completed.");
+    stdoutSpy.mockRestore();
+  });
+
+  test("happy path: spawns worker, starts workflow, polls until COMPLETED, writes report, exits 0", async () => {
+    vi.useFakeTimers();
+    try {
+      discoverOpsMock.mockResolvedValue({ ops: new Map([makeOp("alb-deploy")]), errors: [] });
+      const mockClient = createMockTemporalClient({
+        describeByWorkflowId: {
+          "chant-op-alb-deploy": {
+            workflowId: "chant-op-alb-deploy", runId: "r1",
+            status: { name: "COMPLETED" }, startTime: new Date(),
+            taskQueue: "alb-deploy", type: { name: "albDeployWorkflow" },
+          },
+        },
+        historyByWorkflowId: {
+          "chant-op-alb-deploy": [{ eventType: "ActivityTaskScheduled" }, { eventType: "ActivityTaskCompleted" }],
+        },
+      });
+      setupTemporalClient(mockClient);
+      existsSyncMock.mockReturnValue(true);
+      const { proc } = makeFakeChildProcess();
+      spawnChildMock.mockReturnValue(proc);
+      generateReportMock.mockReturnValue("# Report");
+      writeReportMock.mockReturnValue("/tmp/report.md");
+      const stderrWriteSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+
+      const promise = runOp({ args: makeArgs({ path: "alb-deploy" }), plugins: [], serializers: [] });
+      // Drive the polling loop forward.
+      await vi.advanceTimersByTimeAsync(5000);
+
+      const exit = await promise;
+      expect(exit).toBe(0);
+      expect(spawnChildMock).toHaveBeenCalledTimes(1);
+      expect(spawnChildMock.mock.calls[0][0]).toBe("npx");
+      expect(mockClient.calls.startCalls).toHaveLength(1);
+      expect(mockClient.calls.startCalls[0].opts.workflowId).toBe("chant-op-alb-deploy");
+      expect(generateReportMock).toHaveBeenCalledTimes(1);
+      expect(writeReportMock).toHaveBeenCalledTimes(1);
+      expect(proc.kill).toHaveBeenCalled();
+
+      stderrWriteSpy.mockRestore();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  test("workflow ends in FAILED → exit 1, worker still killed", async () => {
+    vi.useFakeTimers();
+    try {
+      discoverOpsMock.mockResolvedValue({ ops: new Map([makeOp("alb-deploy")]), errors: [] });
+      const mockClient = createMockTemporalClient({
+        describeByWorkflowId: {
+          "chant-op-alb-deploy": {
+            workflowId: "chant-op-alb-deploy", runId: "r1",
+            status: { name: "FAILED" }, startTime: new Date(),
+            taskQueue: "alb-deploy", type: { name: "albDeployWorkflow" },
+          },
+        },
+        historyByWorkflowId: { "chant-op-alb-deploy": [] },
+      });
+      setupTemporalClient(mockClient);
+      existsSyncMock.mockReturnValue(true);
+      const { proc } = makeFakeChildProcess();
+      spawnChildMock.mockReturnValue(proc);
+      generateReportMock.mockReturnValue("# Report");
+      writeReportMock.mockReturnValue("/tmp/report.md");
+      vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+
+      const promise = runOp({ args: makeArgs({ path: "alb-deploy" }), plugins: [], serializers: [] });
+      await vi.advanceTimersByTimeAsync(5000);
+
+      const exit = await promise;
+      expect(exit).toBe(1);
+      expect(proc.kill).toHaveBeenCalled();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});