@intentius/chant 0.49.0 → 0.51.0

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

@@ -0,0 +1,82 @@
+import { describe, test, expect } from "vitest";
+import { fetchNormalizedHistory, type WorkflowHandleRaw } from "./run-client";
+
+/**
+ * `@temporalio/client`'s `WorkflowHandle.fetchHistory()` returns the raw
+ * Temporal wire proto: `eventType` a numeric enum, `eventId`/
+ * `scheduledEventId` protobuf `Long` instances, `eventTime` a
+ * `{seconds, nanos}` Timestamp. What turns those into the friendly
+ * `"EVENT_TYPE_ACTIVITY_TASK_SCHEDULED"` string / decimal strings is the
+ * proto message's own `toJSON()` — confirmed against a real
+ * `TestWorkflowEnvironment` run (Temporal SDK 1.17.2) during development.
+ * These fixtures simulate exactly that: plain values by default, but with a
+ * `toJSON()` on the fields that have one on the wire, so a JSON round-trip
+ * behaves the same way it does against a real server.
+ */
+function fakeLong(n: number) {
+  return { low: n, high: 0, unsigned: false, toJSON: () => String(n) };
+}
+
+function fakeTimestamp(seconds: number, nanos = 0) {
+  return { seconds: fakeLong(seconds), nanos };
+}
+
+function makeHandle(events: unknown[]): WorkflowHandleRaw {
+  return {
+    workflowId: "wf",
+    async fetchHistory() {
+      return { events } as never;
+    },
+  } as unknown as WorkflowHandleRaw;
+}
+
+describe("fetchNormalizedHistory", () => {
+  test("converts the raw wire shape to short eventType, decimal eventId, and a real Date", async () => {
+    const raw = {
+      eventId: fakeLong(7),
+      eventTime: fakeTimestamp(1_788_000_000, 500_000_000),
+      eventType: "EVENT_TYPE_ACTIVITY_TASK_SCHEDULED",
+      activityTaskScheduledEventAttributes: {
+        activityId: "1",
+        activityType: { name: "dup" },
+      },
+    };
+    const history = await fetchNormalizedHistory(makeHandle([raw]));
+    const event = history.events?.[0];
+    expect(event?.eventType).toBe("ActivityTaskScheduled");
+    expect(event?.eventId).toBe("7");
+    expect(event?.eventTime).toBeInstanceOf(Date);
+    expect(event?.eventTime?.getTime()).toBe(1_788_000_000_500);
+    expect(event?.activityTaskScheduledEventAttributes).toEqual({ activityId: "1", activityType: { name: "dup" } });
+  });
+
+  test("ActivityTaskCompleted's scheduledEventId round-trips to a decimal string, joinable against eventId", async () => {
+    const scheduled = {
+      eventId: fakeLong(7),
+      eventType: "EVENT_TYPE_ACTIVITY_TASK_SCHEDULED",
+      activityTaskScheduledEventAttributes: { activityId: "1", activityType: { name: "dup" } },
+    };
+    const completedEvent = {
+      eventId: fakeLong(9),
+      eventType: "EVENT_TYPE_ACTIVITY_TASK_COMPLETED",
+      activityTaskCompletedEventAttributes: { scheduledEventId: fakeLong(7) },
+    };
+    const history = await fetchNormalizedHistory(makeHandle([scheduled, completedEvent]));
+    expect(history.events?.[0].eventId).toBe(history.events?.[1].activityTaskCompletedEventAttributes?.scheduledEventId);
+  });
+
+  test("a short PascalCase eventType (already-normalized test fixture data) passes through unchanged", async () => {
+    const history = await fetchNormalizedHistory(makeHandle([{ eventType: "ActivityTaskScheduled" }]));
+    expect(history.events?.[0].eventType).toBe("ActivityTaskScheduled");
+  });
+
+  test("an ISO eventTime string (already-normalized data) round-trips to the same instant", async () => {
+    const history = await fetchNormalizedHistory(makeHandle([{ eventTime: "2026-05-01T00:00:00.000Z" }]));
+    expect(history.events?.[0].eventTime?.toISOString()).toBe("2026-05-01T00:00:00.000Z");
+  });
+
+  test("no events → empty array, not an error", async () => {
+    const history = await fetchNormalizedHistory(makeHandle([]));
+    expect(history.events).toEqual([]);
+  });
+});

package/src/cli/handlers/run-client.ts

@@ -30,6 +30,7 @@ export interface WorkflowHandleRaw {
   describe(): Promise<WorkflowExecutionDescription>;
   fetchHistory(): Promise<WorkflowHistoryRaw>;
   signal(signalName: string, ...args: unknown[]): Promise<void>;
+  query<T = unknown>(queryName: string, ...args: unknown[]): Promise<T>;
   cancel(): Promise<void>;
 }
 
@@ -56,16 +57,98 @@ export interface WorkflowHistoryRaw {
   events?: HistoryEvent[];
 }
 
+/**
+ * `eventType` is the short PascalCase form (`"ActivityTaskScheduled"`, not
+ * the wire enum's `"EVENT_TYPE_ACTIVITY_TASK_SCHEDULED"`) and `eventId`/
+ * `scheduledEventId` are decimal strings — the shape {@link fetchNormalizedHistory}
+ * produces, not `WorkflowHandleRaw.fetchHistory()`'s own raw return value.
+ */
 export interface HistoryEvent {
+  eventId?: string;
   eventType?: string;
   eventTime?: Date;
-  activityTaskCompletedEventAttributes?: { scheduledEventId?: string | number };
+  activityTaskCompletedEventAttributes?: { scheduledEventId?: string };
   activityTaskScheduledEventAttributes?: { activityId?: string; activityType?: { name?: string } };
-  activityTaskFailedEventAttributes?: { failure?: { message?: string } };
+  activityTaskFailedEventAttributes?: { scheduledEventId?: string; failure?: { message?: string } };
   workflowExecutionCompletedEventAttributes?: unknown;
   workflowExecutionFailedEventAttributes?: { failure?: { message?: string } };
 }
 
+/**
+ * `WorkflowHandleRaw.fetchHistory()` returns the Temporal wire proto
+ * untouched: `eventType` is the numeric enum, `eventId`/`scheduledEventId`
+ * are `Long` instances, `eventTime` is a `{seconds, nanos}` protobuf
+ * Timestamp — none of them comparable or constructible the way the rest of
+ * this file (and run-report.ts, op-progress.ts) needs. The proto message's
+ * own `toJSON()` is what turns enums into their string name and `Long`s into
+ * decimal strings, so a JSON round-trip is the normalization step; only
+ * `eventTime` then needs a further Timestamp-to-Date conversion.
+ */
+export async function fetchNormalizedHistory(handle: WorkflowHandleRaw): Promise<WorkflowHistoryRaw> {
+  const raw = (await handle.fetchHistory()) as unknown as { events?: unknown[] };
+  const events = JSON.parse(JSON.stringify(raw.events ?? [])) as Array<Record<string, unknown>>;
+  return { events: events.map(normalizeHistoryEvent) };
+}
+
+/** `"EVENT_TYPE_ACTIVITY_TASK_SCHEDULED"` → `"ActivityTaskScheduled"`. A value that isn't ALL_CAPS_WITH_UNDERSCORES (e.g. already-short test fixture data) passes through unchanged, so normalizing twice is a no-op. */
+function shortEventType(raw: unknown): string | undefined {
+  if (typeof raw !== "string" || raw.length === 0) return undefined;
+  if (!/^[A-Z][A-Z0-9_]*$/.test(raw)) return raw;
+  const stripped = raw.startsWith("EVENT_TYPE_") ? raw.slice("EVENT_TYPE_".length) : raw;
+  return stripped
+    .split("_")
+    .filter(Boolean)
+    .map((w) => w[0] + w.slice(1).toLowerCase())
+    .join("");
+}
+
+/** Accepts a protobuf `{seconds, nanos}` Timestamp (its `seconds` a decimal string post-JSON-round-trip), an ISO string (already-normalized test fixture data, or the same value normalized twice), or a `Date`. */
+function protoTimestampToDate(ts: unknown): Date | undefined {
+  if (!ts) return undefined;
+  if (ts instanceof Date) return ts;
+  if (typeof ts === "string") {
+    const d = new Date(ts);
+    return Number.isNaN(d.getTime()) ? undefined : d;
+  }
+  if (typeof ts !== "object") return undefined;
+  const seconds = Number((ts as { seconds?: unknown }).seconds);
+  const nanos = Number((ts as { nanos?: unknown }).nanos ?? 0);
+  if (!Number.isFinite(seconds)) return undefined;
+  return new Date(seconds * 1000 + Math.floor(nanos / 1e6));
+}
+
+/** `undefined`/`null` stays `undefined`; anything else (a decimal string post-JSON-round-trip, or a bare number/Long from an un-round-tripped test fixture) becomes a string — `scheduledEventId` is joined against `eventId` as a Map key, and a number `7` and a string `"7"` are different keys. */
+function idString(v: unknown): string | undefined {
+  return v === undefined || v === null ? undefined : String(v);
+}
+
+function normalizeHistoryEvent(raw: Record<string, unknown>): HistoryEvent {
+  const scheduled = raw.activityTaskScheduledEventAttributes as
+    | { activityId?: unknown; activityType?: { name?: string } }
+    | undefined;
+  const completed = raw.activityTaskCompletedEventAttributes as { scheduledEventId?: unknown } | undefined;
+  const failed = raw.activityTaskFailedEventAttributes as
+    | { scheduledEventId?: unknown; failure?: { message?: string } }
+    | undefined;
+
+  return {
+    eventId: idString(raw.eventId),
+    eventType: shortEventType(raw.eventType),
+    eventTime: protoTimestampToDate(raw.eventTime),
+    ...(scheduled
+      ? { activityTaskScheduledEventAttributes: { activityId: idString(scheduled.activityId), activityType: scheduled.activityType } }
+      : {}),
+    ...(completed
+      ? { activityTaskCompletedEventAttributes: { scheduledEventId: idString(completed.scheduledEventId) } }
+      : {}),
+    ...(failed
+      ? { activityTaskFailedEventAttributes: { scheduledEventId: idString(failed.scheduledEventId), failure: failed.failure } }
+      : {}),
+    workflowExecutionCompletedEventAttributes: raw.workflowExecutionCompletedEventAttributes,
+    workflowExecutionFailedEventAttributes: raw.workflowExecutionFailedEventAttributes as HistoryEvent["workflowExecutionFailedEventAttributes"],
+  };
+}
+
 /**
  * Dynamically import @temporalio/client from the user's project node_modules.
  * Fails with a helpful message if not installed.

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

@@ -0,0 +1,62 @@
+import { describe, test, expect } from "vitest";
+import { generateReport } from "./run-report";
+import type { OpConfig } from "../../op/types";
+import type { WorkflowExecutionDescription, WorkflowHistoryRaw, HistoryEvent } from "./run-client";
+
+function scheduled(eventId: string, fn: string): HistoryEvent {
+  return {
+    eventId,
+    eventType: "ActivityTaskScheduled",
+    eventTime: new Date(0),
+    activityTaskScheduledEventAttributes: { activityId: eventId, activityType: { name: fn } },
+  };
+}
+function completed(scheduledEventId: string): HistoryEvent {
+  return {
+    eventType: "ActivityTaskCompleted",
+    eventTime: new Date(1000),
+    activityTaskCompletedEventAttributes: { scheduledEventId },
+  };
+}
+
+const desc: WorkflowExecutionDescription = {
+  workflowId: "wf", runId: "r1", status: { name: "COMPLETED" },
+  startTime: new Date(0), closeTime: new Date(2000), taskQueue: "q", type: { name: "opWorkflow" },
+};
+
+describe("generateReport", () => {
+  test("two steps calling the same activity each get their own row (no last-wins collision, chant #1676)", () => {
+    const config: OpConfig = {
+      name: "op", overview: "o",
+      phases: [{ name: "P1", steps: [{ kind: "activity", fn: "dup" }, { kind: "activity", fn: "dup" }] }],
+    };
+    const history: WorkflowHistoryRaw = {
+      events: [scheduled("1", "dup"), completed("1"), scheduled("2", "dup"), completed("2")],
+    };
+    const md = generateReport("op", config, desc, history);
+    // Both rows present — the prior fn-name join would have produced one
+    // row for "dup" (the second scheduled event overwriting the first).
+    const dupRows = md.split("\n").filter((line) => line.includes("| P1 | dup |"));
+    expect(dupRows).toHaveLength(2);
+    expect(dupRows.every((line) => line.includes("✓ completed"))).toBe(true);
+  });
+
+  test("a declared step with no matching history is reported skipped, not a phantom 'running' row", () => {
+    const config: OpConfig = {
+      name: "op", overview: "o",
+      phases: [
+        { name: "P1", steps: [{ kind: "activity", fn: "a" }] },
+        { name: "P2", steps: [{ kind: "activity", fn: "b" }] },
+      ],
+      onFailure: [{ name: "C1", steps: [{ kind: "activity", fn: "comp" }] }],
+    };
+    const history: WorkflowHistoryRaw = { events: [scheduled("1", "a"), completed("1"), scheduled("2", "b"), completed("2")] };
+    const md = generateReport("op", config, desc, history);
+    expect(md).toContain("| P1 | a | 1.0s | ✓ completed |");
+    expect(md).toContain("| P2 | b | 1.0s | ✓ completed |");
+    // The timeline table is scoped to config.phases only (unchanged from
+    // before this fix) — onFailure phases never appear in it regardless of
+    // whether they ran.
+    expect(md).not.toContain("C1");
+  });
+});

package/src/cli/handlers/run-report.ts

@@ -2,13 +2,12 @@ import { writeFileSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 import type { OpConfig } from "../../op/types";
 import type { WorkflowExecutionDescription, WorkflowHistoryRaw, HistoryEvent } from "./run-client";
+import { extractStepRecords } from "./op-progress";
 
 interface ActivityRecord {
   name: string;
-  startTime?: Date;
-  endTime?: Date;
   durationMs?: number;
-  status: "completed" | "failed" | "running";
+  status: "completed" | "failed" | "skipped";
   error?: string;
 }
 
@@ -25,61 +24,24 @@ function formatDuration(ms: number): string {
   return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
 }
 
-function extractPhaseRecords(config: OpConfig, history: WorkflowHistoryRaw): PhaseRecord[] {
-  const events = history.events ?? [];
-
-  // Build map: scheduled event ID → activity name
-  const scheduledActivities = new Map<string, string>();
-  const scheduledTimes = new Map<string, Date>();
-  const completedTimes = new Map<string, Date>();
-  const failedActivities = new Map<string, string>();
-
-  for (const event of events) {
-    if (event.eventType === "ActivityTaskScheduled" && event.activityTaskScheduledEventAttributes) {
-      const attrs = event.activityTaskScheduledEventAttributes;
-      const id = String(attrs.activityId ?? "");
-      const name = attrs.activityType?.name ?? "unknown";
-      scheduledActivities.set(id, name);
-      if (event.eventTime) scheduledTimes.set(id, new Date(event.eventTime));
-    }
-    if (event.eventType === "ActivityTaskCompleted" && event.activityTaskCompletedEventAttributes) {
-      const scheduledId = String(event.activityTaskCompletedEventAttributes.scheduledEventId ?? "");
-      if (event.eventTime) completedTimes.set(scheduledId, new Date(event.eventTime));
-    }
-    if (event.eventType === "ActivityTaskFailed" && event.activityTaskFailedEventAttributes) {
-      const msg = event.activityTaskFailedEventAttributes.failure?.message ?? "unknown error";
-      failedActivities.set(String(events.indexOf(event)), msg);
-    }
+/**
+ * Group `extractStepRecords`' flat, declared-order step list back into
+ * per-phase rows for the markdown table. `final` (a closed workflow has
+ * every settled step it's ever going to have) decides whether an unmatched
+ * declared step is reported "skipped" or simply omitted for now — see
+ * `extractStepRecords`'s own doc.
+ */
+function extractPhaseRecords(config: OpConfig, history: WorkflowHistoryRaw, final: boolean): PhaseRecord[] {
+  const byPhase = new Map<string, ActivityRecord[]>();
+  for (const phase of config.phases) byPhase.set(phase.name, []);
+
+  for (const step of extractStepRecords(config, history, { final })) {
+    const status = step.status === "ok" ? "completed" : step.status === "fail" ? "failed" : "skipped";
+    const list = byPhase.get(step.phase) ?? (byPhase.set(step.phase, []), byPhase.get(step.phase)!);
+    list.push({ name: step.fn, durationMs: step.durationMs, status, ...(step.error ? { error: step.error } : {}) });
   }
 
-  return config.phases.map((phase) => {
-    const activities: ActivityRecord[] = phase.steps
-      .filter((s) => s.kind === "activity")
-      .map((step) => {
-        if (step.kind !== "activity") return null;
-        const fn = step.fn;
-        // Find this activity by name in the history
-        let record: ActivityRecord | null = null;
-        for (const [id, name] of scheduledActivities) {
-          if (name === fn) {
-            const start = scheduledTimes.get(id);
-            const end = completedTimes.get(id);
-            const durationMs = start && end ? end.getTime() - start.getTime() : undefined;
-            record = {
-              name: fn,
-              startTime: start,
-              endTime: end,
-              durationMs,
-              status: end ? "completed" : "running",
-            };
-          }
-        }
-        return record ?? { name: fn, status: "running" };
-      })
-      .filter((r): r is ActivityRecord => r !== null);
-
-    return { name: phase.name, activities };
-  });
+  return config.phases.map((phase) => ({ name: phase.name, activities: byPhase.get(phase.name) ?? [] }));
 }
 
 export function generateReport(
@@ -116,14 +78,14 @@ export function generateReport(
   lines.push("| Phase | Activity | Duration | Status |");
   lines.push("|---|---|---|---|");
 
-  const phases = extractPhaseRecords(config, history);
+  const phases = extractPhaseRecords(config, history, Boolean(closeTime));
   for (const phase of phases) {
     if (phase.activities.length === 0) {
       lines.push(`| ${phase.name} | — | — | — |`);
     }
     for (const act of phase.activities) {
       const dur = act.durationMs !== undefined ? formatDuration(act.durationMs) : "—";
-      const statusEmoji = act.status === "completed" ? "✓" : act.status === "failed" ? "✗" : "…";
+      const statusEmoji = act.status === "completed" ? "✓" : act.status === "failed" ? "✗" : "○";
       lines.push(`| ${phase.name} | ${act.name} | ${dur} | ${statusEmoji} ${act.status} |`);
     }
   }

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

@@ -50,6 +50,9 @@ vi.mock("./run-client", () => ({
   connectionOptions: (profile: { address: string }) => ({ address: profile.address }),
   resolveProfile: (...args: unknown[]) => resolveProfileMock(...args),
   resolveWorkflowId: (name: string) => `chant-op-${name}`,
+  // Test fixtures already use the short event-type form fetchNormalizedHistory
+  // produces (see mock-temporal-client.ts) — a passthrough keeps them valid.
+  fetchNormalizedHistory: (handle: { fetchHistory(): Promise<unknown> }) => handle.fetchHistory(),
 }));
 vi.mock("node:fs", async () => {
   const actual = await vi.importActual<typeof import("node:fs")>("node:fs");
@@ -297,6 +300,54 @@ describe("runOpStatus", () => {
     expect(out).toContain("COMPLETED");
     expect(out).toContain("1/2 completed");
   });
+
+  test("a pending gate prints a Gate line via the gateState query (#1676)", async () => {
+    setupTemporalClient(createMockTemporalClient({
+      describeByWorkflowId: {
+        "chant-op-alb-deploy": {
+          workflowId: "chant-op-alb-deploy", runId: "r1",
+          status: { name: "RUNNING" },
+          startTime: new Date("2026-05-01T00:00:00Z"),
+          taskQueue: "alb-deploy", type: { name: "albDeployWorkflow" },
+        },
+      },
+      historyByWorkflowId: { "chant-op-alb-deploy": [] },
+      queryResultByWorkflowId: {
+        "chant-op-alb-deploy:gateState": {
+          signalName: "gate-dns-delegation",
+          description: "Approve DNS delegation",
+          since: "2026-05-01T00:05:00.000Z",
+        },
+      },
+    }));
+    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("Gate");
+    expect(out).toContain("gate-dns-delegation");
+    expect(out).toContain("Approve DNS delegation");
+    expect(out).toContain("2026-05-01T00:05:00.000Z");
+  });
+
+  test("an Op with no pending gate (query unregistered or answers null) prints no Gate line", 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": [] },
+    }));
+    const stdout = makeStdoutSpy();
+    const exit = await runOpStatus({ args: makeArgs({ extraPositional: "alb-deploy" }), plugins: [], serializers: [] });
+    expect(exit).toBe(0);
+    expect(stdout.join("\n")).not.toContain("Gate");
+  });
 });
 
 // ── chant run status <name> --components (#599) ─────────────────────────────
@@ -731,6 +782,99 @@ describe("runOp", () => {
     }
   });
 
+  // ── --progress-json (#1676) ──────────────────────────────────────────────
+
+  test("--progress-json streams one NDJSON StepRecord per settled step, plus a final skipped record", async () => {
+    vi.useFakeTimers();
+    try {
+      discoverOpsMock.mockResolvedValue({
+        ops: new Map([[
+          "alb-deploy",
+          {
+            config: {
+              name: "alb-deploy", overview: "o",
+              phases: [
+                { name: "Build", steps: [{ kind: "activity", fn: "build" }] },
+                { name: "Deploy", steps: [{ kind: "activity", fn: "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": [
+            { eventId: "1", eventType: "ActivityTaskScheduled", activityTaskScheduledEventAttributes: { activityId: "1", activityType: { name: "build" } } },
+            { eventType: "ActivityTaskCompleted", activityTaskCompletedEventAttributes: { scheduledEventId: "1" } },
+          ],
+        },
+      }));
+      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 stdoutLines: string[] = [];
+      const stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation((chunk) => { stdoutLines.push(String(chunk)); return true; });
+
+      const promise = runOp({ args: makeArgs({ path: "alb-deploy", progressJson: true }), plugins: [], serializers: [] });
+      await vi.advanceTimersByTimeAsync(5000);
+      const exit = await promise;
+
+      expect(exit).toBe(0);
+      const records = stdoutLines.filter((l) => l.trim()).map((l) => JSON.parse(l));
+      expect(records).toEqual([
+        { phase: "Build", fn: "build", status: "ok", durationMs: 0 },
+        { phase: "Deploy", fn: "deploy", status: "skipped", durationMs: 0 },
+      ]);
+      stdoutSpy.mockRestore();
+    } finally {
+      vi.useRealTimers();
+    }
+  }, 10_000);
+
+  test("without --progress-json, nothing is written to stdout during the poll loop", async () => {
+    vi.useFakeTimers();
+    try {
+      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": [] },
+      }));
+      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 stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+
+      const promise = runOp({ args: makeArgs({ path: "alb-deploy" }), plugins: [], serializers: [] });
+      await vi.advanceTimersByTimeAsync(5000);
+      await promise;
+
+      expect(stdoutSpy).not.toHaveBeenCalled();
+      stdoutSpy.mockRestore();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   test("workflow ends in FAILED → exit 1, worker still killed", async () => {
     vi.useFakeTimers();
     try {