@intentius/chant 0.124.23 → 0.124.25

package/src/workspace/decide.test.ts

@@ -10,7 +10,7 @@ import { join } from "node:path";
 import { afterAll, beforeAll, describe, expect, test } from "vitest";
 import { runDeclarationChecks } from "./checks";
 import { cleanScratch, commitAll, contract, REPO, repo } from "./__fixtures__/contract-repo";
-import { answerFields, answerPoint, askPoint, reasonFields, retractAnswer, type PointsWriteDocument } from "./decide";
+import { answerFields, answerPoint, askPoint, reasonFields, retractAnswer, withdrawQuestion, type PointsWriteDocument } from "./decide";
 import pointAnswerSchema from "./point-answer.schema.json";
 import { responseAsk, workspacePoints } from "./points-cli";
 import pointsSchema from "./points.schema.json";
@@ -293,13 +293,13 @@ describe("the intent walk's points, a note on an answer, and retracting it (#335
   });
 
   test("a workspace whose answer schema predates notes and retractions refuses them, rather than dropping them", () => {
-    expect(answerFields(pointAnswerSchema)).toEqual({ note: true, retractions: true, relayedBy: true, asked: true });
+    expect(answerFields(pointAnswerSchema)).toEqual({ note: true, retractions: true, relayedBy: true, asked: true, withdrawn: true });
     const old = JSON.parse(JSON.stringify(pointAnswerSchema));
     delete old.properties.note;
     delete old.properties.retractions;
     delete old.properties.relayed_by;
     delete old.properties.asked;
-    expect(answerFields(old)).toEqual({ note: false, retractions: false, relayedBy: false, asked: false });
+    expect(answerFields(old)).toEqual({ note: false, retractions: false, relayedBy: false, asked: false, withdrawn: true });
   });
 
   test("an answer relayed for a person records who relayed it, and a retraction keeps it (#3402)", async () => {
@@ -399,6 +399,90 @@ describe("an ad-hoc question whose candidates come with the ask (#3403)", () =>
   });
 });
 
+describe("withdrawing an open question that no longer applies (#2888)", () => {
+  const item = (title: string) => ({
+    "work-item.state": "proposed",
+    "work-item.title": title,
+    "work-item.source.ask.said": "make the port configurable",
+    "work-item.source.ask.by": "alice",
+    "work-item.source.ask.via": "hud",
+    "work-item.acceptance": [],
+  });
+
+  test("the earlier question about a changed item is withdrawn, and --open leaves it out", async () => {
+    const first = ok(await askPoint({ cwd: root, point: "understand", inputs: item("Configurable port"), subject: "W-101", on }));
+    expect(first.question).toMatchObject({ state: "escalated", open: true, withdrawn: null });
+    // The author changes the item: the next ask is another question about W-101, and both are open.
+    const second = ok(await askPoint({ cwd: root, point: "understand", inputs: item("Make the server port configurable"), subject: "W-101", on }));
+    expect(second.id).not.toBe(first.id);
+    const openAbout = async () => {
+      const listed = await workspacePoints({ cwd: root, open: true });
+      read.expectValid(listed);
+      if ("error" in listed) throw new Error(listed.error.message);
+      return listed.questions.filter((q) => q.subject === "W-101").map((q) => q.id);
+    };
+    expect((await openAbout()).sort()).toEqual([first.id, second.id].sort());
+
+    const withdrawn = ok(await withdrawQuestion({ cwd: root, id: first.id, by: ["factory"], note: `W-101 changed; ${second.id} asks it now.`, on: "2026-09-26" }));
+    expect(withdrawn).toMatchObject({ verb: "withdraw", written: true });
+    expect(withdrawn.question).toMatchObject({ state: "escalated", open: false, answer: null, withdrawn: { by: ["factory"], on: "2026-09-26", note: `W-101 changed; ${second.id} asks it now.` } });
+    expect(withdrawn.question.title).toMatch(/: withdrawn$/);
+    expect(fm(first.path)).toContain('withdrawn:\n  by:\n    - "factory"');
+    expect(await openAbout()).toEqual([second.id]);
+  });
+
+  test("a withdrawn question is closed: nobody answers it, and refusals", async () => {
+    const asked = ok(await askPoint({ cwd: root, point: "understand", inputs: item("Refusals"), on }));
+    expect(refused(await withdrawQuestion({ cwd: root, id: asked.id, by: [" "] }))).toBe("write-usage-invalid");
+    expect(ok(await withdrawQuestion({ cwd: root, id: asked.id, by: ["factory"], dryRun: true }))).toMatchObject({ verb: "withdraw", written: false, question: { open: false } });
+    expect(fm(asked.path)).not.toContain("withdrawn:");
+    ok(await withdrawQuestion({ cwd: root, id: asked.id, by: ["factory"], on }));
+    expect(refused(await answerPoint({ cwd: root, id: asked.id, answer: "proceed", by: ["alice"] }))).toBe("record-closed");
+    expect(refused(await withdrawQuestion({ cwd: root, id: asked.id, by: ["factory"] }))).toBe("record-closed");
+    const table = ok(await askPoint({ cwd: root, point: "slice-tier", inputs: { "work-item.fits_small": true }, on }));
+    expect(refused(await withdrawQuestion({ cwd: root, id: table.id, by: ["factory"] }))).toBe("record-closed");
+    const all = await workspacePoints({ cwd: root });
+    if ("error" in all) throw new Error(all.error.message);
+    expect(all.summary.withdrawn).toBe(all.questions.filter((q) => q.withdrawn !== null).length);
+    expect(all.summary.withdrawn).toBeGreaterThan(0);
+  });
+
+  test("asking a withdrawn question again opens it again", async () => {
+    const asked = ok(await askPoint({ cwd: root, point: "understand", inputs: item("Port, again"), subject: "W-102", on }));
+    ok(await withdrawQuestion({ cwd: root, id: asked.id, by: ["factory"], on }));
+    // The item changed back: the same inputs ask the same question.
+    const again = ok(await askPoint({ cwd: root, point: "understand", inputs: item("Port, again"), on: "2026-09-27" }));
+    expect(again).toMatchObject({ id: asked.id, reused: false, written: true, question: { state: "escalated", open: true, withdrawn: null, subject: "W-102", askedOn: "2026-09-27" } });
+    expect(fm(asked.path)).not.toContain("withdrawn:");
+  });
+
+  test("a retracted question withdrawn and asked again is open for people again, its retractions kept", async () => {
+    const inputs = { "region.id": "region:app/server.mjs:1-1", "node.id": "decision:ref-009" };
+    const asked = ok(await askPoint({ cwd: root, point: "intent-origin", inputs, on }));
+    ok(await answerPoint({ cwd: root, id: asked.id, answer: "incidental", by: ["alice"], on }));
+    ok(await retractAnswer({ cwd: root, id: asked.id, by: ["alice"], on }));
+    ok(await withdrawQuestion({ cwd: root, id: asked.id, by: ["factory"], on }));
+    const again = ok(await askPoint({ cwd: root, point: "intent-origin", inputs, on }));
+    expect(again).toMatchObject({ reused: false, question: { state: "escalated", open: true, withdrawn: null, retractions: [{ answer: "incidental" }] } });
+    expect(again.question.title).toMatch(/: open for people$/);
+  });
+
+  test("a workspace whose answer schema predates withdrawn refuses to withdraw", async () => {
+    expect(answerFields(pointAnswerSchema).withdrawn).toBe(true);
+    const asked = ok(await askPoint({ cwd: root, point: "understand", inputs: item("Old schema"), on }));
+    const schemaFile = join(root, "answers", "answer.schema.json");
+    const original = readFileSync(schemaFile, "utf-8");
+    const old = JSON.parse(original);
+    delete old.properties.withdrawn;
+    writeFileSync(schemaFile, JSON.stringify(old, null, 2));
+    try {
+      expect(refused(await withdrawQuestion({ cwd: root, id: asked.id, by: ["factory"] }))).toBe("answer-field-unsupported");
+    } finally {
+      writeFileSync(schemaFile, original);
+    }
+  });
+});
+
 describe("the points file in check and on read (#2738)", () => {
   test("a changed point warns on its answers, and an invalid points file is WSP116 and a points-invalid source", async () => {
     const file = join(root, "decisions", "points.json");

package/src/workspace/decide.ts

@@ -4,7 +4,8 @@
  * {@link askPoint} asks a point's deciders for one set of inputs and records
  * the answer in the answer kind's records directory, {@link answerPoint}
  * records people's answer to an open question, with an optional note, and
- * {@link retractAnswer} takes an answer back (#3351). Each writes one Markdown
+ * {@link retractAnswer} takes an answer back (#3351), and {@link withdrawQuestion}
+ * closes an open question that no longer applies (#2888). Each writes one Markdown
  * record or none, never commits, and goes through the checks every records write goes
  * through (`records-write.ts`): the record is read back with the kind's schema
  * before it is written, and no other record may become invalid.
@@ -33,6 +34,14 @@
  * and why. Asking a retracted question again returns it as it stands, since
  * people took it back from the deciders; people answer it again.
  *
+ * An open question that no longer applies, such as one about a work item its
+ * author changed while it was escalated, is withdrawn (#2888): it keeps its
+ * state, with who withdrew it, when and why as `withdrawn`, is no longer open,
+ * and nobody answers it. A changed item is another question with another id,
+ * so nothing closes the earlier one on its own; whoever asked withdraws it.
+ * Asking a withdrawn question again opens it again, as when the item changes
+ * back.
+ *
  * Each write holds the working tree's write lock (#3173, ws-089) from the first read
  * to the write, so two answers to one question are never both taken from the
  * same reading of it.
@@ -95,11 +104,11 @@ import { RefCASConflictError } from "../lifecycle/git";
 import { readLedgerAnswers, refreshLedger, withLedgerAnswers, writeLedgerAnswer, type LedgerAnswers } from "./answers-ledger";
 import { currentGateOrigin, isModelAuthored, type GateOrigin } from "../lifecycle/gate-origin";
 
-/** The version of the write documents `points ask`, `points answer` and `points retract` print. */
+/** The version of the write documents `points ask`, `points answer`, `points retract` and `points withdraw` print. */
 export const POINTS_WRITE_CONTRACT_VERSION = 1;
 export const POINTS_WRITE_SCHEMA_ID = "https://intentius.io/chant/schemas/workspace/points-write/v1/points-write.schema.json";
 
-/** Why `points ask`, `points answer` or `points retract` wrote nothing. Closed: a reader may switch on it. */
+/** Why `points ask`, `points answer`, `points retract` or `points withdraw` wrote nothing. Closed: a reader may switch on it. */
 export const POINTS_WRITE_ERROR_CODES = [
   ...LOAD_ERROR_CODES,
   "write-usage-invalid",
@@ -129,7 +138,7 @@ export const POINTS_WRITE_ERROR_CODES = [
   "principal-unidentified",
   /** `points retract` names a question that has no answer: escalated or proposed (#3351). */
   "answer-not-answered",
-  /** The answer kind's schema copy has no `note`, `retractions`, `relayed_by` or `asked` field for what the write was given (#3351, #3402, #3403). */
+  /** The answer kind's schema copy has no `note`, `retractions`, `relayed_by`, `asked` or `withdrawn` field for what the write was given (#3351, #3402, #3403, #2888). */
   "answer-field-unsupported",
   /** An ad-hoc point was asked without its question and candidates, a declared point with them, or they don't fit the point's question type (#3403). */
   "point-candidates-invalid",
@@ -158,7 +167,7 @@ export interface QuestionView {
   /** What the question is about, the record's first `constrains` entry, or null. */
   subject: string | null;
   state: "escalated" | "proposed" | "answered";
-  /** Not answered yet: escalated to people, or proposed by a model and waiting for a person to confirm it. */
+  /** Not answered yet: escalated to people, or proposed by a model and waiting for a person to confirm it, and not withdrawn (#2888). */
   open: boolean;
   questionType: string;
   candidates: (string | boolean)[];
@@ -194,6 +203,8 @@ export interface QuestionView {
   relayedBy: string | null;
   /** Answers people took back, oldest first (`points retract`, #3351). Empty when none was. */
   retractions: RetractionView[];
+  /** Who withdrew the question, when and why, when it no longer applies (`points withdraw`, #2888), or null. A withdrawn question is not open. */
+  withdrawn: { by: string[]; on: string | null; note: string | null } | null;
   /**
    * An ad-hoc point's question as its ask gave it (#3403): the question's text
    * and its criteria, what each candidate means. null for a declared point's
@@ -255,6 +266,14 @@ function retractionsOf(d: Record<string, unknown>): RetractionView[] {
     }));
 }
 
+/** The record's `withdrawn`, as a view, or null. */
+function withdrawnOf(d: Record<string, unknown>): QuestionView["withdrawn"] {
+  const w = d.withdrawn;
+  if (w === null || typeof w !== "object" || Array.isArray(w)) return null;
+  const r = w as Record<string, unknown>;
+  return { by: Array.isArray(r.by) ? r.by.filter((x): x is string => typeof x === "string") : [], on: typeof r.on === "string" ? r.on : null, note: typeof r.note === "string" ? r.note : null };
+}
+
 /** The harness a steward's question names in its source block (#2749). */
 export const STEWARD_HARNESS = "chant-steward";
 
@@ -304,6 +323,7 @@ export function questionView(entry: RecordEntry, point: Point | undefined, ledge
     }
   }
   const constrains = Array.isArray(d.constrains) ? d.constrains.filter((c): c is string => typeof c === "string") : [];
+  const withdrawn = withdrawnOf(d);
   return {
     id: entry.id,
     path: entry.path,
@@ -311,7 +331,7 @@ export function questionView(entry: RecordEntry, point: Point | undefined, ledge
     title: str(d.title) ?? "",
     subject: constrains[0] ?? null,
     state,
-    open: state !== "answered",
+    open: state !== "answered" && withdrawn === null,
     questionType: str(d.question_type) ?? "",
     candidates: Array.isArray(d.candidates) ? (d.candidates as (string | boolean)[]) : [],
     inputs: d.inputs !== null && typeof d.inputs === "object" && !Array.isArray(d.inputs) ? (d.inputs as Record<string, unknown>) : {},
@@ -332,6 +352,7 @@ export function questionView(entry: RecordEntry, point: Point | undefined, ledge
     note: str(d.note),
     relayedBy: str(d.relayed_by),
     retractions: retractionsOf(d),
+    withdrawn,
     asked: askedOf(d) ?? null,
     askedBy: askedByOf(d),
     ledger,
@@ -341,9 +362,9 @@ export function questionView(entry: RecordEntry, point: Point | undefined, ledge
 }
 
 /** The write verbs of `points`. */
-export type PointsWriteVerb = "ask" | "answer" | "retract";
+export type PointsWriteVerb = "ask" | "answer" | "retract" | "withdraw";
 
-/** What `points ask`, `points answer` and `points retract` print. */
+/** What `points ask`, `points answer`, `points retract` and `points withdraw` print. */
 export type PointsWriteDocument =
   | {
       $schema: string;
@@ -460,7 +481,7 @@ const show = (answer: string | boolean, type: string): string => (type === "noul
 
 /** A record's title: the point's title, or an ad-hoc question's own text (#3403), what it is about, and where it stands. */
 function titleFor(point: Point, subject: string | undefined, state: string, answer: string | boolean | undefined, asked?: Asked): string {
-  const outcome = state === "escalated" ? "open for people" : state === "proposed" ? `${show(answer!, point.question.type)}, proposed` : show(answer!, point.question.type);
+  const outcome = state === "withdrawn" ? "withdrawn" : state === "escalated" ? "open for people" : state === "proposed" ? `${show(answer!, point.question.type)}, proposed` : show(answer!, point.question.type);
   return `${asked ? asked.question : point.title}${subject ? ` (${subject})` : ""}: ${outcome}`;
 }
 
@@ -639,9 +660,25 @@ async function askPointLocked(opts: AskPointOptions): Promise<PointsWriteDocumen
       question: questionView(entry, point, extra.ledger !== undefined ? extra.ledger : heldAt(entry))!,
       ...(extra.text !== undefined ? { text: extra.text } : {}),
     });
-    if (existing && existing.data !== null && (existing.state === "answered" || existing.state === "proposed")) return done(existing, { reused: true, written: false });
+    /** A retracted question withdrawn and now asked again: open for people again, as it stood before it was withdrawn (#2888). */
+    const reopen = async (entry: RecordEntry & { data: Record<string, unknown> }): Promise<PointsWriteDocument> => {
+      const { withdrawn: _, ...rest } = entry.data;
+      const subject = Array.isArray(rest.constrains) && typeof rest.constrains[0] === "string" ? (rest.constrains[0] as string) : undefined;
+      const title = titleFor(point, subject, String(rest.state), rest.answer as string | boolean | undefined, asked);
+      const data = recordData(o, { ...rest, title });
+      const text = renderRecord(data, body(point, title, asked));
+      const message = `Decision point ${opts.point}: asked again${subject ? ` (${subject})` : ""}`;
+      const wrote = await write(o, before, entry.path, text, false, !!opts.dryRun, { source: read, ledger, onLedger: toLedger || ledger.byPath.has(entry.path), message, who: { verb: "points ask", by: steward?.name ?? null } });
+      return done({ ...entry, data, valid: true, reasons: [], warnings: wrote.warnings }, { reused: false, written: !opts.dryRun, ledger: wrote.ledger, ...(opts.dryRun ? { text } : {}) });
+    };
+    // A withdrawn question is asked again (#2888): it applies again, so it is open again.
+    const withdrawn = existing !== undefined && existing.data !== null && existing.data.withdrawn !== undefined;
+    if (existing && existing.data !== null && !withdrawn && (existing.state === "answered" || existing.state === "proposed")) return done(existing, { reused: true, written: false });
     // People took a retracted question back from the deciders (ws-084): they answer it again, and asking returns it as it stands.
-    if (existing && existing.data !== null && Array.isArray(existing.data.retractions) && existing.data.retractions.length > 0) return done(existing, { reused: true, written: false });
+    if (existing && existing.data !== null && Array.isArray(existing.data.retractions) && existing.data.retractions.length > 0) {
+      if (!withdrawn) return done(existing, { reused: true, written: false });
+      return reopen(existing as RecordEntry & { data: Record<string, unknown> });
+    }
 
     let result: ChainResult;
     try {
@@ -651,7 +688,7 @@ async function askPointLocked(opts: AskPointOptions): Promise<PointsWriteDocumen
       throw err;
     }
     // A standing escalation is kept while the chain still escalates.
-    if (existing && existing.data !== null && result.status === "escalated") return done(existing, { reused: true, written: false });
+    if (existing && existing.data !== null && !withdrawn && result.status === "escalated") return done(existing, { reused: true, written: false });
 
     const on = opts.on ?? today();
     const state = result.status;
@@ -731,15 +768,16 @@ export interface AnswerPointOptions {
 
 /**
  * Whether an answer kind's schema copy takes the fields of #3351 (`note` on an
- * answer, and `retractions`), of #3402 (`relayed_by`) and of #3403 (`asked`).
- * A copy of point-answer.schema.json from before them refuses a note, a
- * retraction, a relay or an ad-hoc ask with `answer-field-unsupported`, rather
+ * answer, and `retractions`), of #3402 (`relayed_by`), of #3403 (`asked`) and
+ * of #2888 (`withdrawn`). A copy of point-answer.schema.json from before them
+ * refuses a note, a retraction, a relay, an ad-hoc ask or a withdrawal with
+ * `answer-field-unsupported`, rather
  * than dropping what a person wrote or the question an agent asked.
  */
-export function answerFields(schema: Record<string, unknown>): { note: boolean; retractions: boolean; relayedBy: boolean; asked: boolean } {
+export function answerFields(schema: Record<string, unknown>): { note: boolean; retractions: boolean; relayedBy: boolean; asked: boolean; withdrawn: boolean } {
   const props = schema.properties as Record<string, unknown> | undefined;
   const has = (key: string): boolean => props !== undefined && props !== null && typeof props === "object" && Object.prototype.hasOwnProperty.call(props, key);
-  return { note: has("note"), retractions: has("retractions"), relayedBy: has("relayed_by"), asked: has("asked") };
+  return { note: has("note"), retractions: has("retractions"), relayedBy: has("relayed_by"), asked: has("asked"), withdrawn: has("withdrawn") };
 }
 
 /** A note as given, trimmed, or undefined when it is empty. */
@@ -944,6 +982,9 @@ async function answerPointLocked(opts: AnswerPointOptions): Promise<PointsWriteD
     if (target.state === "answered") {
       throw new PointsWriteError("record-closed", `${opts.id} is answered, and an answer never changes in place: retract it with \`points retract ${opts.id}\` and answer again, ask again with other inputs, or change the point, which asks the question anew`);
     }
+    if (d.withdrawn !== undefined) {
+      throw new PointsWriteError("record-closed", `${opts.id} was withdrawn, so nobody answers it: ask it again with \`points ask\`, which opens it again, when it applies again`);
+    }
     const note = noteOf(opts.note);
     if (note !== undefined && !answerFields(o.loaded.schema).note) {
       throw new PointsWriteError("answer-field-unsupported", `the ${o.loaded.kind.name} kind's schema has no note field, so ${opts.id} can't keep the note: copy point-answer.schema.json from @intentius/chant anew`);
@@ -1151,3 +1192,87 @@ async function retractAnswerLocked(opts: RetractAnswerOptions): Promise<PointsWr
     return failure("retract", err);
   }
 }
+
+// ── points withdraw ──────────────────────────────────────────────────────────
+
+export interface WithdrawQuestionOptions {
+  cwd: string;
+  /** The answer record's id. */
+  id: string;
+  /** Who withdraws the question, such as the factory that asked it. At least one. */
+  by: string[];
+  /** Why, such as the question that asks about the subject now. */
+  note?: string;
+  kind?: string;
+  on?: string;
+  dryRun?: boolean;
+}
+
+/**
+ * Close an open question that no longer applies: `points withdraw` (#2888).
+ * A run asks about a work item whose author then changes it, so the next ask
+ * is another question, and the first one would wait on people forever. The
+ * question keeps its state, escalated or proposed, and gains `withdrawn`: who
+ * withdrew it, when and why. It is no longer open, so `points --open` leaves
+ * it out, and `points answer` refuses it. Asking it again opens it again.
+ *
+ * Withdrawing answers nothing and passes no gate, so it needs no quorum, and
+ * the asker withdraws its own question, a steward's turn or an MCP session
+ * included. An answered question is not withdrawn: people retract it.
+ */
+export async function withdrawQuestion(opts: WithdrawQuestionOptions): Promise<PointsWriteDocument> {
+  try {
+    return await withWriteLock(opts.cwd, { verb: "points withdraw", by: (opts.by ?? []).join(", ") || null }, opts.dryRun, () => withdrawQuestionLocked(opts));
+  } catch (err) {
+    return failure("withdraw", err);
+  }
+}
+
+async function withdrawQuestionLocked(opts: WithdrawQuestionOptions): Promise<PointsWriteDocument> {
+  try {
+    const by = [...new Set((opts.by ?? []).map((b) => b.trim()).filter((b) => b !== ""))];
+    if (by.length === 0) throw new PointsWriteError("write-usage-invalid", "--by <name> is required: who withdraws the question");
+    refuseUnidentified(scopeSource(opts.cwd), by, "--by");
+    const found = await findQuestion(opts.cwd, opts.kind, opts.id);
+    const { opened, before, target } = found;
+    const ledger = found.read.ledger;
+    const { o } = opened;
+    const d = target.data;
+    if (target.state === "answered") {
+      throw new PointsWriteError("record-closed", `${opts.id} is answered, so it is not withdrawn: people take the answer back with \`points retract ${opts.id}\``);
+    }
+    if (d.withdrawn !== undefined) throw new PointsWriteError("record-closed", `${opts.id} is withdrawn already`);
+    if (!answerFields(o.loaded.schema).withdrawn) {
+      throw new PointsWriteError("answer-field-unsupported", `the ${o.loaded.kind.name} kind's schema has no withdrawn field, so ${opts.id} can't record that it no longer applies: copy point-answer.schema.json from @intentius/chant anew`);
+    }
+    const name = String(d.point);
+    const point = pointOf(opened.points, name);
+    if (!point) throw new PointsWriteError("point-unknown", `${opts.id} asks ${name}, which ${opened.pointsFile} no longer declares`);
+    const on = opts.on ?? today();
+    const note = noteOf(opts.note);
+    const subject = Array.isArray(d.constrains) && typeof d.constrains[0] === "string" ? (d.constrains[0] as string) : undefined;
+    const asked = askedOf(d);
+    const title = titleFor(point, subject, "withdrawn", undefined, asked);
+    const data = recordData(o, { ...d, title, withdrawn: Object.fromEntries(Object.entries({ by, on, note }).filter(([, v]) => v !== undefined)) });
+    const text = renderRecord(data, body(point, title, asked));
+    const onLedger = ledger.byPath.has(target.path);
+    const message = `Decision point ${name}: withdrawn by ${by.join(", ")}${subject ? ` (${subject})` : ""}`;
+    const wrote = await write(o, before, target.path, text, false, !!opts.dryRun, { source: found.read.source, ledger, onLedger, message, who: { verb: "points withdraw", by: by.join(", ") } });
+    const entry: RecordEntry = { ...target, data, valid: true, reasons: [], warnings: wrote.warnings };
+    return {
+      $schema: POINTS_WRITE_SCHEMA_ID,
+      contract: POINTS_WRITE_CONTRACT_VERSION,
+      verb: "withdraw",
+      kind: o.view,
+      id: opts.id,
+      path: target.path,
+      reused: false,
+      written: !opts.dryRun,
+      dryRun: !!opts.dryRun,
+      question: questionView(entry, point, onLedger ? (wrote.ledger ?? ledger.byPath.get(target.path)?.ledger ?? null) : null)!,
+      ...(opts.dryRun ? { text } : {}),
+    };
+  } catch (err) {
+    return failure("withdraw", err);
+  }
+}

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

@@ -15,7 +15,7 @@ import { existsSync, readdirSync, readFileSync, rmSync, utimesSync, writeFileSyn
 import { join } from "node:path";
 import { afterAll, describe, expect, test } from "vitest";
 import { cleanScratch, commitAll, contract, declaration, declaration as declaration_, FAKE_FILE_GRAPH_CHANT, FAKE_GRAPH_CHANT, git, REPO, repo, scratchDir, validSchema } from "./__fixtures__/contract-repo";
-import type { GraphIR } from "../graph-ir";
+import type { GraphIR, IREdgeKind } from "../graph-ir";
 import { composeWorkspaceGraph, MEMBER_RUN_REASON_CODES } from "./compose-graph";
 import { parseDeclaration, WORKSPACE_ERROR_CODES } from "./declaration";
 import type { LinkTableRow } from "./links";
@@ -106,6 +106,31 @@ describe("the links section (#2539)", () => {
   });
 });
 
+describe("CI edges, pipelines and dangling references (#3922)", () => {
+  test("the edge kinds match IREdgeKind, and a composed CI member validates", () => {
+    const kinds: IREdgeKind[] = ["ref", "needs", "calls", "triggers", "includes", "extends"];
+    expect(schema.$defs.edge.properties.kind.enum).toEqual(kinds);
+    const ir: GraphIR = {
+      version: 1,
+      nodes: [
+        { id: "ci", kind: "Workflow", lexicon: "github", attrs: {} },
+        { id: "build", kind: "Job", lexicon: "github", attrs: {} },
+        { id: "deploy", kind: "Job", lexicon: "github", attrs: {} },
+      ],
+      edges: [
+        { from: "deploy", to: "build", kind: "needs", viaAttr: "needs" },
+        { from: "build", to: "ci", kind: "calls", viaAttr: "uses", crossPipeline: true },
+      ],
+      groups: { byPipeline: { ci: ["build", "ci", "deploy"] } },
+      dangling: [{ from: "deploy", kind: "needs", path: "needs", value: "lint" }, { from: "build", kind: "calls", path: "uses", value: "o/r/.github/workflows/x.yml@v1", crossPipeline: true }],
+    };
+    const m = { name: "svc", dir: "svc", kind: "chant", status: "composed" as const, reason: null, chant: "0.124.20", irVersion: 1, live: false };
+    const graph = composeWorkspaceGraph({ name: "acme", root: "." }, [{ member: m, ir }]);
+    expect(graph.dangling).toHaveLength(2);
+    expectValid({ $schema: GRAPH_OUTPUT_SCHEMA_ID, contract: 1, chant: "0.124.20", at: null, ...graph });
+  });
+});
+
 describe("the collectors section (#2559)", () => {
   const topology = {
     pipelines: [{ id: "traces", signal: "traces", receivers: ["otlp"], processors: [], exporters: ["otlphttp"] }],

package/src/workspace/graph.schema.json

@@ -93,6 +93,13 @@
             "$ref": "#/$defs/edge"
           }
         },
+        "dangling": {
+          "description": "Added in contract 1 by #3922. The members' references whose target is no node of their graph (#3910): a job `needs` a job no workflow declares, a `uses:` names another repository's workflow, a GitLab `include:` names a file chant did not generate. Each member's `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.",
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/dangling"
+          }
+        },
         "groups": {
           "type": "object",
           "required": [
@@ -158,6 +165,16 @@
                 }
               },
               "description": "Keys prefixed with the member."
+            },
+            "byPipeline": {
+              "type": "object",
+              "additionalProperties": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "description": "Added in contract 1 by #3922. CI pipeline membership (#3910): a workflow or pipeline the member's CI lexicon reports, with the node ids it runs. Keys prefixed with the member, like byStack. Edges with `crossPipeline` run between these groups."
             }
           }
         },
@@ -523,7 +540,15 @@
           "type": "string"
         },
         "kind": {
-          "type": "string"
+          "enum": [
+            "ref",
+            "needs",
+            "calls",
+            "triggers",
+            "includes",
+            "extends"
+          ],
+          "description": "`ref` for an edge from a typed reference. The CI kinds (#3910): `needs` (a job waits on another), `calls` (a reusable workflow or action is used), `triggers` (a pipeline starts another), `includes` (a file is pulled in), `extends` (a GitLab job inherits another). The list grows within contract 1; a reader ignores a kind it does not know."
         },
         "viaAttr": {
           "type": "string"
@@ -531,11 +556,53 @@
         "toAttr": {
           "type": "string"
         },
+        "crossPipeline": {
+          "type": "boolean",
+          "description": "Added in contract 1 by #3922. True when the edge leaves the pipeline `from` belongs to (#3910): a reusable-workflow call, a `workflow_run` trigger, a GitLab child or multi-project trigger, an include. Absent on every in-pipeline edge."
+        },
         "member": {
           "type": "string"
         }
       }
     },
+    "dangling": {
+      "type": "object",
+      "required": [
+        "from",
+        "kind",
+        "path",
+        "value",
+        "member"
+      ],
+      "properties": {
+        "from": {
+          "type": "string",
+          "description": "The node holding the reference, prefixed with its member."
+        },
+        "kind": {
+          "$ref": "#/$defs/edge/properties/kind"
+        },
+        "path": {
+          "type": "string",
+          "description": "Where on `from` it was written, such as `needs`, `uses` or `trigger.include`."
+        },
+        "value": {
+          "type": "string",
+          "description": "The reference exactly as written."
+        },
+        "crossPipeline": {
+          "type": "boolean",
+          "description": "As on an edge."
+        },
+        "member": {
+          "type": "string"
+        },
+        "nested": {
+          "type": "string",
+          "description": "For a member of kind `workspace`: the nested workspace's member the reference was read through, as on a node."
+        }
+      }
+    },
     "failure": {
       "description": "The declaration could not be read, and nothing was composed. Exit code 1.",
       "type": "object",

package/src/workspace/lineage-upgrade.test.ts

@@ -476,6 +476,27 @@ describe("chant workspace upgrade", () => {
     expect(isGovernancePath("src/main.ts")).toBe(false);
   });
 
+  test("the quorum counts the gates in a workspace member's Op files (#2892)", async () => {
+    const op = (overview: string): string =>
+      `export default { props: { name: "release", overview: ${JSON.stringify(overview)}, phases: [{ name: "Ship", steps: [{ kind: "gate", name: "ship", approval: { quorum: { count: 2, roles: ["maintainer"] } } }] }] } };\n`;
+    // A template whose Op lives in a member, and a project made from it.
+    release("v1.1.0", {
+      "chant.workspace.json": JSON.stringify({ name: "proj", schema: 1, members: [{ name: "delivery", dir: "delivery", kind: "chant" }] }, null, 2) + "\n",
+      "delivery/chant.config.ts": "export default {};\n",
+      "delivery/ops/release.op.ts": op("v1"),
+    });
+    proj = join(root, "members");
+    expect((await initFromCommand({ from: `${tpl}@v1.1.0`, path: proj })).error).toBeUndefined();
+    git(proj, ["init", "-q", "-b", "main"]);
+    commitProject("init from v1.1");
+    release("v2.0.0", { "delivery/ops/release.op.ts": op("v2") });
+    const port = ledger();
+    const result = await upgradeCommand({ root: proj, to: "v2.0.0", runChant: passing, ledger: port, now: "2026-09-23T10:00:00.000Z" });
+    expect(result.outcome).toBe("gated");
+    expect(result.staged!.governance).toMatchObject({ paths: ["delivery/ops/release.op.ts"], approval: { mode: "log-only", quorum: { count: 2, roles: ["maintainer"] } } });
+    expect(port.pending[0].approval).toEqual({ mode: "log-only", quorum: { count: 2, roles: ["maintainer"] } });
+  });
+
   test("refuses a scope with uncommitted changes, and a scope that does not exist", async () => {
     put(proj, "README.md", "dirty\n");
     await expect(stageUpgrade({ root: proj, to: "v1.0.0" })).rejects.toThrow(/uncommitted changes/);

package/src/workspace/lineage-upgrade.ts

@@ -571,22 +571,30 @@ export function isGovernancePath(path: string): boolean {
  * strictest gate declared at HEAD in any Op file the patch changes, at least
  * one. The Op files are read from the project's tree, which the upgrade
  * requires to match HEAD for every path the patch touches.
+ *
+ * Discovery runs from each changed Op file's own directory, so it finds the
+ * file under the project that owns it. Run from a workspace root, it would
+ * skip every member's Op files (#2892).
  */
-async function rulesAtHead(root: string, repo: string, paths: string[]): Promise<ResolvedGateApproval> {
+async function rulesAtHead(repo: string, paths: string[]): Promise<ResolvedGateApproval> {
   const opFiles = new Set(paths.filter((p) => GOVERNANCE[0].test(p)));
   let count = 1;
   let roles: string[] | undefined;
   if (opFiles.size > 0) {
     const { discoverOps } = await import("../op/discover");
-    const { ops } = await discoverOps({ cwd: root });
-    for (const { config, filePath } of ops.values()) {
-      const rel = relative(repo, filePath).split(sep).join("/");
-      if (!opFiles.has(rel)) continue;
-      for (const approval of gateApprovals(config)) {
-        const need = approval.quorum?.count ?? 1;
-        if (need > count) {
-          count = need;
-          roles = approval.quorum?.roles;
+    const dirs = new Set([...opFiles].map((p) => dirname(join(repo, p))));
+    for (const dir of dirs) {
+      if (!existsSync(dir)) continue;
+      const { ops } = await discoverOps({ cwd: dir });
+      for (const { config, filePath } of ops.values()) {
+        const rel = relative(repo, filePath).split(sep).join("/");
+        if (!opFiles.has(rel)) continue;
+        for (const approval of gateApprovals(config)) {
+          const need = approval.quorum?.count ?? 1;
+          if (need > count) {
+            count = need;
+            roles = approval.quorum?.roles;
+          }
         }
       }
     }
@@ -854,7 +862,7 @@ export async function stageUpgrade(options: UpgradeOptions): Promise<StagedUpgra
       if (touched.length > 0) {
         throw new UpgradeError(`the upgrade changes governance files that have uncommitted edits (${touched.map((l) => l.slice(3)).join(", ")}). Commit them first: their gates are read at HEAD.`);
       }
-      governance = { paths: governed, approval: await rulesAtHead(root, repo, governed), rules: head };
+      governance = { paths: governed, approval: await rulesAtHead(repo, governed), rules: head };
     }
 
     // 5. Checks.

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

@@ -97,6 +97,20 @@ describe("foldNested", () => {
   });
 });
 
+describe("foldNested with CI pipelines and dangling references (#3922)", () => {
+  test("prefixes byPipeline and dangling with the outer member, and keeps the nested member on each reference", () => {
+    const outer = composeWorkspaceGraph({ name: "outer", root: "." }, [
+      { member: member("platform", { kind: "workspace", status: "skipped", reason: { code: "kind-not-run", message: "nested" }, chant: null, irVersion: null }) },
+    ]);
+    const inner = innerGraph();
+    inner.groups.byPipeline = { "api/ci": ["api/Queue"] };
+    inner.dangling = [{ from: "api/Queue", kind: "needs", path: "needs", value: "lint", member: "api" }];
+    foldNested(outer, outer.members[0], inner);
+    expect(outer.groups.byPipeline).toEqual({ "platform/api/ci": ["platform/api/Queue"] });
+    expect(outer.dangling).toEqual([{ from: "platform/api/Queue", kind: "needs", path: "needs", value: "lint", member: "platform", nested: "api" }]);
+  });
+});
+
 describe("the outer workspace never writes inside a nested one", () => {
   let root: string;
   afterEach(() => rmSync(root, { recursive: true, force: true }));