@intentius/chant 0.124.10 → 0.124.12

package/src/op/op-waves-point.test.ts

@@ -13,7 +13,7 @@ import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { assertOpWavesSpec, type OpWavesSpec } from "./op-waves";
-import { runOpWave, type OpWaveDecision, type OpWaveExec, type OpWaveShowAtBase } from "./op-waves-run";
+import { runOpWave, type OpWaveDecision, type OpWaveExec, type OpWaveRunsFile, type OpWaveShowAtBase } from "./op-waves-run";
 import { memoryGateLedgerPort } from "./gate";
 import { waveSetDigest } from "../gated-waves";
 import { pointGateResumable, type GatePointAsker, type GatePointQuestion, type GatePointRequest } from "../point-decision";
@@ -218,6 +218,62 @@ describe("a wave gate that asks a decision point (#3836)", () => {
     h.done();
   });
 
+  test("the plans file's pending fields and the spec's neverOverMcp land on the point gate's pending fact (#3863)", async () => {
+    const tg: OpWavesSpec = {
+      name: "tf-apply",
+      op: "tf-apply",
+      gateName: "wave-{k}",
+      planWave: ["tg", "plan", "{wave}", "{runs}", "{plans}"],
+      applyWave: ["tg", "apply", "{wave}", "{runs}", "{plans}"],
+      point: { name: "prod-apply" },
+      waves: [{ name: "net", runs: [{ target: "vpc" }, { target: "nat" }] }],
+    };
+    const members = [{ member: "vpc", planDigest: digest("1") }, { member: "nat", planDigest: digest("2") }];
+    const cwd = mkdtempSync(join(tmpdir(), "op-waves-point-3863-"));
+    const exec: OpWaveExec = (argv, dir) => {
+      const runs = JSON.parse(readFileSync(join(dir, argv[3]!), "utf-8")) as OpWaveRunsFile;
+      if (argv[1] === "plan") {
+        writeFileSync(join(dir, argv[4]!), JSON.stringify({
+          runs: runs.runs.map((r) => ({ target: r.target, planDigest: members.find((m) => m.member === r.target)!.planDigest })),
+          pending: { commit: "c".repeat(40), members, description: "wave 1 of 1: vpc, nat" },
+        }));
+      }
+      return 0;
+    };
+    // neverOverMcp at base counts even when the change drops it.
+    const show: OpWaveShowAtBase = () => ({ sha: "b".repeat(40), text: JSON.stringify({ ...tg, neverOverMcp: true }) });
+    const gates = memoryGateLedgerPort();
+    const asker = stubAsker();
+    const waiting = await runOpWave({ spec: tg, specFile: "waves.json", wave: 1, cwd, exec, show, gates, points: asker, now: NOW, log: () => {} });
+    expect(waiting.exitCode).toBe(3);
+    expect(gates.appended).toHaveLength(1);
+    expect(gates.appended[0]).toMatchObject({
+      op: "tf-apply",
+      gate: "wave-1",
+      commit: "c".repeat(40),
+      members,
+      description: "wave 1 of 1: vpc, nat",
+      neverOverMcp: true,
+      answer: { point: "prod-apply" },
+    });
+    expect(waiting.decision?.pendingFact).toMatchObject({ commit: "c".repeat(40), neverOverMcp: true });
+
+    // A standing fact for the same question that does not carry neverOverMcp does not stand: the run records one that does.
+    const old = { ...gates.appended[0]! };
+    delete (old as { neverOverMcp?: true }).neverOverMcp;
+    const stale = memoryGateLedgerPort({ pending: [old] });
+    await runOpWave({ spec: tg, specFile: "waves.json", wave: 1, cwd, exec, show, gates: stale, points: asker, now: NOW, log: () => {} });
+    expect(stale.appended).toHaveLength(1);
+    expect(stale.appended[0]).toMatchObject({ neverOverMcp: true });
+
+    // Without neverOverMcp at base, the fact carries the fields and no neverOverMcp.
+    const plain = memoryGateLedgerPort();
+    await runOpWave({ spec: tg, specFile: "waves.json", wave: 1, cwd, exec, show: () => ({ sha: "b".repeat(40), text: JSON.stringify(tg) }), gates: plain, points: asker, now: NOW, log: () => {} });
+    expect(plain.appended[0]).toMatchObject({ commit: "c".repeat(40), members });
+    expect(plain.appended[0]).not.toHaveProperty("neverOverMcp");
+    rmSync(cwd, { recursive: true, force: true });
+  });
+
   test("resume picks up the waiting wave once its question is answered (#3835)", async () => {
     vi.stubEnv("GITLAB_CI", "");
     vi.stubEnv("GITHUB_ACTIONS", "true");
@@ -245,7 +301,9 @@ describe("a wave gate that asks a decision point (#3836)", () => {
     expect(await resumeStanding(fact, [], { questions: new Map([[id, yes]]), dryRun: true })).toMatchObject({
       op: "tf-apply",
       gate: "tf-apply-wave-1",
-      status: "skipped",
+      status: "would-resume",
+      resumable: true,
+      reason: "answered",
       approvedBy: "alice",
       message: expect.stringContaining("would resume github run 4242"),
     });

package/src/op/op-waves-run.ts

@@ -1696,6 +1696,9 @@ async function settlePointGate(options: RunOpWaveOptions, ctx: WaveContext, deci
     ...(point.timeout ? { timeout: point.timeout } : {}),
     planDigest: digest,
     ...(options.now ? { now: options.now } : {}),
+    // #3863: the plans file's pending fields and the spec's neverOverMcp, as settleGate passes them.
+    ...(decision.pending ? { fields: decision.pending } : {}),
+    ...(decision.neverOverMcp ? { neverOverMcp: true } : {}),
   });
   if (check.satisfied) {
     decision.status = "approved";
@@ -2085,17 +2088,10 @@ async function approveByReview(
 }
 
 async function readHeadPlans(name: string, head: string, cwd: string): Promise<HeadPlans | null> {
-  const { readBlobFromPath, requireLifecycleLedger } = await import("../lifecycle/git");
-  const { headPlansPath } = await import("./gate-review");
+  const { gitLedgerReadPort, requireLifecycleLedger } = await import("../lifecycle/git");
+  const { readHeadPlans: read } = await import("../lifecycle/wave-plans");
   await requireLifecycleLedger({ cwd });
-  const { dir, file } = headPlansPath(name, head);
-  const text = await readBlobFromPath(dir, file, { cwd });
-  if (!text) return null;
-  try {
-    return JSON.parse(text) as HeadPlans;
-  } catch {
-    return null;
-  }
+  return read(gitLedgerReadPort({ cwd }), name, head);
 }
 
 export interface RecordHeadPlansOptions {

package/src/point-decision.ts

@@ -31,7 +31,7 @@ import { execFile } from "node:child_process";
 import { isPendingGateExpired, latestPendingGate } from "./lifecycle/gate-ledger-select";
 import { DEFAULT_GATE_EXPIRY, resolveApprovalUrl } from "./lifecycle/gate-pending";
 import { samePlanDigest } from "./lifecycle/plan-digest";
-import type { GateAnswerRef, GateResolutionRecord, PendingGateRecord } from "./lifecycle/gate-ledger";
+import type { GateAnswerRef, GateResolutionRecord, PendingGateInput, PendingGateRecord } from "./lifecycle/gate-ledger";
 import { parseDuration } from "./op/duration";
 import type { GateLedgerPort } from "./op/gate";
 import { DEFAULT_GATE_POINT_PASS, defaultGatePointStore, gatePointInputs, gateSubject, type GatePoint, type GatePointFacts, type GatePointStore } from "./op/gate-point";
@@ -121,6 +121,17 @@ export interface PointGateInput {
    * ({@link resolveGateRunLocator}); false records none.
    */
   resume?: GateRunLocator | false;
+  /**
+   * Fields a caller adds to the pending fact it records (#3863), such as an
+   * Op waves product's commit and members, as `evaluateGate` takes them.
+   * Every field this function writes itself wins over one of the same name.
+   */
+  fields?: Record<string, unknown>;
+  /**
+   * The pending fact it records carries `neverOverMcp` (#3863): an answer to
+   * the question over MCP or ACP is refused (`answer-never-over-mcp`, #3817).
+   */
+  neverOverMcp?: boolean;
 }
 
 /** What reaching a gate that asks a point decided. */
@@ -198,12 +209,17 @@ export async function evaluatePointGate(port: PointGateLedgerPort, asker: GatePo
   const waiting: WaitingPoint = { id: q.id, point: q.point, state: q.state === "proposed" ? "proposed" : "escalated", path: q.path, subject: q.subject, steward: q.steward };
   const ledger = await port.read(input.op);
   const standing = latestPendingGate(ledger.pending.filter((p) => p.environment === undefined), input.gate);
-  if (standing && !isPendingGateExpired(standing, now) && samePlanDigest(standing.planDigest, input.planDigest) && standing.answer?.id === q.id) {
+  // #3863: a standing fact that does not carry the gate's neverOverMcp does not stand, so the answer path reads the rule.
+  if (
+    standing && !isPendingGateExpired(standing, now) && samePlanDigest(standing.planDigest, input.planDigest) && standing.answer?.id === q.id &&
+    (!input.neverOverMcp || standing.neverOverMcp === true)
+  ) {
     return { satisfied: false, waiting, pending: standing, recorded: false };
   }
   const url = resolveApprovalUrl();
   const resume = input.resume === false ? undefined : (input.resume ?? resolveGateRunLocator());
   const { record, pushed, pushWarning } = await port.appendPending({
+    ...(input.fields as Partial<PendingGateInput> | undefined),
     op: input.op,
     gate: input.gate,
     timestamp: now,
@@ -214,6 +230,7 @@ export async function evaluatePointGate(port: PointGateLedgerPort, asker: GatePo
     ...(input.planDigest !== undefined ? { planDigest: input.planDigest } : {}),
     ...(resume ? { resume } : {}),
     answer: { ...ref, ...(input.point.pass ? { pass: input.point.pass } : {}) },
+    ...(input.neverOverMcp ? { neverOverMcp: true as const } : {}),
   });
   return { satisfied: false, waiting, pending: record, recorded: true, pushed, ...(pushWarning ? { pushWarning } : {}) };
 }