@intentius/chant 0.124.24 → 0.124.26

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/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/point-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/points-cli.ts

@@ -6,12 +6,12 @@
  * The points come from each record kind the declaration names with an
  * `answers` block, or from `--kind`, and the questions are that kind's
  * records. A question is open while it is escalated to people or proposed by a
- * model and not yet confirmed, and it lists any model's answer with its
+ * model and not yet confirmed, and not withdrawn (#2888), and it lists any model's answer with its
  * confidence, so a reader such as hud can prompt a person and an MCP client
  * can see it. With `--open`, only open questions are listed. It never writes
  * and never calls a model.
  *
- * `points ask`, `points answer` and `points retract` are the writes, in
+ * `points ask`, `points answer`, `points retract` and `points withdraw` are the writes, in
  * `decide.ts`.
  */
 
@@ -21,7 +21,7 @@ import { formatError } from "../cli/format";
 import type { CommandContext } from "../cli/registry";
 import { declaredRecordKinds, readDeclaration, readerVersion, WorkspaceReadError, type ErrorLocation, type WorkspaceErrorCode } from "./declaration";
 import { declaredKindFile } from "./declared-kinds";
-import { answerPoint, askPoint, questionView, retractAnswer, POINTS_WRITE_CONTRACT_VERSION, POINTS_WRITE_SCHEMA_ID, type PointsWriteDocument, type PointsWriteVerb, type QuestionView } from "./decide";
+import { answerPoint, askPoint, questionView, retractAnswer, withdrawQuestion, POINTS_WRITE_CONTRACT_VERSION, POINTS_WRITE_SCHEMA_ID, type PointsWriteDocument, type PointsWriteVerb, type QuestionView } from "./decide";
 import { candidates, inputOutput, pointsFileOf, pointVersion, quorumOf, readPointsThrough, type Decider, type ModelAsk, type WireAnswer } from "./points";
 import type { ReasonCode } from "./reason-codes";
 import { gitRevisionSource, workingTreeSource } from "./record-source";
@@ -107,7 +107,8 @@ export type PointsDocument =
       sources: SourceView[];
       points: PointView[];
       questions: QuestionView[];
-      summary: { points: number; questions: number; open: number; escalated: number; proposed: number; answered: number };
+      /** escalated, proposed and answered count by state, withdrawn ones included; withdrawn counts the questions withdrawn (#2888). */
+      summary: { points: number; questions: number; open: number; escalated: number; proposed: number; answered: number; withdrawn: number };
     }
   | { $schema: string; contract: number; chant: string; error: { code: WorkspaceErrorCode; message: string; location: ErrorLocation | null } };
 
@@ -197,7 +198,7 @@ export async function workspacePoints(query: PointsQuery): Promise<PointsDocumen
     sources,
     points,
     questions,
-    summary: { points: points.length, questions: questions.length, open: questions.filter((q) => q.open).length, escalated: count("escalated"), proposed: count("proposed"), answered: count("answered") },
+    summary: { points: points.length, questions: questions.length, open: questions.filter((q) => q.open).length, escalated: count("escalated"), proposed: count("proposed"), answered: count("answered"), withdrawn: questions.filter((q) => q.withdrawn !== null).length },
   };
 }
 
@@ -228,7 +229,7 @@ export function formatPoints(doc: Extract<PointsDocument, { points: unknown }>):
   lines.push("");
   for (const q of doc.questions) {
     const model = q.model && q.state !== "answered" ? `  model ${JSON.stringify(q.model.answer)} at ${q.model.confidence ?? "?"}${q.model.observed ? "" : `, below ${q.model.threshold ?? "?"}`}` : "";
-    lines.push(`${q.id}  ${q.state}  ${q.title}${model}`);
+    lines.push(`${q.id}  ${q.withdrawn ? "withdrawn" : q.state}  ${q.title}${model}`);
   }
   const n = doc.summary.questions;
   lines.push(doc.open ? `${n} open ${n === 1 ? "question" : "questions"}` : `${n} ${n === 1 ? "question" : "questions"}, ${doc.summary.open} open`);
@@ -252,6 +253,7 @@ const USAGE = [
   "chant workspace points ask <point> --inputs <file|-|json> [--candidates <file|-|json>] [--response <file>] [--subject <id>] [--kind <kind file>] [--dry-run]",
   "chant workspace points answer <id> --answer <value> --by <name> [--by <name>...] [--note <text>] [--relayed-by <principal>] [--kind <kind file>] [--resume] [--dry-run]",
   "chant workspace points retract <id> --by <name> [--by <name>...] [--note <text>] [--kind <kind file>] [--dry-run]",
+  "chant workspace points withdraw <id> --by <name> [--by <name>...] [--note <text>] [--kind <kind file>] [--dry-run]",
 ].join("\n");
 
 function usage(verb: PointsWriteVerb, message: string): PointsWriteDocument {
@@ -276,7 +278,7 @@ function readJson(verb: PointsWriteVerb, flag: string, value: string, cwd: strin
   }
 }
 
-/** `chant workspace points`, and its `ask`, `answer` and `retract` verbs. */
+/** `chant workspace points`, and its `ask`, `answer`, `retract` and `withdraw` verbs. */
 export async function runWorkspacePoints(ctx: CommandContext): Promise<number> {
   const { args } = ctx;
   const cwd = process.cwd();
@@ -324,8 +326,14 @@ export async function runWorkspacePoints(ctx: CommandContext): Promise<number> {
     if (!args.bys || args.bys.length === 0) return print(usage("retract", "--by <name> is required, once for each person who takes the answer back"));
     return print(await retractAnswer({ cwd, id, by: args.bys, note: args.note, kind: args.kind, dryRun: args.dryRun }));
   }
+  if (verb === "withdraw") {
+    const id = args.extraPositional2;
+    if (!id) return print(usage("withdraw", "withdraw needs the question's id"));
+    if (!args.bys || args.bys.length === 0) return print(usage("withdraw", "--by <name> is required: who withdraws the question"));
+    return print(await withdrawQuestion({ cwd, id, by: args.bys, note: args.note, kind: args.kind, dryRun: args.dryRun }));
+  }
   if (verb !== undefined) {
-    console.error(formatError({ message: `chant workspace points takes no argument but ask, answer or retract (got ${verb})`, hint: USAGE }));
+    console.error(formatError({ message: `chant workspace points takes no argument but ask, answer, retract or withdraw (got ${verb})`, hint: USAGE }));
     return 1;
   }
   const doc = await workspacePoints({ cwd, at: args.at, open: args.open, kind: args.kind });

package/src/workspace/points-write.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://intentius.io/chant/schemas/workspace/points-write/v1/points-write.schema.json",
   "title": "chant workspace points ask, answer and retract output",
-  "description": "What `chant workspace points ask`, `points answer` and `points retract` print (ws-058, #2739, #3351): the answer record asked for or written, as `points --json` lists a question. ask returns the record that is there when the same point, declaration and inputs were answered or proposed before (reused), and otherwise writes one: answered from a table, proposed from a model at or above its threshold, escalated to people below it. answer records people's answer to an open question once the point's quorum is met, with their note. retract takes an answer back once the quorum is met: the question is escalated to people again and the answer moves into its retractions (ws-084). Nothing is committed to the working branch, and nothing is written on a refusal or with --dry-run. In a steward's turn a new record goes on the lifecycle ledger instead of the working tree (#2786), as a commit on chant/lifecycle, and a record already held there is rewritten there. The error codes are a closed list, each in the one closed list of `reason-codes.ts`. Written at contract version 1 of the write documents.",
+  "description": "What `chant workspace points ask`, `points answer`, `points retract` and `points withdraw` print (ws-058, #2739, #3351, #2888): the answer record asked for or written, as `points --json` lists a question. ask returns the record that is there when the same point, declaration and inputs were answered or proposed before (reused), and otherwise writes one: answered from a table, proposed from a model at or above its threshold, escalated to people below it. answer records people's answer to an open question once the point's quorum is met, with their note. retract takes an answer back once the quorum is met: the question is escalated to people again and the answer moves into its retractions (ws-084). withdraw closes an open question that no longer applies, with who withdrew it, when and why; asking it again opens it again (#2888). Nothing is committed to the working branch, and nothing is written on a refusal or with --dry-run. In a steward's turn a new record goes on the lifecycle ledger instead of the working tree (#2786), as a commit on chant/lifecycle, and a record already held there is rewritten there. The error codes are a closed list, each in the one closed list of `reason-codes.ts`. Written at contract version 1 of the write documents.",
   "oneOf": [
     {
       "$ref": "#/$defs/result"
@@ -38,7 +38,8 @@
           "enum": [
             "ask",
             "answer",
-            "retract"
+            "retract",
+            "withdraw"
           ]
         },
         "kind": {
@@ -507,6 +508,38 @@
             }
           }
         },
+        "withdrawn": {
+          "type": [
+            "object",
+            "null"
+          ],
+          "description": "Who withdrew the question, when and why (points withdraw, #2888): an open question that no longer applies, such as one about a work item its author changed. A withdrawn question keeps its state and is not open. null when it was not withdrawn, and absent from a chant before it.",
+          "required": [
+            "by",
+            "on",
+            "note"
+          ],
+          "properties": {
+            "by": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "on": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "note": {
+              "type": [
+                "string",
+                "null"
+              ]
+            }
+          }
+        },
         "asked": {
           "description": "An ad-hoc point's question as its ask gave it (points ask --candidates, #3403): the question's text, and its criteria, what each candidate means, in the point's question type's shape. People's answer is one of the candidates. null for a declared point's question, and absent from a chant before it.",
           "oneOf": [
@@ -567,7 +600,8 @@
                   "answer-points-unreadable",
                   "answer-point-unknown",
                   "answer-point-changed",
-                  "record-unattested"
+                  "record-unattested",
+                  "record-ratified-below-quorum"
                 ]
               },
               "message": {
@@ -598,7 +632,8 @@
           "enum": [
             "ask",
             "answer",
-            "retract"
+            "retract",
+            "withdraw"
           ]
         },
         "error": {