@intentius/chant 0.124.23 → 0.124.25

package/src/op/step-output-ref.test.ts

@@ -10,7 +10,7 @@ import { z } from "zod";
 import { activity, phase, effect } from "./builders";
 import type { OpConfig } from "./types";
 import { activityContract, type ActivityContract } from "./activity-contract";
-import { stepOutput, isStepOutputRef, collectStepOutputRefs, validateStepOutputRefs } from "./step-output-ref";
+import { stepOutput, isStepOutputRef, collectStepOutputRefs, validateStepOutputRefs, validateStepOutputRefScope } from "./step-output-ref";
 import { EffectReceipt } from "../effect-receipt";
 
 const lifecycleDiffContract = activityContract(
@@ -248,39 +248,83 @@ describe("validateStepOutputRefs() — structural coverage", () => {
     expect(issues.some((i) => i.message.includes("declares no return schema"))).toBe(true);
   });
 
-  it("flags a reference authored inside onFailure", () => {
+  it("reports every issue across multiple refs, not just the first", () => {
+    const apply1 = activity("applyStacks", { stacks: stepOutput("nope1", "x") });
+    const apply2 = activity("applyStacks", { stacks: stepOutput("nope2", "x") });
+    const config = opWith({ phases: [phase("P", [apply1, apply2])] });
+    const issues = validateStepOutputRefs(config, new Map([["applyStacks", applyStacksContract]]));
+    expect(issues.some((i) => i.message.includes("nope1"))).toBe(true);
+    expect(issues.some((i) => i.message.includes("nope2"))).toBe(true);
+  });
+});
+
+// ── onFailure and effect steps (#3948) ───────────────────────────────────────
+
+describe("validateStepOutputRefs() — onFailure and effect steps (#3948)", () => {
+  const seeded = EffectReceipt("seeded", { effect: "db-seed", flavor: "hash", inputs: { file: "seed.sql", version: 3 } });
+  const contracts = new Map<string, ActivityContract>([
+    ["lifecycleDiff", lifecycleDiffContract],
+    ["applyStacks", applyStacksContract],
+  ]);
+
+  it("an onFailure step may reference any main-phase step", () => {
     const diff = activity("lifecycleDiff", { env: "prod" }, { id: "diff" });
+    const apply = activity("applyStacks", { stacks: ["a"] });
     const rollback = activity("applyStacks", { stacks: stepOutput("diff", "driftedStacks") });
+    const config = opWith({ phases: [phase("Diff", [diff]), phase("Apply", [apply])], onFailure: [phase("Rollback", [rollback])] });
+    expect(validateStepOutputRefs(config, contracts)).toEqual([]);
+  });
+
+  it("an onFailure step's reference is still checked against the producer's contract", () => {
+    const diff = activity("lifecycleDiff", { env: "prod" }, { id: "diff" });
+    const rollback = activity("applyStacks", { stacks: stepOutput("diff", "nope") });
     const config = opWith({ phases: [phase("P", [diff])], onFailure: [phase("Rollback", [rollback])] });
-    const contracts = new Map<string, ActivityContract>([
-      ["lifecycleDiff", lifecycleDiffContract],
-      ["applyStacks", applyStacksContract],
-    ]);
     const issues = validateStepOutputRefs(config, contracts);
-    expect(issues.some((i) => i.message.includes("onFailure compensation"))).toBe(true);
+    expect(issues).toHaveLength(1);
+    expect(issues[0].phase).toBe("Rollback");
+    expect(issues[0].message).toMatch(/path "nope", which does not exist/);
+  });
+
+  it("an onFailure step cannot reference another onFailure step", () => {
+    const diff = activity("lifecycleDiff", { env: "prod" }, { id: "undoDiff" });
+    const rollback = activity("applyStacks", { stacks: stepOutput("undoDiff", "driftedStacks") });
+    const config = opWith({ phases: [phase("P", [activity("applyStacks", { stacks: [] })])], onFailure: [phase("Rollback", [diff, rollback])] });
+    expect(validateStepOutputRefScope(config)[0].message).toMatch(/unknown step id "undoDiff"/);
   });
 
-  it("flags a reference authored inside an effect step's nested steps", () => {
-    const receipt = EffectReceipt("seeded", { effect: "db-seed", flavor: "hash", inputs: { file: "seed.sql", version: 3 } });
+  it("a step inside an effect may reference a step that runs before the effect", () => {
     const diff = activity("lifecycleDiff", { env: "prod" }, { id: "diff" });
     const nested = activity("applyStacks", { stacks: stepOutput("diff", "driftedStacks") });
-    const effectStep = effect(receipt, [nested]);
-    const config = opWith({ phases: [phase("P", [diff, effectStep])] });
-    const contracts = new Map<string, ActivityContract>([
-      ["lifecycleDiff", lifecycleDiffContract],
-      ["applyStacks", applyStacksContract],
-    ]);
-    const issues = validateStepOutputRefs(config, contracts);
-    expect(issues.some((i) => i.message.includes("nested inside an effect step"))).toBe(true);
+    const config = opWith({ phases: [phase("P", [diff, effect(seeded, [nested])])] });
+    expect(validateStepOutputRefs(config, contracts)).toEqual([]);
   });
 
-  it("reports every issue across multiple refs, not just the first", () => {
-    const apply1 = activity("applyStacks", { stacks: stepOutput("nope1", "x") });
-    const apply2 = activity("applyStacks", { stacks: stepOutput("nope2", "x") });
-    const config = opWith({ phases: [phase("P", [apply1, apply2])] });
-    const issues = validateStepOutputRefs(config, new Map([["applyStacks", applyStacksContract]]));
-    expect(issues.some((i) => i.message.includes("nope1"))).toBe(true);
-    expect(issues.some((i) => i.message.includes("nope2"))).toBe(true);
+  it("a step inside an effect in onFailure may reference a main-phase step", () => {
+    const diff = activity("lifecycleDiff", { env: "prod" }, { id: "diff" });
+    const nested = activity("applyStacks", { stacks: stepOutput("diff", "driftedStacks") });
+    const config = opWith({ phases: [phase("P", [diff])], onFailure: [phase("Undo", [effect(seeded, [nested])])] });
+    expect(validateStepOutputRefs(config, contracts)).toEqual([]);
+  });
+
+  it("a step inside an effect cannot reference a step after the effect", () => {
+    const nested = activity("applyStacks", { stacks: stepOutput("diff", "driftedStacks") });
+    const diff = activity("lifecycleDiff", { env: "prod" }, { id: "diff" });
+    const config = opWith({ phases: [phase("P", [effect(seeded, [nested]), diff])] });
+    expect(validateStepOutputRefScope(config)[0].message).toMatch(/step "diff" does not run before this step/);
+  });
+
+  it("nothing can reference a step nested inside an effect (decision A7)", () => {
+    const inner = activity("lifecycleDiff", { env: "prod" }, { id: "inner" });
+    const sibling = activity("applyStacks", { stacks: stepOutput("inner", "driftedStacks") });
+    const later = activity("applyStacks", { stacks: stepOutput("inner", "driftedStacks") });
+    const rollback = activity("applyStacks", { stacks: stepOutput("inner", "driftedStacks") });
+    const config = opWith({
+      phases: [phase("P", [effect(seeded, [inner, sibling]), later])],
+      onFailure: [phase("Rollback", [rollback])],
+    });
+    const issues = validateStepOutputRefScope(config);
+    expect(issues).toHaveLength(3);
+    for (const issue of issues) expect(issue.message).toMatch(/"inner", which is nested inside an effect step/);
   });
 });
 

package/src/op/step-output-ref.ts

@@ -23,15 +23,20 @@
  * Scope, kept deliberately tight (see the issue's "Open questions"):
  *  - same-Op only — no cross-Op plumbing (that needs a durable place to put
  *    the value, which #1290 explicitly defers).
- *  - main `phases` only — a step inside `onFailure` or nested inside an
- *    `EffectStep` can neither produce nor consume a step-output reference.
- *    `onFailure` compensation runs only when something upstream already
- *    failed, so a main-phase step's captured result isn't reliably
- *    available there; an effect step's nested steps run only when the
- *    receipt comparison mismatches, so a value it produces isn't reliably
- *    available to anything outside it either. Both are conditional
- *    execution paths, which is exactly the class of thing #1290 keeps out
- *    of an Op's inert-data model.
+ *  - producers are the top-level activity steps of the main `phases`. A step
+ *    in `onFailure` or nested inside an `EffectStep` produces nothing another
+ *    step may reference: an effect's nested steps run only when the receipt
+ *    comparison mismatches, so a value one of them returns isn't reliably
+ *    there for anything else (#3948 decision A7, "for now").
+ *  - consumers are those producers, plus (#3948) every activity step in
+ *    `onFailure` and every activity step nested inside an effect. An
+ *    `onFailure` step may reference any main-phase producer. Compensation
+ *    runs after a failure, so its producer may never have completed; the
+ *    executor then skips the compensation step and records why (decision
+ *    A6), rather than calling it with an `undefined` in place of the value.
+ *    A step nested inside an effect may reference a producer that runs
+ *    before the effect, and the executor folds the resolved values into the
+ *    effect's expectation, so a changed value re-fires the effect.
  *  - producer must run to completion before the consumer starts: an earlier
  *    phase, or an earlier step within the same non-parallel phase. Two
  *    steps in the same parallel phase run concurrently (`Promise.all`) with
@@ -243,26 +248,63 @@ function locateStepOutputRefPath(value: unknown, target: StepOutputRef, path: st
 // ── Validation ──────────────────────────────────────────────────────────────
 
 interface StepLocation {
+  /** Index into `phases`; every `onFailure` phase sits after all of them. */
   phaseIndex: number;
+  /** Index into the phase's `steps`. A step nested in an effect takes the effect's. */
   stepIndex: number;
   parallel: boolean;
   step: ActivityStep;
+  phaseName: string;
 }
 
-/** Top-level `ActivityStep`s of `phases`, in authored (phase, then step) order — gates, effects, and steps nested inside an effect are not producers or consumers (see the module doc's scope note). */
+/** Top-level `ActivityStep`s of `phases`, in authored (phase, then step) order: the producers (see the module doc's scope note). */
 function locateActivitySteps(phases: PhaseDefinition[]): StepLocation[] {
   const locations: StepLocation[] = [];
   phases.forEach((phase, phaseIndex) => {
-    let stepIndex = 0;
-    for (const step of phase.steps) {
-      if (step.kind !== "activity") continue;
-      locations.push({ phaseIndex, stepIndex, parallel: phase.parallel === true, step });
-      stepIndex++;
-    }
+    phase.steps.forEach((step, stepIndex) => {
+      if (step.kind !== "activity") return;
+      locations.push({ phaseIndex, stepIndex, parallel: phase.parallel === true, step, phaseName: phase.name });
+    });
   });
   return locations;
 }
 
+/**
+ * Every activity step that may hold a reference (#3948): the producers, each
+ * step nested inside an effect of a main phase, and every activity step of
+ * `onFailure`, effect-nested ones included. An `onFailure` step is placed after
+ * every main phase, so any main-phase producer precedes it.
+ */
+function locateConsumers(config: Pick<OpConfig, "phases" | "onFailure">): StepLocation[] {
+  const consumers: StepLocation[] = [];
+  const visit = (phases: PhaseDefinition[], offset: number) => {
+    phases.forEach((phase, i) => {
+      const at = { phaseIndex: offset + i, parallel: phase.parallel === true, phaseName: phase.name };
+      phase.steps.forEach((step, stepIndex) => {
+        if (step.kind === "activity") consumers.push({ ...at, stepIndex, step });
+        if (step.kind === "effect") {
+          for (const nested of step.steps) if (nested.kind === "activity") consumers.push({ ...at, stepIndex, step: nested });
+        }
+      });
+    });
+  };
+  visit(config.phases, 0);
+  visit(config.onFailure ?? [], config.phases.length);
+  return consumers;
+}
+
+/** Ids of the activity steps nested inside an effect, in any phase. Nothing may reference them (#3948 decision A7). */
+function effectNestedIds(config: Pick<OpConfig, "phases" | "onFailure">): Set<string> {
+  const ids = new Set<string>();
+  for (const phase of [...config.phases, ...(config.onFailure ?? [])]) {
+    for (const step of phase.steps) {
+      if (step.kind !== "effect") continue;
+      for (const nested of step.steps) if (nested.kind === "activity" && nested.id) ids.add(nested.id);
+    }
+  }
+  return ids;
+}
+
 /** True when `producer` is guaranteed to have completed before `consumer` starts. */
 function producerPrecedes(producer: StepLocation, consumer: StepLocation): boolean {
   if (producer.phaseIndex !== consumer.phaseIndex) return producer.phaseIndex < consumer.phaseIndex;
@@ -270,10 +312,6 @@ function producerPrecedes(producer: StepLocation, consumer: StepLocation): boole
   return producer.stepIndex < consumer.stepIndex;
 }
 
-function effectNestedActivitySteps(phase: PhaseDefinition): ActivityStep[] {
-  return phase.steps.flatMap((s) => (s.kind === "effect" ? s.steps.filter((n) => n.kind === "activity") : []));
-}
-
 /** `byId`/`duplicateIds` over an Op's top-level main-phase activity steps — shared by {@link validateStepOutputRefScope} and {@link validateStepOutputRefs}. */
 function indexById(locations: StepLocation[]): { byId: Map<string, StepLocation>; duplicateIds: Set<string> } {
   const byId = new Map<string, StepLocation>();
@@ -298,46 +336,28 @@ function indexById(locations: StepLocation[]): { byId: Map<string, StepLocation>
  * a public export a caller can invoke directly, bypassing that lint pass —
  * this is its own defense-in-depth.
  *
- * Flags:
- *  - a reference authored inside `onFailure`, or inside an `EffectStep`'s
- *    nested steps — out of scope by design (see the module doc); flagged
- *    explicitly here rather than left to fall through as "unknown producer",
+ * Consumers are the main-phase activity steps, the steps nested inside an
+ * effect, and every `onFailure` activity step (#3948). Flags:
+ *  - a reference to a step nested inside an effect step, from anywhere
+ *    (#3948 decision A7) — flagged explicitly here rather than left to fall
+ *    through as "unknown producer",
  *  - a reference to an unregistered step id (no step in scope declares it),
  *  - a duplicate step id (ambiguous producer),
  *  - a reference to a step that does not precede the referencing step
  *    (a later phase, a later step in the same phase, itself, or a step in
- *    the same parallel phase).
+ *    the same parallel phase). A step nested inside an effect takes the
+ *    effect's position, so it may reference only a step that runs before
+ *    the effect. An `onFailure` step comes after every main phase.
  */
 export function validateStepOutputRefScope(
   config: Pick<OpConfig, "name" | "phases" | "onFailure"> & Partial<Pick<OpConfig, "workLease">>,
 ): ActivityContractIssue[] {
   const issues: ActivityContractIssue[] = [];
 
-  const flagOutOfScope = (steps: ActivityStep[], phaseName: string, reason: string) => {
-    for (const step of steps) {
-      for (const ref of collectStepOutputRefs(step.args)) {
-        issues.push({
-          opName: config.name,
-          phase: phaseName,
-          fn: step.fn,
-          message: `references step "${ref.step}"'s output, but ${reason}`,
-        });
-      }
-    }
-  };
-  for (const phase of config.onFailure ?? []) {
-    const steps = phase.steps.filter((s): s is ActivityStep => s.kind === "activity").concat(effectNestedActivitySteps(phase));
-    flagOutOfScope(steps, phase.name, "step-output references are not supported in onFailure compensation phases");
-  }
-  for (const phase of config.phases) {
-    flagOutOfScope(effectNestedActivitySteps(phase), phase.name, "step-output references are not supported for a step nested inside an effect step");
-  }
-
-  const locations = locateActivitySteps(config.phases);
-  const { byId, duplicateIds } = indexById(locations);
-  const phaseNameOf = (loc: StepLocation): string => config.phases[loc.phaseIndex]!.name;
+  const { byId, duplicateIds } = indexById(locateActivitySteps(config.phases));
+  const nestedIds = effectNestedIds(config);
 
-  for (const consumer of locations) {
+  for (const consumer of locateConsumers(config)) {
     const refs = collectStepOutputRefs(consumer.step.args);
     for (const ref of refs) {
       // The run's work lease (#2748) is published under a reserved id once it
@@ -346,7 +366,7 @@ export function validateStepOutputRefScope(
       if (duplicateIds.has(ref.step)) {
         issues.push({
           opName: config.name,
-          phase: phaseNameOf(consumer),
+          phase: consumer.phaseName,
           fn: consumer.step.fn,
           message: `references step id "${ref.step}", but that id is used by more than one step in this Op — ids must be unique`,
         });
@@ -357,9 +377,11 @@ export function validateStepOutputRefScope(
       if (!producer) {
         issues.push({
           opName: config.name,
-          phase: phaseNameOf(consumer),
+          phase: consumer.phaseName,
           fn: consumer.step.fn,
-          message: `references unknown step id "${ref.step}" — no step in this Op's main phases declares that id`,
+          message: nestedIds.has(ref.step)
+            ? `references step "${ref.step}", which is nested inside an effect step — a step inside an effect runs only when the effect fires, so no other step can reference its output`
+            : `references unknown step id "${ref.step}" — no step in this Op's main phases declares that id`,
         });
         continue;
       }
@@ -373,7 +395,7 @@ export function validateStepOutputRefScope(
               : `step "${ref.step}" does not run before this step`;
         issues.push({
           opName: config.name,
-          phase: phaseNameOf(consumer),
+          phase: consumer.phaseName,
           fn: consumer.step.fn,
           message: `references ${reason} — a step can only reference an earlier step's output`,
         });
@@ -385,10 +407,10 @@ export function validateStepOutputRefScope(
 }
 
 /**
- * Validate every step-output reference in an Op's main phases against a
- * contract map and the Op's own step ordering. Scope: `config.phases` only
- * (never `onFailure`, never a step nested inside an `EffectStep` — see the
- * module doc). Layers contract-based checks on top of {@link
+ * Validate every step-output reference in an Op against a contract map and
+ * the Op's own step ordering, over the consumers {@link
+ * validateStepOutputRefScope} covers (see the module doc). Layers
+ * contract-based checks on top of {@link
  * validateStepOutputRefScope}'s scope/ordering checks.
  *
  * Flags everything {@link validateStepOutputRefScope} does, plus:
@@ -404,11 +426,9 @@ export function validateStepOutputRefs(
 ): ActivityContractIssue[] {
   const issues = validateStepOutputRefScope(config);
 
-  const locations = locateActivitySteps(config.phases);
-  const { byId, duplicateIds } = indexById(locations);
-  const phaseNameOf = (loc: StepLocation): string => config.phases[loc.phaseIndex]!.name;
+  const { byId, duplicateIds } = indexById(locateActivitySteps(config.phases));
 
-  for (const consumer of locations) {
+  for (const consumer of locateConsumers(config)) {
     const refs = collectStepOutputRefs(consumer.step.args);
     for (const ref of refs) {
       // Already flagged by validateStepOutputRefScope — nothing to validate
@@ -421,7 +441,7 @@ export function validateStepOutputRefs(
       if (!producerContract) {
         issues.push({
           opName: config.name,
-          phase: phaseNameOf(consumer),
+          phase: consumer.phaseName,
           fn: consumer.step.fn,
           message: `references step "${ref.step}"'s output, but "${producer.step.fn}" has no registered activity contract to validate the reference against`,
         });
@@ -430,7 +450,7 @@ export function validateStepOutputRefs(
       if (!producerContract.returns) {
         issues.push({
           opName: config.name,
-          phase: phaseNameOf(consumer),
+          phase: consumer.phaseName,
           fn: consumer.step.fn,
           message: `references step "${ref.step}"'s output, but "${producer.step.fn}"'s contract declares no return schema`,
         });
@@ -439,7 +459,7 @@ export function validateStepOutputRefs(
       if (ref.path && !pathExistsInSchema(producerContract.returns as z.ZodTypeAny, ref.path)) {
         issues.push({
           opName: config.name,
-          phase: phaseNameOf(consumer),
+          phase: consumer.phaseName,
           fn: consumer.step.fn,
           message: `references step "${ref.step}"'s output path "${ref.path}", which does not exist on "${producer.step.fn}"'s declared return type`,
         });
@@ -466,7 +486,7 @@ export function validateStepOutputRefs(
           if (consumerKind && producerKind && consumerKind !== producerKind) {
             issues.push({
               opName: config.name,
-              phase: phaseNameOf(consumer),
+              phase: consumer.phaseName,
               fn: consumer.step.fn,
               message: `references step "${ref.step}"'s output path "${ref.path}" (${producerKind}), but arg "${argPath.join(".")}" on "${consumer.step.fn}" declares ${consumerKind} — type mismatch`,
             });

package/src/point-decision-bundle.test.ts

@@ -51,6 +51,7 @@ describe("the point-decision bundle", () => {
       "packages/core/src/intrinsic.ts",
       "packages/core/src/lifecycle/gate-ledger-select.ts",
       "packages/core/src/lifecycle/gate-pending.ts",
+      "packages/core/src/lifecycle/no-record.ts",
       "packages/core/src/lifecycle/plan-digest.ts",
       "packages/core/src/op/duration.ts",
       "packages/core/src/op/gate-point.ts",

package/src/point-decision.ts

@@ -37,6 +37,7 @@ import type { GateLedgerPort } from "./op/gate";
 import { DEFAULT_GATE_POINT_PASS, defaultGatePointStore, gatePointInputs, gateSubject, type GatePoint, type GatePointFacts, type GatePointStore } from "./op/gate-point";
 import type { WaitingPoint } from "./op/steward-points";
 import { resolveGateRunLocator, type GateRunLocator } from "./op/gate-run-locator";
+import { refuseGateWithoutRecording } from "./lifecycle/no-record";
 
 export {
   DEFAULT_GATE_POINT_PASS,
@@ -170,6 +171,8 @@ function resolvedByOf(q: GatePointQuestion): string {
 
 /** Decide a gate that asks a point: ask it, then record the pending fact or the resolution that cites the answer. */
 export async function evaluatePointGate(port: PointGateLedgerPort, asker: GatePointAsker, input: PointGateInput): Promise<PointGateCheck> {
+  // #3955: refused before the point is asked, which would itself write to the ledger.
+  refuseGateWithoutRecording(input.op, input.gate);
   const now = input.now ?? new Date().toISOString();
   const facts: GatePointFacts = { component: input.op, name: input.gate, env: input.env ?? null, planDigest: input.planDigest ?? null };
   const q = await asker.ask({ point: input.point.name, inputs: input.inputs ?? {}, facts, subject: gateSubject(input.op, input.gate, input.env), ...(input.point.store ? { store: input.point.store } : {}) });

package/src/workspace/agent-cli.ts

@@ -91,6 +91,8 @@ export async function agentSession(q: { cwd: string; name: string }): Promise<Ag
   try {
     const source = scopeSource(q.cwd);
     if (source.declaration === null || source.from === null) {
+      // A declaration that is there but fails validation says so (#3433).
+      if (source.failure && source.failure.code !== "declaration-missing") throw source.failure;
       throw new WorkspaceReadError("declaration-missing", "no chant.workspace.json or .jsonc between this directory and the git root, so no agent session is declared");
     }
     const decl = source.declaration;

package/src/workspace/compose-graph.test.ts

@@ -104,6 +104,61 @@ describe("composeWorkspaceGraph", () => {
   });
 });
 
+describe("CI edges, pipelines and dangling references (#3922)", () => {
+  /** A github member as `chant graph` reports it after #3910. */
+  const ci = (workflow: string, job: string): GraphIR => ({
+    version: 1,
+    nodes: [
+      { id: workflow, kind: "Workflow", lexicon: "github", attrs: {} },
+      { id: job, kind: "Job", lexicon: "github", attrs: {} },
+      { id: "deploy", kind: "Job", lexicon: "github", attrs: {} },
+    ],
+    edges: [
+      { from: "deploy", to: job, kind: "needs", viaAttr: "needs" },
+      { from: job, to: workflow, kind: "calls", viaAttr: "uses", crossPipeline: true },
+    ],
+    groups: { byLexicon: { github: [job, "deploy", workflow] }, byPipeline: { ci: [job, "deploy", workflow] } },
+    dangling: [
+      { from: "deploy", kind: "needs", path: "needs", value: "lint" },
+      { from: job, kind: "calls", path: "uses", value: "other/repo/.github/workflows/x.yml@main", crossPipeline: true },
+    ],
+  });
+  const doc = composeWorkspaceGraph({ name: "acme", root: "." }, [
+    { member: member("svc", "svc"), ir: ci("ciWorkflow", "build") },
+    { member: member("app", "app"), ir: ci("ciWorkflow", "test") },
+    { member: member("db", "db"), ir: db },
+  ]);
+
+  test("edges keep their kind and crossPipeline", () => {
+    expect(doc.edges.filter((e) => e.member === "svc")).toEqual([
+      { from: "svc/build", to: "svc/ciWorkflow", kind: "calls", viaAttr: "uses", crossPipeline: true, member: "svc" },
+      { from: "svc/deploy", to: "svc/build", kind: "needs", viaAttr: "needs", member: "svc" },
+    ]);
+  });
+
+  test("byPipeline keys and ids are prefixed with the member", () => {
+    expect(doc.groups.byPipeline).toEqual({
+      "app/ci": ["app/ciWorkflow", "app/deploy", "app/test"],
+      "svc/ci": ["svc/build", "svc/ciWorkflow", "svc/deploy"],
+    });
+  });
+
+  test("dangling references keep their fields, with from prefixed and the member named, sorted", () => {
+    expect(doc.dangling).toEqual([
+      { from: "app/deploy", kind: "needs", path: "needs", value: "lint", member: "app" },
+      { from: "app/test", kind: "calls", path: "uses", value: "other/repo/.github/workflows/x.yml@main", crossPipeline: true, member: "app" },
+      { from: "svc/build", kind: "calls", path: "uses", value: "other/repo/.github/workflows/x.yml@main", crossPipeline: true, member: "svc" },
+      { from: "svc/deploy", kind: "needs", path: "needs", value: "lint", member: "svc" },
+    ]);
+  });
+
+  test("no dangling section and no byPipeline when no member reports either", () => {
+    const plain = composeWorkspaceGraph({ name: "acme", root: "." }, [{ member: member("db", "db"), ir: db }]);
+    expect("dangling" in plain).toBe(false);
+    expect(plain.groups.byPipeline).toBeUndefined();
+  });
+});
+
 describe("the links section (#2539)", () => {
   test("inferred joins carry their label, and a declared link suppresses the inferred edge it covers", () => {
     const consumer: GraphIR = {

package/src/workspace/compose-graph.ts

@@ -11,8 +11,12 @@
  *   `runtimeOwner` and export and import nodes are rewritten the same way.
  * - `groups.byMember` maps each member to its node ids. `byLexicon` and
  *   `byComposite` keep their keys (a lexicon or composite type is the same
- *   thing in every member) and merge the ids. `byStack`, `byContainer` and
- *   `byWave` name things inside one member, so their keys are prefixed too.
+ *   thing in every member) and merge the ids. `byStack`, `byContainer`,
+ *   `byWave` and `byPipeline` name things inside one member, so their keys
+ *   are prefixed too.
+ * - Edges keep their `kind` and `crossPipeline` (#3910). A member's dangling
+ *   references (`ir.dangling`) land on the top-level `dangling` list with
+ *   `from` prefixed and a `member` field, like edges (#3922).
  * - `links` holds the member links (#2524 D6, #2539): the declared links and
  *   the joins inferred from members' `imports` and `exports` with the core
  *   `joinKey()`, labelled `exact` or `folded` (`./links.ts`). A declared link
@@ -36,7 +40,7 @@ import { graphLinks, type LinkTableRow } from "./links";
 import type { KindLinkRead } from "./kind-link-readers";
 import type { RecordLinkRow } from "./record-assets";
 import type { ReasonCode } from "./reason-codes";
-import { GRAPH_IR_VERSION, type GraphIR, type IRExport, type IRGroups, type IRImport, type IREdge, type IRNode } from "../graph-ir";
+import { GRAPH_IR_VERSION, type GraphIR, type IRExport, type IRDanglingRef, type IRGroups, type IRImport, type IREdge, type IRNode } from "../graph-ir";
 
 /** The version of the composed document `chant workspace graph` writes. */
 export const WORKSPACE_GRAPH_VERSION = 1;
@@ -165,6 +169,8 @@ export const COLLECTOR_META_KEY = "collector";
 /** `nested` names the nested workspace's member a node was read through (#2551); absent for the outer workspace's own nodes. */
 export type ComposedNode = IRNode & { member: string; nested?: string };
 export type ComposedEdge = IREdge & { member: string };
+/** A member's dangling reference (#3910, #3922): `from` is prefixed like a node id. `nested` as on {@link ComposedNode}. */
+export type ComposedDangling = IRDanglingRef & { member: string; nested?: string };
 
 export interface WorkspaceGraph {
   version: number;
@@ -176,6 +182,12 @@ export interface WorkspaceGraph {
   exports: (IRExport & { member: string })[];
   imports: (IRImport & { member: string })[];
   derivedAttrs?: Record<string, string[]>;
+  /**
+   * The members' dangling CI references (#3910, #3922): each `ir.dangling`
+   * entry with `from` prefixed by its member and a `member` field, sorted by
+   * `from`, `path` and `value`. Absent when no member has one.
+   */
+  dangling?: ComposedDangling[];
   /**
    * Member links (#2524 D6, #2539), declared and inferred, then the links of
    * the records read with `--kind` (#2549). Empty when no declaration is given.
@@ -289,6 +301,13 @@ function prefixRefs(value: unknown, member: string): unknown {
   return out;
 }
 
+/** The groups whose keys name something inside one member, so are prefixed with it. */
+export const SCOPED_GROUPS = ["byStack", "byContainer", "byWave", "byPipeline"] as const;
+type ScopedGroup = (typeof SCOPED_GROUPS)[number];
+
+/** The order the composed `dangling` list is sorted in. */
+export const danglingKey = (d: IRDanglingRef): string => `${d.from}\u0000${d.path}\u0000${d.value}`;
+
 function mergeInto(target: Record<string, string[]>, key: string, ids: string[]): void {
   (target[key] ??= []).push(...ids);
 }
@@ -317,7 +336,8 @@ export function composeWorkspaceGraph(
   const imports: WorkspaceGraph["imports"] = [];
   const byMember: Record<string, string[]> = {};
   const shared: Record<"byLexicon" | "byComposite", Record<string, string[]>> = { byLexicon: {}, byComposite: {} };
-  const scoped: Record<"byStack" | "byContainer" | "byWave", Record<string, string[]>> = { byStack: {}, byContainer: {}, byWave: {} };
+  const scoped: Record<ScopedGroup, Record<string, string[]>> = { byStack: {}, byContainer: {}, byWave: {}, byPipeline: {} };
+  const dangling: ComposedDangling[] = [];
   const derivedAttrs: Record<string, Set<string>> = {};
   const collectors: MemberCollector[] = [];
 
@@ -337,9 +357,10 @@ export function composeWorkspaceGraph(
     for (const key of ["byLexicon", "byComposite"] as const) {
       for (const [k, v] of Object.entries(ir.groups[key] ?? {})) mergeInto(shared[key], k, v.map((id) => prefix(m, id)));
     }
-    for (const key of ["byStack", "byContainer", "byWave"] as const) {
+    for (const key of SCOPED_GROUPS) {
       for (const [k, v] of Object.entries(ir.groups[key] ?? {})) mergeInto(scoped[key], prefix(m, k), v.map((id) => prefix(m, id)));
     }
+    for (const d of ir.dangling ?? []) dangling.push({ ...d, from: prefix(m, d.from), member: m });
     for (const e of ir.exports ?? []) exports.push({ ...e, ...(e.node ? { node: prefix(m, e.node) } : {}), member: m });
     for (const i of ir.imports ?? []) imports.push({ ...i, node: prefix(m, i.node), member: m });
     for (const [kind, attrs] of Object.entries(ir.derivedAttrs ?? {})) for (const a of attrs) (derivedAttrs[kind] ??= new Set()).add(a);
@@ -360,7 +381,7 @@ export function composeWorkspaceGraph(
 
   const groups: WorkspaceGraph["groups"] = { byMember };
   for (const key of ["byLexicon", "byComposite"] as const) if (Object.keys(shared[key]).length) groups[key] = sorted(shared[key]);
-  for (const key of ["byStack", "byContainer", "byWave"] as const) if (Object.keys(scoped[key]).length) groups[key] = sorted(scoped[key]);
+  for (const key of SCOPED_GROUPS) if (Object.keys(scoped[key]).length) groups[key] = sorted(scoped[key]);
 
   const doc: WorkspaceGraph = {
     version: WORKSPACE_GRAPH_VERSION,
@@ -377,6 +398,7 @@ export function composeWorkspaceGraph(
     collectors,
     records: [],
   };
+  if (dangling.length) doc.dangling = dangling.sort((a, b) => danglingKey(a).localeCompare(danglingKey(b)));
   if (Object.keys(derivedAttrs).length) {
     doc.derivedAttrs = Object.fromEntries(Object.keys(derivedAttrs).sort().map((k) => [k, [...derivedAttrs[k]].sort()]));
   }

package/src/workspace/conformance/__writer_fixture__/answers/answer.schema.json

@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "urn:intentius:chant:point-answer:1",
   "title": "Decision point answer front matter",
-  "description": "The front matter of one answer to a decision point (ws-058, #2739), as `chant workspace points ask` and `points answer` write it into the records directory of a record kind with an `answers` block. One record per point, declaration and inputs: its id is the point's name and the first 12 hex digits of the inputs hash, so the same question is answered once. A table's answer is `answered`; a model's answer at or above its threshold is `proposed` until a person confirms it; a question no decider before the quorum answered is `escalated`, open for people. An answer never changes in place: `points retract` escalates the question to people again and moves the answer into `retractions` (#3351, ws-084). An ad-hoc point's answer keeps the question and candidates its ask gave as `asked`, and they are part of the inputs hash (#3403). A workspace copies this file next to its answer kind, as reference-workspace/answers/ does. Values stay within what YAML and JSON share. Fields other than these must start with x-.",
+  "description": "The front matter of one answer to a decision point (ws-058, #2739), as `chant workspace points ask` and `points answer` write it into the records directory of a record kind with an `answers` block. One record per point, declaration and inputs: its id is the point's name and the first 12 hex digits of the inputs hash, so the same question is answered once. A table's answer is `answered`; a model's answer at or above its threshold is `proposed` until a person confirms it; a question no decider before the quorum answered is `escalated`, open for people. An answer never changes in place: `points retract` escalates the question to people again and moves the answer into `retractions` (#3351, ws-084). An open question that no longer applies is `withdrawn` (`points withdraw`, #2888), and asking it again opens it again. An ad-hoc point's answer keeps the question and candidates its ask gave as `asked`, and they are part of the inputs hash (#3403). A workspace copies this file next to its answer kind, as reference-workspace/answers/ does. Values stay within what YAML and JSON share. Fields other than these must start with x-.",
   "type": "object",
   "additionalProperties": false,
   "patternProperties": { "^x-": {} },
@@ -65,6 +65,17 @@
       "description": "Answers people took back, oldest first (`points retract`, #3351): each answer as it was, and who retracted it, when and why. A retracted question is escalated to people again.",
       "items": { "$ref": "#/definitions/retraction" }
     },
+    "withdrawn": {
+      "type": "object",
+      "description": "An open question that no longer applies, such as one about a work item its author changed, which a run asks about anew (`points withdraw`, #2888): who withdrew it, when and why. A withdrawn question is not open, and nobody answers it; asking it again opens it again.",
+      "required": ["by", "on"],
+      "properties": {
+        "by": { "type": "array", "minItems": 1, "items": { "type": "string", "minLength": 1 }, "description": "Who withdrew it." },
+        "on": { "$ref": "#/definitions/date" },
+        "note": { "type": "string", "minLength": 1, "description": "Why it was withdrawn (`points withdraw --note`)." }
+      },
+      "additionalProperties": false
+    },
     "asked_on": { "$ref": "#/definitions/date" },
     "answered_on": { "$ref": "#/definitions/date" },
     "source": {
@@ -85,6 +96,10 @@
       "if": { "properties": { "state": { "const": "escalated" } }, "required": ["state"] },
       "then": { "not": { "required": ["answer"] }, "properties": { "decider": { "properties": { "kind": { "const": "quorum" } } } } }
     },
+    {
+      "if": { "required": ["withdrawn"] },
+      "then": { "properties": { "state": { "enum": ["escalated", "proposed"] } } }
+    },
     {
       "if": { "properties": { "decider": { "properties": { "kind": { "const": "model" } }, "required": ["kind"] } }, "required": ["decider"] },
       "then": { "required": ["probabilities", "confidence", "threshold"], "properties": { "decider": { "required": ["backend", "model"] } } }

package/src/workspace/conformance/writer.ts

@@ -614,7 +614,7 @@ export function isReadCall(argv: readonly string[]): boolean {
     case "runs":
       return !["start", "end", "record"].includes(sub ?? "");
     case "points":
-      return !["ask", "answer", "retract"].includes(sub ?? "");
+      return !["ask", "answer", "retract", "withdraw"].includes(sub ?? "");
     case "work":
       return sub === "history";
     case "wip":