@intentius/chant 0.57.0 → 0.59.0

package/src/components/driver.ts

@@ -11,11 +11,18 @@
  * component.schema.json (`@Phase.field` prior-step references,
  * `@<component>.publish.<field>` cross-component artifact references, and
  * passes through `$env.*`/`stackOutput` values as opaque env config), runs
- * `parallel` phases concurrently, rejects a `gate` locally (matching
- * ../op/local-executor.ts's `LocalGateUnsupportedError`), and on terminal
- * failure unwinds every executed step in reverse via that step's capability
- * `rollback`, then runs `onFailure` phases in reverse order (best-effort),
- * mirroring the Op local executor's saga semantics.
+ * `parallel` phases concurrently, decides a `gate` against the gate ledger
+ * (#2119 — the same `../op/gate.ts` the Op executor uses, so `chant run
+ * --components` and `chant run <op>` can never disagree about what a gate
+ * means), and on terminal failure unwinds every executed step in reverse via
+ * that step's capability `rollback`, then runs `onFailure` phases in reverse
+ * order (best-effort), mirroring the Op local executor's saga semantics.
+ *
+ * A gate nobody has approved is not a failure: the component stops there with
+ * status `gated`, the pending fact is on the ledger, and no rollback and no
+ * `onFailure` phase runs — nothing failed and the steps that did run are the
+ * steps the author meant to run before the approval. The next run re-reads the
+ * ledger and continues past the gate if `chant approve` has answered it.
  *
  * A step whose capability declares no `rollback` is never silently passed
  * over during unwind: it gets a `"rollback-opted-out"` record (see
@@ -25,15 +32,13 @@
  * already requires at author time — the driver reports the same fact the
  * lint rule already made a component author state.
  *
- * This unwind runs entirely in-process: if the process crashes mid-rollback
- * on the local executor, nothing resumes it — there is no persisted run state
- * to resume from. That is the documented Temporal boundary (see
- * docs/components/orchestration.mdx#rollback-comes-free and
- * docs/guide/local-vs-temporal.mdx): the *mechanism* (reverse-order unwind
- * calling each capability's `rollback`) is capability-agnostic and works
- * identically on both executors, but *durable resume of a rollback already in
- * progress* is Temporal-only, the same boundary that already applies to
- * forward `onFailure` compensation on an Op.
+ * This unwind runs entirely in-process: if the process crashes mid-rollback,
+ * nothing resumes it — there is no persisted run state to resume from (see
+ * docs/components/orchestration.mdx#rollback-comes-free). The *mechanism*
+ * (reverse-order unwind calling each capability's `rollback`) is
+ * capability-agnostic; *durable resume of a rollback already in progress*
+ * would be a hosting runtime's to offer, the same boundary that already
+ * applies to forward `onFailure` compensation on an Op.
  *
  * Contains zero per-component logic: nothing in this module branches on a
  * component or capability `kind`/name. All behavior is either generic
@@ -42,8 +47,11 @@
  */
 
 import { topoSort } from "../codegen/topo-sort";
+import { evaluateGate, gitGateLedgerPort, type GateLedgerPort } from "../op/gate";
+import { gateName } from "../op/gate-name";
+import type { PendingGateRecord } from "../lifecycle/gate-ledger";
 import type { CapabilityRegistry, DeployContext } from "./capability";
-import type { RunProgressEvent } from "./run-progress";
+import type { RunProgressEvent, RunProgressStatus } from "./run-progress";
 
 export type { RunProgressEvent } from "./run-progress";
 
@@ -61,10 +69,16 @@ export interface DriverStep {
   [param: string]: unknown;
 }
 
-/** A gate step — pauses for an external signal; unsupported on the local executor (schema `Gate`). */
+/**
+ * A gate step — a human approval, decided against the gate ledger when the run
+ * reaches it (schema `Gate`). The name is on `gate`; `signalName` is the
+ * deprecated spelling (#2202), so read the name through `gateName()`.
+ */
 export interface DriverGate {
   kind: "gate";
-  signalName: string;
+  gate?: string;
+  /** @deprecated Renamed to `gate` in #2202. Accepted through 0.59.0, removed in 0.60.0. */
+  signalName?: string;
   timeout?: string;
   description?: string;
 }
@@ -96,20 +110,6 @@ function isPhaseStep(step: DriverStep | DriverGate | DriverPhase): step is Drive
 
 // ── Errors ────────────────────────────────────────────────────────────────
 
-/** Thrown when a component's composition contains a `gate` — gates need a durable runtime, matching chant's Op local executor. */
-export class DriverGateUnsupportedError extends Error {
-  constructor(
-    public readonly component: string,
-    public readonly signalName: string,
-  ) {
-    super(
-      `component "${component}": gate "${signalName}" is not supported on the local executor — ` +
-        `gates need a durable runtime. Re-run with a durable (Temporal) backend.`,
-    );
-    this.name = "DriverGateUnsupportedError";
-  }
-}
-
 /** Thrown when a dependency cycle is found among `dependsOn` edges. */
 export class DependencyCycleError extends Error {
   constructor(public readonly cycle: string[]) {
@@ -147,12 +147,18 @@ export interface DriverStepRecord {
   durationMs: number;
   output?: unknown;
   error?: string;
+  /** Set on a `gate` step that passed (#2119): who resolved it, when, and at what address. */
+  approval?: { gate: string; resolvedBy: string; timestamp: string; url?: string };
 }
 
 export interface DriverComponentResult {
   component: string;
   ok: boolean;
+  /** Three-state outcome (#2119) — `gated` is `ok: false` without being a failure: the component stopped at a gate awaiting `chant approve`, and nothing was rolled back. */
+  status: "ok" | "fail" | "gated";
   records: DriverStepRecord[];
+  /** Present when `status === "gated"`: the pending fact this component stopped on. */
+  gate?: PendingGateRecord;
 }
 
 export interface DriverRunResult {
@@ -162,8 +168,14 @@ export interface DriverRunResult {
   waves: string[][];
   results: DriverComponentResult[];
   ok: boolean;
+  /** Three-state outcome (#2119), matching `OpRunResult.status`. */
+  status: "ok" | "fail" | "gated";
   /** Name of the component that terminated the run, if any. */
   failedComponent?: string;
+  /** Name of the component the run stopped at for approval, when `status === "gated"`. */
+  gatedComponent?: string;
+  /** The pending fact the run stopped on, when `status === "gated"`. */
+  gate?: PendingGateRecord;
   /**
    * The accumulated cross-component/cross-stack outputs after the run — each
    * component's `publish` output and, for an applied stack, its `cfn-deploy`
@@ -285,12 +297,11 @@ export function resolveWiring(
  * Deep-walk an object, resolving every string/stackOutput wiring value found.
  * Arrays and nested objects are walked too.
  *
- * Exported (not just used internally) so the durable Temporal path
- * (`@intentius/chant-lexicon-temporal`'s component workflow codegen, see
- * epic #551 #589) can resolve a step's wiring the same way inside a Temporal
- * *activity* — the workflow itself only accumulates `phaseOutputs`/
- * `componentOutputs` and passes them through; resolution logic stays in one
- * place so local and durable execution can never silently diverge.
+ * Exported (not just used internally) so a hosting runtime that runs steps
+ * out of process can resolve a step's wiring the same way — the orchestrator
+ * only accumulates `phaseOutputs`/`componentOutputs` and passes them through;
+ * resolution logic stays in one place so local and hosted execution can never
+ * silently diverge.
  */
 export function resolveStepInput(
   input: Record<string, unknown>,
@@ -338,6 +349,29 @@ class StepFailure extends Error {
   }
 }
 
+/** Internal: a phase stopped at an unapproved gate (#2119). Carries what ran before it, so the records survive; not a failure, so no unwind follows. */
+class GateStop extends Error {
+  constructor(
+    public readonly records: DriverStepRecord[],
+    public readonly executed: ExecutedStep[],
+    public readonly pending: PendingGateRecord,
+  ) {
+    super(`gate "${pending.gate}" is pending approval`);
+    this.name = "GateStop";
+  }
+}
+
+/** A result status as the progress stream spells it — the only difference is `fail` vs `failed`, which the two vocabularies have always disagreed on. */
+function progressStatus(status: DriverComponentResult["status"]): RunProgressStatus {
+  return status === "fail" ? "failed" : status;
+}
+
+/** How a component's run reaches the gate ledger — see `../op/gate.ts`. */
+export interface GateContext {
+  port: GateLedgerPort;
+  now?: string;
+}
+
 /** Run a single capability step. Never throws for a capability-run failure; returns a fail record instead. */
 async function runCapabilityStep(
   step: DriverStep,
@@ -381,11 +415,16 @@ async function runCapabilityStep(
 }
 
 /**
- * Run a phase's steps. A step may be a `Gate` (rejected — local executor has
- * no durable wait) or a nested `Phase` (a fan-out unit; recursed into,
- * inheriting `parallel` from its own definition, not its parent's). Steps run
- * sequentially unless `phase.parallel` is set, in which case they run via
- * `Promise.all`, matching ../op/local-executor.ts's phase semantics.
+ * Run a phase's steps. A step may be a `Gate` (decided against the gate
+ * ledger, in authored order — a resolution newer than the gate's newest
+ * pending fact lets it pass carrying the approver, anything else records the
+ * fact and stops the component) or a nested `Phase` (a fan-out unit; recursed
+ * into, inheriting `parallel` from its own definition, not its parent's).
+ * Steps run sequentially unless `phase.parallel` is set, in which case they run
+ * via `Promise.all`, matching ../op/local-executor.ts's phase semantics — and
+ * as there, a gate in a parallel phase is decided before the fan-out, since a
+ * gate is a read of the ledger rather than work, and starting activities a
+ * pending gate is about to strand defeats the point of stopping at it.
  *
  * `onProgress`, when supplied, is called with a `phase-start` event before any
  * step runs, a `step` event around each capability invocation (`"running"`
@@ -402,22 +441,60 @@ async function runPhase(
   registry: CapabilityRegistry,
   phaseOutputs: Record<string, Record<string, unknown>>,
   componentOutputs: Record<string, Record<string, unknown>>,
+  gates: GateContext,
   onProgress?: (event: RunProgressEvent) => void,
 ): Promise<{ records: DriverStepRecord[]; executed: ExecutedStep[] }> {
-  const gate = phaseDef.steps.find(isGateStep);
-  if (gate) throw new DriverGateUnsupportedError(ctx.component, gate.signalName);
+  /** Decide this phase's gates against the ledger, in authored order, before any of its work starts. Throws `GateStop` at the first one nobody has approved. */
+  const decideGates = async (): Promise<DriverStepRecord[]> => {
+    const gateRecords: DriverStepRecord[] = [];
+    for (const gate of phaseDef.steps.filter(isGateStep)) {
+      const start = Date.now();
+      const check = await evaluateGate(gates.port, {
+        op: ctx.component,
+        gate: gateName(gate),
+        ...(gate.description ? { description: gate.description } : {}),
+        ...(gate.timeout ? { timeout: gate.timeout } : {}),
+        ...(gates.now ? { now: gates.now } : {}),
+      });
+      const base = { component: ctx.component, phase: phaseDef.phase, kind: `gate:${gateName(gate)}` };
+      if (!check.satisfied) {
+        gateRecords.push({ ...base, status: "skipped" as const, durationMs: Date.now() - start });
+        for (const skipped of phaseDef.steps.filter((s): s is DriverStep | DriverPhase => !isGateStep(s))) {
+          gateRecords.push(skippedRecord(skipped));
+        }
+        throw new GateStop(gateRecords, [], check.pending);
+      }
+      gateRecords.push({
+        ...base,
+        status: "ok" as const,
+        durationMs: Date.now() - start,
+        approval: {
+          gate: gateName(gate),
+          resolvedBy: check.resolution.resolvedBy,
+          timestamp: check.resolution.timestamp,
+          ...(check.resolution.url ? { url: check.resolution.url } : {}),
+        },
+      });
+    }
+    return gateRecords;
+  };
 
   const entries = phaseDef.steps.filter((s): s is DriverStep | DriverPhase => !isGateStep(s));
 
   const runEntry = async (
     entry: DriverStep | DriverPhase,
-  ): Promise<{ records: DriverStepRecord[]; executed: ExecutedStep[]; failed: boolean }> => {
+  ): Promise<{ records: DriverStepRecord[]; executed: ExecutedStep[]; failed: boolean; pending?: PendingGateRecord }> => {
     if (isPhaseStep(entry)) {
       try {
-        const nested = await runPhase(entry, ctx, registry, phaseOutputs, componentOutputs, onProgress);
+        const nested = await runPhase(entry, ctx, registry, phaseOutputs, componentOutputs, gates, onProgress);
         return { ...nested, failed: false };
       } catch (err) {
         if (err instanceof StepFailure) return { records: err.records, executed: err.executed, failed: true };
+        // A nested fan-out phase's gate stops the whole component, but the
+        // records it produced before the gate still belong in the run.
+        if (err instanceof GateStop) {
+          return { records: err.records, executed: err.executed, failed: false, pending: err.pending };
+        }
         throw err;
       }
     }
@@ -448,32 +525,38 @@ async function runPhase(
     };
   };
 
+  const skippedRecord = (entry: DriverStep | DriverPhase): DriverStepRecord => ({
+    component: ctx.component,
+    phase: phaseDef.phase,
+    kind: isPhaseStep(entry) ? entry.phase : (entry as DriverStep).kind,
+    status: "skipped",
+    durationMs: 0,
+  });
+
   const runEntries = async (): Promise<{ records: DriverStepRecord[]; executed: ExecutedStep[] }> => {
+    const gateRecords = await decideGates();
     if (phaseDef.parallel) {
       const results = await Promise.all(entries.map(runEntry));
-      const records = results.flatMap((r) => r.records);
+      const records = gateRecords.concat(results.flatMap((r) => r.records));
       const executed = results.flatMap((r) => r.executed);
+      const pending = results.find((r) => r.pending)?.pending;
+      if (pending) throw new GateStop(records, executed, pending);
       if (results.some((r) => r.failed)) throw new StepFailure(records, executed);
       return { records, executed };
     }
 
-    const records: DriverStepRecord[] = [];
+    const records: DriverStepRecord[] = [...gateRecords];
     const executed: ExecutedStep[] = [];
     for (let i = 0; i < entries.length; i++) {
       const result = await runEntry(entries[i]);
       records.push(...result.records);
       executed.push(...result.executed);
+      if (result.pending) {
+        for (const skipped of entries.slice(i + 1)) records.push(skippedRecord(skipped));
+        throw new GateStop(records, executed, result.pending);
+      }
       if (result.failed) {
-        for (const skipped of entries.slice(i + 1)) {
-          const skippedKind = isPhaseStep(skipped) ? skipped.phase : (skipped as DriverStep).kind;
-          records.push({
-            component: ctx.component,
-            phase: phaseDef.phase,
-            kind: skippedKind,
-            status: "skipped",
-            durationMs: 0,
-          });
-        }
+        for (const skipped of entries.slice(i + 1)) records.push(skippedRecord(skipped));
         throw new StepFailure(records, executed);
       }
     }
@@ -486,7 +569,9 @@ async function runPhase(
     onProgress?.({ type: "phase-done", component: ctx.component, phase: phaseDef.phase, status: "ok" });
     return result;
   } catch (err) {
-    if (err instanceof StepFailure) {
+    if (err instanceof GateStop) {
+      onProgress?.({ type: "phase-done", component: ctx.component, phase: phaseDef.phase, status: "gated" });
+    } else if (err instanceof StepFailure) {
       onProgress?.({ type: "phase-done", component: ctx.component, phase: phaseDef.phase, status: "failed" });
     }
     throw err;
@@ -577,6 +662,7 @@ export async function runComponentDeploy(
   registry: CapabilityRegistry,
   componentOutputs: Record<string, Record<string, unknown>>,
   onProgress?: (event: RunProgressEvent) => void,
+  gates: GateContext = { port: gitGateLedgerPort() },
 ): Promise<DriverComponentResult> {
   const phaseOutputs: Record<string, Record<string, unknown>> = {};
   const records: DriverStepRecord[] = [];
@@ -584,11 +670,20 @@ export async function runComponentDeploy(
 
   try {
     for (const phaseDef of component.deploy) {
-      const result = await runPhase(phaseDef, ctx, registry, phaseOutputs, componentOutputs, onProgress);
+      const result = await runPhase(phaseDef, ctx, registry, phaseOutputs, componentOutputs, gates, onProgress);
       records.push(...result.records);
       allExecuted.push(...result.executed);
     }
   } catch (err) {
+    // A pending gate stops the component where it stands (#2119): no saga
+    // unwind and no `rollback` phase. The steps before the gate ran on
+    // purpose and are meant to survive the wait for an approval — undoing
+    // them would make every gated run a no-op with a rollback attached.
+    if (err instanceof GateStop) {
+      records.push(...err.records);
+      return { component: component.name, ok: false, status: "gated", records, gate: err.pending };
+    }
+
     if (err instanceof StepFailure) {
       records.push(...err.records);
       allExecuted.push(...err.executed);
@@ -600,24 +695,24 @@ export async function runComponentDeploy(
 
     for (const phaseDef of [...(component.rollback ?? [])].reverse()) {
       try {
-        const result = await runPhase(phaseDef, ctx, registry, phaseOutputs, componentOutputs, onProgress);
+        const result = await runPhase(phaseDef, ctx, registry, phaseOutputs, componentOutputs, gates, onProgress);
         records.push(...result.records);
       } catch (compErr) {
-        if (compErr instanceof StepFailure) records.push(...compErr.records);
+        if (compErr instanceof StepFailure || compErr instanceof GateStop) records.push(...compErr.records);
         else throw compErr;
       }
     }
 
-    return { component: component.name, ok: false, records };
+    return { component: component.name, ok: false, status: "fail", records };
   }
 
   // Publish-family and stack outputs become this component's entry in
-  // `componentOutputs` — through the same exported accumulator the durable
-  // path's `accumulateComponentOutputs` activity calls (#700), so local and
-  // Temporal runs can never diverge on what downstream references see.
+  // `componentOutputs` — through the same exported accumulator a hosted
+  // runtime calls (#700), so local and hosted runs can never diverge on what
+  // downstream references see.
   accumulateComponentOutputs(componentOutputs, component.name, phaseOutputs);
 
-  return { component: component.name, ok: true, records };
+  return { component: component.name, ok: true, status: "ok", records };
 }
 
 /**
@@ -641,9 +736,8 @@ export async function runComponentDeploy(
  * the driver free of per-capability branching. Returns `undefined` when the
  * component exposed nothing.
  *
- * Exported, like `resolveStepInput`, so the durable Temporal path
- * (lexicons/temporal/src/component-op/activities.ts) accumulates outputs via
- * this exact function rather than re-deriving it (#700). The resolver and the
+ * Exported, like `resolveStepInput`, so a hosting runtime accumulates outputs
+ * via this exact function rather than re-deriving it (#700). The resolver and the
  * accumulator are the two halves of one contract; sharing only the resolver
  * is how the cross-stack gap #699 closed locally could reopen durably.
  */
@@ -659,11 +753,11 @@ export function collectComponentOutputs(
 /**
  * Record a finished component's outputs (`collectComponentOutputs`) into the
  * shared `componentOutputs` map under the component's own name, merging over
- * any seeded entry (`--seed-outputs`, or a durable parent workflow's
- * thread-through). Mutates and returns `componentOutputs`, so a Temporal
- * activity can hand the updated map back to its workflow over the JSON
- * boundary — every value in it is plain activity-result data, so the map is
- * serializable by construction. A no-op when the component exposed nothing.
+ * any seeded entry (`--seed-outputs`, or a parent orchestrator's
+ * thread-through). Mutates and returns `componentOutputs`, so an out-of-process
+ * step can hand the updated map back over a JSON boundary — every value in it
+ * is plain result data, so the map is serializable by construction. A no-op
+ * when the component exposed nothing.
  */
 export function accumulateComponentOutputs(
   componentOutputs: Record<string, Record<string, unknown>>,
@@ -736,6 +830,10 @@ export interface InterpretRunOptions {
    * byte-for-byte the same as before this option existed.
    */
   onProgress?: (event: RunProgressEvent) => void;
+  /** Where a `gate` step's facts are read and written (#2119). Defaults to the `chant/lifecycle` orphan branch; a test passes `memoryGateLedgerPort()` from `../op/gate.ts`. */
+  gates?: GateLedgerPort;
+  /** ISO-8601 "now" for gate decisions, so a test is deterministic. */
+  now?: string;
 }
 
 /**
@@ -748,6 +846,11 @@ export interface InterpretRunOptions {
  * a result with `ok: false`; throws `DriverRunFailure` carrying that result
  * so callers can choose to inspect or propagate it.
  *
+ * A component that stops at an unapproved gate (#2119) ends the run the same
+ * way, with `status: "gated"` and the pending fact on `gate` — but it is
+ * *returned*, never thrown, because nothing failed. Downstream waves do not
+ * run: a gate is the author saying a human decides before the rest happens.
+ *
  * Zero per-component logic: this function and everything it calls dispatches
  * purely on the generic `Component`/`Phase`/`Step` shapes and the registry —
  * no branch anywhere names a specific component or capability.
@@ -761,11 +864,16 @@ export async function runInterpretDriver(
   const byName = new Map(components.map((c) => [c.name, c]));
   const componentOutputs: Record<string, Record<string, unknown>> = { ...(options.componentOutputs ?? {}) };
   const { onProgress } = options;
+  const gates: GateContext = {
+    port: options.gates ?? gitGateLedgerPort(),
+    ...(options.now ? { now: options.now } : {}),
+  };
 
   onProgress?.({ type: "run-start", waves });
 
   const results: DriverComponentResult[] = [];
   let failedComponent: string | undefined;
+  let gated: DriverComponentResult | undefined;
 
   waveLoop: for (const [waveIndex, wave] of waves.entries()) {
     const waveNum = waveIndex + 1;
@@ -780,23 +888,32 @@ export async function runInterpretDriver(
           registry,
           componentOutputs,
           onProgress,
+          gates,
         );
-        onProgress?.({ type: "component-done", wave: waveNum, component: component.name, status: result.ok ? "ok" : "failed" });
+        onProgress?.({ type: "component-done", wave: waveNum, component: component.name, status: progressStatus(result.status) });
         return result;
       }),
     );
     results.push(...waveResults);
-    const failed = waveResults.find((r) => !r.ok);
-    onProgress?.({ type: "wave-done", wave: waveNum, status: failed ? "failed" : "ok" });
-    if (failed) {
-      failedComponent = failed.component;
+    const stopped = waveResults.find((r) => r.status !== "ok");
+    onProgress?.({ type: "wave-done", wave: waveNum, status: progressStatus(stopped?.status ?? "ok") });
+    if (stopped) {
+      // A failure in the same wave outranks a gate: something is actually
+      // broken, and reporting the run as "waiting on a human" would hide it.
+      const failure = waveResults.find((r) => r.status === "fail");
+      if (failure) failedComponent = failure.component;
+      else gated = stopped;
       break waveLoop;
     }
   }
 
-  const ok = failedComponent === undefined;
-  onProgress?.({ type: "run-done", status: ok ? "ok" : "failed" });
-  const result: DriverRunResult = { order, waves, results, ok, failedComponent, componentOutputs };
-  if (!ok) throw new DriverRunFailure(result);
+  const status: DriverRunResult["status"] = failedComponent ? "fail" : gated ? "gated" : "ok";
+  const ok = status === "ok";
+  onProgress?.({ type: "run-done", status: progressStatus(status) });
+  const result: DriverRunResult = {
+    order, waves, results, ok, status, failedComponent, componentOutputs,
+    ...(gated ? { gatedComponent: gated.component, gate: gated.gate } : {}),
+  };
+  if (status === "fail") throw new DriverRunFailure(result);
   return result;
 }

package/src/components/index.ts

@@ -95,7 +95,7 @@ export {
   accumulateComponentOutputs,
   runComponentDeploy,
   runInterpretDriver,
-  DriverGateUnsupportedError,
+  type GateContext,
   DependencyCycleError,
   UnknownDependencyError,
   DriverRunFailure,
@@ -108,8 +108,3 @@ export {
   SingleHostComposeComponent,
   type SingleHostComposeComponentConfig,
 } from "./presets/index";
-export {
-  type ComponentTemporalCodegen,
-  type ComponentTemporalCodegenOptions,
-  loadComponentTemporalCodegen,
-} from "./temporal-codegen-loader";

package/src/components/manifest-persistence.test.ts

@@ -16,7 +16,6 @@ vi.mock("../lifecycle/git", () => ({
 const {
   maybePersistBuildManifest,
   extractRunManifest,
-  extractRunManifestFromPhaseOutputs,
 } = await import("./manifest-persistence");
 
 function makeManifest(component: string, digest: string): BuildArchiveManifest {
@@ -67,23 +66,6 @@ describe("extractRunManifest", () => {
   });
 });
 
-describe("extractRunManifestFromPhaseOutputs", () => {
-  test("finds the manifest across phase outputs (Temporal workflow result shape)", () => {
-    const manifest = makeManifest("svc", "sha256:abc");
-    expect(
-      extractRunManifestFromPhaseOutputs({
-        Build: { archivePath: "image.tar", digest: "sha256:abc", manifest },
-        Apply: { ok: true },
-      }),
-    ).toEqual(manifest);
-  });
-
-  test("returns undefined for undefined/empty phaseOutputs", () => {
-    expect(extractRunManifestFromPhaseOutputs(undefined)).toBeUndefined();
-    expect(extractRunManifestFromPhaseOutputs({})).toBeUndefined();
-  });
-});
-
 describe("maybePersistBuildManifest", () => {
   beforeEach(() => {
     persistBuildManifestMock.mockReset();
@@ -102,8 +84,8 @@ describe("maybePersistBuildManifest", () => {
     expect(pushLifecycleMock).toHaveBeenCalledTimes(1);
   });
 
-  test("a pre-resolved manifest (Temporal path) takes precedence over records", async () => {
-    const preResolved = makeManifest("svc", "sha256:temporal");
+  test("a pre-resolved manifest takes precedence over records", async () => {
+    const preResolved = makeManifest("svc", "sha256:preresolved");
     persistBuildManifestMock.mockResolvedValue({ commit: "b".repeat(40) });
 
     const outcome = await maybePersistBuildManifest({

package/src/components/manifest-persistence.ts

@@ -13,10 +13,9 @@
  * doc: a manifest write is a git commit + push, a non-idempotent side effect
  * with real-world I/O — exactly what `driver.ts` resists taking on (it is
  * exercised in tests against a bare `CapabilityRegistry` with no lifecycle
- * dependency at all) and what Temporal workflow code must never do directly
- * (replay-safety). The CLI calls this after `runComponents`/`handle.result()`
- * reports success, the same place `maybeRecordAutoRelease` is already
- * called from (../cli/handlers/run.ts).
+ * dependency at all). The CLI calls this after `runComponents` reports
+ * success, the same place `maybeRecordAutoRelease` is already called from
+ * (../cli/handlers/run.ts).
  *
  * **Extraction is duck-typed, not capability-specific.** `docker-build`,
  * `generate-sbom`, `extract-config-bom`, and `addArchiveTemplate` (the
@@ -68,25 +67,6 @@ export function extractRunManifest(records: DriverStepRecord[]): BuildArchiveMan
   return found;
 }
 
-/**
- * Same manifest extraction as `extractRunManifest`, but over a component
- * Temporal workflow's returned `phaseOutputs` (`{ [phase]: output }`) —
- * mirroring ./auto-release.ts's `extractRunDigestFromPhaseOutputs`, the
- * `--temporal` CLI path's counterpart, since that path never sees individual
- * step records either.
- */
-export function extractRunManifestFromPhaseOutputs(
-  phaseOutputs: Record<string, Record<string, unknown>> | undefined,
-): BuildArchiveManifest | undefined {
-  let found: BuildArchiveManifest | undefined;
-  for (const output of Object.values(phaseOutputs ?? {})) {
-    if (isManifestShaped(output)) {
-      found = output.manifest;
-    }
-  }
-  return found;
-}
-
 /** Explicit reasons `maybePersistBuildManifest` declined to write — never a thrown error, mirroring ./auto-release.ts's `AutoReleaseSkipReason`. */
 export type ManifestPersistSkipReason = "opted-out" | "run-not-successful" | "no-manifest";
 
@@ -101,7 +81,7 @@ export interface ManifestPersistRunInfo {
   success: boolean;
   /** The component's step records (local executor), used to locate the accumulated manifest via `extractRunManifest`. Mutually exclusive with `manifest`. */
   records?: DriverStepRecord[];
-  /** A manifest already resolved by the caller (e.g. a future durable/Temporal path that has its own phaseOutputs-shaped extraction). Takes precedence over `records` when both are given. */
+  /** A manifest the caller already resolved by its own means. Takes precedence over `records` when both are given. */
   manifest?: BuildArchiveManifest;
 }
 

package/src/components/pilots/neo4j-fanout.pilot.ts

@@ -31,7 +31,7 @@ interface Neo4jInstanceConfig {
    */
   health: { size: number } | { quorum: true };
   /** Optional human gate placed before this instance's steps (rolling instances only, never the seed). */
-  approval?: { signalName: string; description: string; timeout: string };
+  approval?: { gate: string; description: string; timeout: string };
 }
 
 const SEED: Neo4jInstanceConfig = {
@@ -55,7 +55,7 @@ const FOLLOWERS: Neo4jInstanceConfig[] = [
     template: "archive:neo4j-1.template.json",
     health: { quorum: true },
     approval: {
-      signalName: "approve-neo4j-node-1",
+      gate: "approve-neo4j-node-1",
       description: "Confirm the seed node is healthy before rolling to node 1",
       timeout: "24h",
     },
@@ -71,7 +71,7 @@ const FOLLOWERS: Neo4jInstanceConfig[] = [
 /** Build one instance's mini-composition phase — the unit that repeats N times for an N-node cluster. */
 function instancePhase(instance: Neo4jInstanceConfig): Phase {
   const steps = [
-    ...(instance.approval ? [gate(instance.approval.signalName, instance.approval)] : []),
+    ...(instance.approval ? [gate(instance.approval.gate, instance.approval)] : []),
     { kind: "cfn-deploy", template: instance.template },
     { kind: "code-deploy", instance: instance.index, revision: "@Seed.templateUri" },
     { kind: "wait-cluster-healthy", ...instance.health },