@intentius/chant 0.50.0 → 0.51.0

package/src/cli/handlers/op-progress.ts

@@ -0,0 +1,192 @@
+/**
+ * Per-phase progress reconstructed from a Temporal Op workflow's history
+ * (chant #1676) — the durable-path counterpart to the local executor's
+ * `StepRecord[]` (op/local-executor.ts), so `chant run <name> --temporal
+ * --progress-json` and `op-status` can report the same shape `chant run
+ * <name> --json` already does for the local path, instead of the two raw
+ * `ActivityTaskScheduled`/`ActivityTaskCompleted` counts.
+ *
+ * A step is joined to its declared (phase, fn) by position, not by name: the
+ * declared step list (`declaredStepOrder`, mirroring the serializer's own
+ * `collectActivitySteps` traversal — main phases, then `onFailure` phases
+ * *reversed*, matching how the generated workflow actually runs them) is
+ * walked in order, and each step consumes the next not-yet-consumed
+ * `ActivityTaskScheduled` event whose activity type matches its `fn` — a
+ * per-fn FIFO queue, not a global "does this name appear anywhere" scan.
+ * Two steps calling the same activity therefore each get their own
+ * scheduled event instead of the later one overwriting the earlier
+ * (the collision the prior `run-report.ts` join had). A step whose queue is
+ * empty never ran this execution — an untaken effect branch, or an
+ * `onFailure` phase on a run that succeeded.
+ */
+
+import type { OpConfig, PhaseDefinition } from "../../op/types";
+import type { StepRecord } from "../../op/local-executor";
+import type { WorkflowHistoryRaw, HistoryEvent, WorkflowHandleRaw } from "./run-client";
+
+// Synthesized step names an effect step's read-compare-run-write compiles
+// to (lexicons/temporal/src/op/serializer.ts's RECEIPT_READ_STEP/
+// RECEIPT_WRITE_STEP) — duplicated here rather than imported so this module
+// stays lexicon-free, same constraint as op/local-executor.ts.
+const RECEIPT_READ_FN = "receiptRead";
+const RECEIPT_WRITE_FN = "receiptWrite";
+
+interface DeclaredStep {
+  phase: string;
+  fn: string;
+}
+
+function flattenPhases(phases: PhaseDefinition[]): DeclaredStep[] {
+  const out: DeclaredStep[] = [];
+  for (const phase of phases) {
+    for (const step of phase.steps) {
+      if (step.kind === "activity") {
+        out.push({ phase: phase.name, fn: step.fn });
+      } else if (step.kind === "effect") {
+        out.push({ phase: phase.name, fn: RECEIPT_READ_FN });
+        for (const nested of step.steps) {
+          if (nested.kind === "activity") out.push({ phase: phase.name, fn: nested.fn });
+        }
+        out.push({ phase: phase.name, fn: RECEIPT_WRITE_FN });
+      }
+      // Gate steps schedule no activity — nothing to join them to.
+    }
+  }
+  return out;
+}
+
+/** Declared order matching actual scheduling order: main phases, then `onFailure` reversed (compensation runs last-declared-first — serializer.ts's `renderPhases([...config.onFailure].reverse())`). */
+function declaredStepOrder(config: OpConfig): DeclaredStep[] {
+  return [...flattenPhases(config.phases), ...flattenPhases([...(config.onFailure ?? [])].reverse())];
+}
+
+interface ScheduledEntry {
+  scheduledEventId: string;
+  scheduledAt?: Date;
+}
+
+/** Every `ActivityTaskScheduled` event, grouped by activity type name, in chronological order. */
+function scheduledQueues(events: HistoryEvent[]): Map<string, ScheduledEntry[]> {
+  const byFn = new Map<string, ScheduledEntry[]>();
+  for (const e of events) {
+    if (e.eventType !== "ActivityTaskScheduled") continue;
+    const attrs = e.activityTaskScheduledEventAttributes;
+    if (!attrs) continue;
+    const fn = attrs.activityType?.name ?? "unknown";
+    if (!byFn.has(fn)) byFn.set(fn, []);
+    byFn.get(fn)!.push({ scheduledEventId: e.eventId ?? "", scheduledAt: e.eventTime });
+  }
+  return byFn;
+}
+
+interface TerminalOutcome {
+  status: "ok" | "fail";
+  at?: Date;
+  error?: string;
+}
+
+/**
+ * The terminal outcome of each scheduled activity, keyed by the scheduling
+ * event's own id. A retried activity emits one `ActivityTaskFailed` per
+ * attempt under the same `scheduledEventId`; walking events in order and
+ * always overwriting on a later event leaves whichever came last —
+ * `ActivityTaskCompleted` on an eventual success, otherwise the final
+ * attempt's failure.
+ */
+function terminalOutcomes(events: HistoryEvent[]): Map<string, TerminalOutcome> {
+  const out = new Map<string, TerminalOutcome>();
+  for (const e of events) {
+    if (e.eventType === "ActivityTaskCompleted" && e.activityTaskCompletedEventAttributes) {
+      const id = e.activityTaskCompletedEventAttributes.scheduledEventId;
+      if (id) out.set(id, { status: "ok", at: e.eventTime });
+    } else if (e.eventType === "ActivityTaskFailed" && e.activityTaskFailedEventAttributes) {
+      const id = e.activityTaskFailedEventAttributes.scheduledEventId;
+      if (id) {
+        out.set(id, {
+          status: "fail",
+          at: e.eventTime,
+          error: e.activityTaskFailedEventAttributes.failure?.message ?? "unknown error",
+        });
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * Reconstruct per-step progress records from a workflow's history, in
+ * declared order. Only settled steps (matched to a scheduled event that has
+ * since completed or failed) produce a record — a step that hasn't been
+ * scheduled yet simply isn't in the result, so a live poll only ever
+ * appends. Pass `final: true` once the workflow has reached a terminal
+ * status to also emit a `"skipped"` record for every declared step that
+ * never got a matching scheduled event (an untaken effect branch, or an
+ * `onFailure` phase on a run that succeeded) — never before, or a
+ * still-running Op would show its not-yet-reached steps as skipped.
+ */
+export function extractStepRecords(
+  config: OpConfig,
+  history: WorkflowHistoryRaw,
+  opts: { final?: boolean } = {},
+): StepRecord[] {
+  const events = history.events ?? [];
+  const queues = scheduledQueues(events);
+  const terminals = terminalOutcomes(events);
+  const nextIndex = new Map<string, number>();
+
+  const records: StepRecord[] = [];
+  for (const step of declaredStepOrder(config)) {
+    const queue = queues.get(step.fn);
+    const idx = nextIndex.get(step.fn) ?? 0;
+    const entry = queue?.[idx];
+    if (!entry) {
+      if (opts.final) records.push({ phase: step.phase, fn: step.fn, status: "skipped", durationMs: 0 });
+      continue;
+    }
+    nextIndex.set(step.fn, idx + 1);
+
+    const terminal = terminals.get(entry.scheduledEventId);
+    if (!terminal) continue; // scheduled but not yet settled
+
+    const durationMs =
+      entry.scheduledAt && terminal.at ? terminal.at.getTime() - entry.scheduledAt.getTime() : 0;
+    records.push({
+      phase: step.phase,
+      fn: step.fn,
+      status: terminal.status,
+      durationMs,
+      ...(terminal.error ? { error: terminal.error } : {}),
+    });
+  }
+  return records;
+}
+
+/** `{completed, scheduled}` activity counts for the summary line `chant run status`/`op-status` show alongside the full record list. */
+export function countActivities(history: WorkflowHistoryRaw): { completed: number; scheduled: number } {
+  const events = history.events ?? [];
+  return {
+    completed: events.filter((e) => e.eventType === "ActivityTaskCompleted").length,
+    scheduled: events.filter((e) => e.eventType === "ActivityTaskScheduled").length,
+  };
+}
+
+/** The `gateState` workflow query's result (op/serializer.ts's `emitGate`) — the gate currently blocking the workflow, or `null` when none is pending. */
+export interface GateQueryResult {
+  signalName: string;
+  description?: string;
+  since: string;
+}
+
+/**
+ * Best-effort `gateState` query. `undefined` (as opposed to `null`) means
+ * the query itself failed — an Op with no gate steps never registers a
+ * `gateState` handler, so querying it is expected to fail, not an error
+ * worth surfacing.
+ */
+export async function queryGateState(handle: WorkflowHandleRaw): Promise<GateQueryResult | null | undefined> {
+  try {
+    return await handle.query<GateQueryResult | null>("gateState");
+  } catch {
+    return undefined;
+  }
+}

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} |`);
     }
   }