@intentius/chant 0.57.0 → 0.59.0

package/src/components/driver-output.ts

@@ -51,15 +51,27 @@ export function renderDriverHuman(result: DriverRunResult, write: Writer = stder
       } else {
         write(`    ${mark} ${record.kind}   ${formatDuration(record.durationMs)}`);
       }
+      if (record.approval) {
+        write(`      [approved] ${record.approval.resolvedBy} at ${record.approval.timestamp}` +
+          (record.approval.url ? ` (${record.approval.url})` : ""));
+      }
       if (record.error) {
         write(`      ${record.error}`);
       }
     }
-    write(componentResult.ok ? `  component "${componentResult.component}" completed` : `  component "${componentResult.component}" failed`);
+    write(
+      componentResult.status === "ok"
+        ? `  component "${componentResult.component}" completed`
+        : componentResult.status === "gated"
+          ? `  component "${componentResult.component}" gated on "${componentResult.gate?.gate ?? "?"}"`
+          : `  component "${componentResult.component}" failed`,
+    );
   }
 
-  if (result.ok) {
+  if (result.status === "ok") {
     write(`interpret run completed (${result.order.length} component(s))`);
+  } else if (result.status === "gated") {
+    write(`interpret run is gated at component "${result.gatedComponent}"`);
   } else {
     write(`interpret run failed at component "${result.failedComponent}"`);
   }

package/src/components/driver.test.ts

@@ -5,17 +5,17 @@
  * implementations are a separate later issue (#557). These tests exercise the
  * driver's generic behavior only: dependency ordering + parallel-safe waves,
  * sequential vs parallel step execution, `onFailure`/saga rollback in reverse
- * order, output wiring (`@Phase.field` and `@<component>.publish.*`), and that
- * a `gate` errors on the local executor. Several cases replay the real pilot
+ * order, output wiring (`@Phase.field` and `@<component>.publish.*`), and
+ * gate-as-fact on the local executor (#2119). Several cases replay the real pilot
  * declarations (../pilots/*.pilot.ts) as realistic inputs.
  */
 
 import { describe, expect, it } from "vitest";
 import { CapabilityRegistry, type DeployContext } from "./capability";
 import { stubCapability } from "./verbs/stub";
+import { memoryGateLedgerPort } from "../op/gate";
 import {
   DependencyCycleError,
-  DriverGateUnsupportedError,
   DriverRunFailure,
   UnknownDependencyError,
   accumulateComponentOutputs,
@@ -210,32 +210,121 @@ describe("runComponentDeploy — sequential vs parallel", () => {
   });
 });
 
-describe("runComponentDeploy — gate on the local executor", () => {
-  it("throws DriverGateUnsupportedError when a phase contains a gate", async () => {
+describe("runComponentDeploy — gate as fact (#2119)", () => {
+  const NOW = "2026-09-05T12:00:00.000Z";
+
+  const gatedComponent = (): DriverComponent => ({
+    name: "neo4j-cluster",
+    deploy: [
+      { phase: "Prepare", steps: [{ kind: "cfn-deploy" }] },
+      { phase: "Node 1", steps: [{ kind: "gate", gate: "approve-node-1" }, { kind: "code-deploy" }] },
+    ],
+    rollback: [{ phase: "Undo", steps: [{ kind: "cfn-deploy" }] }],
+  });
+
+  function registryWithCalls() {
     const registry = new CapabilityRegistry();
-    const component: DriverComponent = {
+    const calls: string[] = [];
+    const rolledBack: string[] = [];
+    for (const kind of ["cfn-deploy", "code-deploy"]) {
+      registry.register(
+        fakeCapability(kind, {
+          run: () => { calls.push(kind); return { ok: true }; },
+          rollback: () => { rolledBack.push(kind); },
+        }).capability,
+      );
+    }
+    return { registry, calls, rolledBack };
+  }
+
+  it("ends gated, records the pending fact, and runs nothing after the gate", async () => {
+    const { registry, calls, rolledBack } = registryWithCalls();
+    const port = memoryGateLedgerPort();
+    const result = await runComponentDeploy(
+      gatedComponent(), { env: "dev", component: "neo4j-cluster" }, registry, {}, undefined,
+      { port, now: NOW },
+    );
+
+    expect(result.status).toBe("gated");
+    expect(result.ok).toBe(false);
+    expect(result.gate).toMatchObject({ op: "neo4j-cluster", gate: "approve-node-1" });
+    expect(port.appended).toHaveLength(1);
+    expect(calls).toEqual(["cfn-deploy"]);
+    // A gate is not a failure: nothing unwinds and no `rollback` phase runs.
+    expect(rolledBack).toEqual([]);
+    expect(result.records.map((r) => [r.kind, r.status])).toEqual([
+      ["cfn-deploy", "ok"],
+      ["gate:approve-node-1", "skipped"],
+      ["code-deploy", "skipped"],
+    ]);
+  });
+
+  // #2202: `signalName` was the key that named a component gate through 0.58.0
+  // and is still read, so a component on the old key gates identically.
+  it("still reads a gate step's deprecated `signalName` key", async () => {
+    const { registry } = registryWithCalls();
+    const legacy: DriverComponent = {
       name: "neo4j-cluster",
-      deploy: [
-        {
-          phase: "Node 1",
-          steps: [{ kind: "gate", signalName: "approve-node-1" }, { kind: "cfn-deploy" }],
-        },
-      ],
+      deploy: [{ phase: "Node 1", steps: [{ kind: "gate", signalName: "approve-node-1" }, { kind: "code-deploy" }] }],
     };
-    await expect(
-      runComponentDeploy(component, { env: "dev", component: "neo4j-cluster" }, registry, {}),
-    ).rejects.toThrow(DriverGateUnsupportedError);
+    const port = memoryGateLedgerPort();
+    const result = await runComponentDeploy(
+      legacy, { env: "dev", component: "neo4j-cluster" }, registry, {}, undefined,
+      { port, now: NOW },
+    );
+
+    expect(result.status).toBe("gated");
+    expect(result.gate).toMatchObject({ op: "neo4j-cluster", gate: "approve-node-1" });
+    expect(result.records.map((r) => r.kind)).toEqual(["gate:approve-node-1", "code-deploy"]);
+  });
+
+  it("a resolution newer than the pending fact passes the gate and carries the approver", async () => {
+    const { registry, calls } = registryWithCalls();
+    const port = memoryGateLedgerPort({
+      pending: [{
+        version: 1, kind: "pending", op: "neo4j-cluster", gate: "approve-node-1",
+        timestamp: "2026-09-05T10:00:00.000Z", expiresAt: "2026-09-07T10:00:00.000Z",
+      }],
+      resolutions: [{
+        version: 1, op: "neo4j-cluster", gate: "approve-node-1",
+        resolvedBy: "alex", timestamp: "2026-09-05T11:00:00.000Z",
+      }],
+    });
+    const result = await runComponentDeploy(
+      gatedComponent(), { env: "dev", component: "neo4j-cluster" }, registry, {}, undefined,
+      { port, now: NOW },
+    );
+
+    expect(result.status).toBe("ok");
+    expect(calls).toEqual(["cfn-deploy", "code-deploy"]);
+    expect(result.records.find((r) => r.kind === "gate:approve-node-1")?.approval)
+      .toEqual({ gate: "approve-node-1", resolvedBy: "alex", timestamp: "2026-09-05T11:00:00.000Z" });
   });
 
-  it("the neo4j pilot's gated Node 1 phase errors locally (matches chant's local-executor behavior)", async () => {
+  it("the neo4j pilot's gated Node 1 phase ends the run pending approval", async () => {
     const registry = new CapabilityRegistry();
     for (const kind of ["cfn-deploy", "code-deploy", "wait-cluster-healthy"]) {
       registry.register(fakeCapability(kind, { run: () => ({ ok: true }) }).capability);
     }
     const json = projectToJson(neo4jCluster) as unknown as DriverComponent;
-    await expect(runComponentDeploy(json, { env: "dev", component: "neo4j-cluster" }, registry, {})).rejects.toThrow(
-      /gate "approve-neo4j-node-1" is not supported/,
+    const result = await runComponentDeploy(
+      json, { env: "dev", component: "neo4j-cluster" }, registry, {}, undefined,
+      { port: memoryGateLedgerPort(), now: NOW },
     );
+    expect(result.status).toBe("gated");
+    expect(result.gate?.gate).toBe("approve-neo4j-node-1");
+  });
+
+  it("a gated component stops the whole interpret run without throwing", async () => {
+    const { registry } = registryWithCalls();
+    const run = await runInterpretDriver([gatedComponent()], registry, {
+      env: "dev",
+      gates: memoryGateLedgerPort(),
+      now: NOW,
+    });
+    expect(run.status).toBe("gated");
+    expect(run.gatedComponent).toBe("neo4j-cluster");
+    expect(run.gate?.gate).toBe("approve-node-1");
   });
 });
 
@@ -415,7 +504,7 @@ describe("runComponentDeploy — output wiring", () => {
 
 describe("collectComponentOutputs / accumulateComponentOutputs — the shared accumulator (#700)", () => {
   // Exported so the durable path's `accumulateComponentOutputs` activity
-  // (lexicons/temporal/src/component-op/activities.ts) captures outputs via
+  // (a hosting runtime's own step executor) captures outputs via
   // the same function `runComponentDeploy` does — the accumulation twin of
   // the already-shared `resolveStepInput`.
   const phaseOutputs = {
@@ -446,7 +535,7 @@ describe("collectComponentOutputs / accumulateComponentOutputs — the shared ac
       publish: { uri: "repo@sha256:abc", digest: "sha256:abc" },
     });
     expect(out.other).toEqual({ x: 1 });
-    // Plain data throughout — survives the Temporal activity JSON boundary unchanged.
+    // Plain data throughout — survives an out-of-process JSON boundary unchanged.
     expect(JSON.parse(JSON.stringify(out))).toEqual(out);
   });