@intentius/chant 0.90.0 → 0.93.0

package/src/workspace/checks/records.ts

@@ -14,11 +14,21 @@
  * | WSP113 | a pinned file that a superseding record pins at the old hash: the artifact did not follow the decision |
  * | WSP114 | the records of `--kind` can't be read (fixed) |
  * | WSP115 | a record kind the declaration names is missing or does not load as one (fixed, #2680) |
+ * | WSP116 | an answer kind's decision points file is missing or not valid (fixed, ws-058, #2738) |
+ * | WSP117 | a done work item has an acceptance criterion no passing evidence meets (#2772) |
+ *
+ * WSP117 reads the records of every declared work kind with acceptance
+ * criteria, in the working tree, and the records of `--kind`. It carries the
+ * reason code `work-acceptance-unmet`.
  */
 
 import type { WorkspaceCheck, WorkspaceDiagnostic } from "../checks";
+import type { ReasonCode } from "../reason-codes";
 import type { ReadErrorCode, RecordEntry } from "../records";
 
+/** The read contract's codes the record checks carry as `code`: WSP117's (#2772). */
+export const RECORD_FINDING_CODES = ["work-acceptance-unmet"] as const satisfies readonly ReasonCode[];
+
 /** The records `check --kind` read, or why they could not be read. */
 export type RecordFacts =
   | { kind: string; records: readonly (RecordEntry & { file: string })[] }
@@ -99,4 +109,66 @@ export const RECORD_CHECKS: readonly WorkspaceCheck[] = [
         }));
     },
   },
+  {
+    id: "WSP116",
+    name: "decision-points-invalid",
+    description:
+      "Every answer kind the declaration names has a decision points file that matches decision-points.schema.json: each input names a read-contract output, each table row tests declared inputs and answers a candidate, each model id is pinned, and the chain ends in its one quorum (ws-058).",
+    severity: "error",
+    configurable: false,
+    check(ctx) {
+      const out: WorkspaceDiagnostic[] = [];
+      for (const k of ctx.facts?.declaredKinds ?? []) {
+        if (!k.points) continue;
+        const where = k.declared.member === null ? "the workspace" : `member ${k.declared.member}`;
+        const finding = (message: string) => ({
+          checkId: this.id,
+          severity: this.severity,
+          message,
+          ...(k.declared.member !== null ? { entity: k.declared.member } : {}),
+          pointer: `${k.declared.pointer}/kind`,
+        });
+        for (const p of k.points.problems) out.push(finding(`${where} declares the answer kind ${k.declared.kind}, whose points file ${k.points.file} ${p.field ? `has ${p.field}, which ${p.message}` : p.message}`));
+      }
+      return out;
+    },
+  },
+  {
+    id: "WSP117",
+    name: "work-acceptance-unmet",
+    description:
+      "Every done work item meets its acceptance criteria: each has evidence that names it, passed, and has the verification the criterion expects, and a manual verdict is from someone other than the implementer (#2772).",
+    severity: "error",
+    configurable: true,
+    check(ctx) {
+      const out: WorkspaceDiagnostic[] = [];
+      const seen = new Set<string>();
+      const facts = ctx.facts?.records;
+      if (facts && !("error" in facts)) {
+        for (const r of facts.records) {
+          if (r.supersededBy !== null) continue;
+          const w = r.warnings.find((x) => x.code === "work-acceptance-unmet");
+          if (!w || seen.has(r.file)) continue;
+          seen.add(r.file);
+          out.push({ checkId: this.id, severity: this.severity, message: w.message, pointer: "", file: r.file, code: "work-acceptance-unmet" });
+        }
+      }
+      for (const k of ctx.facts?.declaredKinds ?? []) {
+        for (const a of k.acceptance ?? []) {
+          if (a.unmet === null || seen.has(a.file)) continue;
+          seen.add(a.file);
+          out.push({
+            checkId: this.id,
+            severity: this.severity,
+            message: a.unmet,
+            ...(k.declared.member !== null ? { entity: k.declared.member } : {}),
+            pointer: "",
+            file: a.file,
+            code: "work-acceptance-unmet",
+          });
+        }
+      }
+      return out;
+    },
+  },
 ];

package/src/workspace/checks.test.ts

@@ -60,6 +60,13 @@ describe("the WSP catalog", () => {
       "records-unreadable",
       // A declared record kind that doesn't load breaks every reader's default (#2680).
       "record-kind-unloadable",
+      // An answer kind's points file that isn't valid can't be asked (ws-058).
+      "decision-points-invalid",
+      // A credential in a box's files is in git (#2726).
+      "box-credential-declared",
+      // Two boxes sharing a value, or a box that only holds on one machine, is never the fix (#2727).
+      "box-isolation-collision",
+      "box-isolation-literal",
     ]);
   });
 

package/src/workspace/checks.ts

@@ -28,6 +28,12 @@
  * | WSP101 to WSP106 | generated files |
  * | WSP111 to WSP114 | records read with `--kind` (#2549) |
  * | WSP115 | the record kinds the declaration names (#2680) |
+ * | WSP116 | the decision points file of each declared answer kind (ws-058) |
+ * | WSP117 | a done work item's acceptance criteria all met (#2772) |
+ * | WSP121, WSP122 | boxes: no literal credential, every capability brokered (#2726) |
+ * | WSP123, WSP124 | box isolation: no shared port, state path or cookie, no literal machine path (#2727) |
+ * | WSP125 | boxes: a fountain Box declares the callback token fountain gives its sandbox (#2780) |
+ * | WSP131 to WSP133 | diagram artifacts: source and render exist, a recorded source hash still matches (#2764) |
  */
 
 import { realpathSync } from "node:fs";
@@ -45,6 +51,8 @@ import { gatherGeneratedFacts, GENERATED_CHECKS, type GeneratedFileFacts } from
 import { gatherLedgerFacts, LEDGER_CHECKS, type MemberLedgerFacts } from "./checks/ledgers";
 import { gatherPipelineFacts, PIPELINE_CHECKS, type MemberPipelineFacts } from "./checks/pipelines";
 import { RECORD_CHECKS, type RecordFacts } from "./checks/records";
+import { BOX_CHECKS } from "./checks/boxes";
+import { DIAGRAM_CHECKS } from "./checks/diagrams";
 import { loadDeclaredKinds, type DeclaredKind } from "./declared-kinds";
 
 /**
@@ -87,6 +95,12 @@ export interface WorkspaceDiagnostic extends PostSynthDiagnostic {
   pointer: string;
   /** An absolute path, for a finding about a file other than the declaration, such as a record (#2549). It is reported at its first line. */
   file?: string;
+  /** A path in the tree checked, relative to the workspace root, for a finding about a file there (#2726). It is reported at `line` and `column`. */
+  treeFile?: string;
+  line?: number;
+  column?: number;
+  /** The read contract's code for the finding, when it has one (#2726). */
+  code?: ReasonCode;
 }
 
 export interface WorkspaceCheck {
@@ -104,7 +118,7 @@ export interface WorkspaceCheck {
 /** A diagnostic ready for lint's reporters, with the entry it is about. */
 export interface WorkspaceFinding extends LintDiagnostic {
   entity?: string;
-  /** The read contract's reason code, for a WSP001 finding: why the declaration can't be read (#2536). */
+  /** The read contract's reason code: for a WSP001 finding, why the declaration can't be read (#2536); for a box check, its finding code (#2726). */
   code?: ReasonCode;
 }
 
@@ -307,6 +321,10 @@ export const WORKSPACE_CHECKS: readonly WorkspaceCheck[] = [
   ...GENERATED_CHECKS,
   // Records read with --kind (#2549).
   ...RECORD_CHECKS,
+  // Boxes and their brokered capabilities (#2726).
+  ...BOX_CHECKS,
+  // Diagram artifacts (#2764).
+  ...DIAGRAM_CHECKS,
 ];
 
 const BY_ID = new Map(WORKSPACE_CHECKS.map((c) => [c.id, c]));
@@ -449,7 +467,8 @@ export async function runDeclarationChecks(
   const { registry, problems } = loadKindRegistry(declaration.pins, root);
   const gathered = options.gather === false || options.tree ? {} : await gatherWorkspaceFacts(root, declaration, options);
   // The declared record kinds load from the working tree; under --at only whether each exists at the revision is checked (#2680).
-  const declaredKinds = options.gather === false ? undefined : await loadDeclaredKinds(declaration, tree, root, { load: !options.tree });
+  // A declared work kind's acceptance criteria are counted in the working tree too (#2772).
+  const declaredKinds = options.gather === false ? undefined : await loadDeclaredKinds(declaration, tree, root, { load: !options.tree, acceptance: !options.tree });
   const facts: WorkspaceFacts = { ...gathered, ...(options.records ? { records: options.records } : {}), ...(declaredKinds ? { declaredKinds } : {}) };
   const ctx: WorkspaceCheckContext = { declaration, tree, groups, kinds: registry, kindProblems: problems, facts };
   const findings = runWorkspaceChecks(ctx);
@@ -459,11 +478,16 @@ export async function runDeclarationChecks(
   const locate = (pointer: string): TextLocation => (parsed.ok ? parsed.locate(pointer) : { line: 1, column: 1 });
   const file = display(declaration.file);
   const toFinding = (d: WorkspaceDiagnostic): WorkspaceFinding => ({
-    ...(d.file !== undefined ? { file: display(relative(root, d.file).split(sep).join("/")), line: 1, column: 1 } : { file, ...locate(d.pointer) }),
+    ...(d.treeFile !== undefined
+      ? { file: display(d.treeFile), line: d.line ?? 1, column: d.column ?? 1 }
+      : d.file !== undefined
+        ? { file: display(relative(root, d.file).split(sep).join("/")), line: 1, column: 1 }
+        : { file, ...locate(d.pointer) }),
     ruleId: d.checkId,
     severity: d.severity,
     message: d.message,
     ...(d.entity !== undefined ? { entity: d.entity } : {}),
+    ...(d.code !== undefined ? { code: d.code } : {}),
   });
   const order = (a: LintDiagnostic, b: LintDiagnostic) => a.line - b.line || a.column - b.column || (a.ruleId < b.ruleId ? -1 : a.ruleId > b.ruleId ? 1 : 0);
   const diagnostics = active.map(toFinding).sort(order);

package/src/workspace/compose-graph.ts

@@ -113,6 +113,8 @@ export interface GraphRecord {
   state: string | null;
   valid: boolean;
   supersededBy: string | null;
+  /** The ids of records whose remediates link names this one (#2774). */
+  remediatedBy: string[];
 }
 
 /** Read one member's `chant graph --format ir` output, upgrading an unversioned (v1) IR in place. */

package/src/workspace/conformance/__fixture__/decisions/decision.kind.mjs

@@ -17,6 +17,9 @@ export const recordKind = {
   // Sealed once reached (#2555).
   closedStates: ["ratified", "superseded"],
   supersedes: { field: "supersedes", key: "decision" },
+  // A remediates link names a closed decision this one fixes the consequence
+  // of, without replacing it: the target's state never changes (#2774).
+  remediates: { field: "remediates", key: "decision" },
   // A supersedes link takes effect under an equal or stricter approval rule
   // (#2524 D4): from a record ranked above 0 and at least as high as the one it
   // names. A decided record supersedes a decided or proposed one, a ratified
@@ -26,9 +29,16 @@ export const recordKind = {
   pins: { field: "evidence" },
   // member:<name> and path:<path> entries are the record's links in workspace graph (#2549).
   constrains: { field: "constrains" },
+  // Workspace paths a change carrying the decision out must not touch
+  // (#2773): chant workspace check --changes reports change-out-of-scope.
+  outOfScope: { field: "out_of_scope" },
   // Verdicts, and the field naming the decider, for each record's digest and
   // quorum (#2671, #2672).
   reviews: { field: "reviews", decider: "decided_by" },
+  // records new --by and the MCP records-new tool's by name a proposal's
+  // proposer here, apart from decided_by, which stays null until the
+  // decision is decided (#2756).
+  proposedBy: { field: "proposed_by" },
   // source is where a decision came from, and says where its proposal came
   // from too: via, client, harness, model, session, turns and a transcript
   // pinned by hash (#2708).

package/src/workspace/conformance/__fixture__/decisions/decision.schema.json

@@ -116,6 +116,19 @@
         ]
       }
     },
+    "remediates": {
+      "description": "Closed decisions this one fixes the consequence of, without replacing them: each names the decision by id and may say why (#2774). The named decision's status never changes because of a remediates link; a decision still open is amended instead, never remediated. Optional: most decisions remediate nothing.",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["decision"],
+        "properties": {
+          "decision": { "$ref": "#/definitions/decisionId" },
+          "reason": { "type": ["string", "null"] }
+        }
+      }
+    },
     "evidence": {
       "description": "The research, audits, design sections and workspace files behind the decision. A public link carries a url; a file in the workspace carries a path and the hash of its bytes (#2549). May be empty when the decision cites nothing; chant workspace records then warns decision-no-evidence (#2654).",
       "type": "array",
@@ -127,6 +140,10 @@
       "description": "Who chose. A forge login. Null in state proposed or withdrawn.",
       "type": ["string", "null"]
     },
+    "proposed_by": {
+      "description": "Who proposed this decision: the name chant workspace records new --by or the MCP records-new tool's by wrote, for a decision that opened proposed (#2756). Null or absent when nobody named a proposer, or the decision opened straight into a later state. Never cleared by a later decide, ratify or supersede.",
+      "type": ["string", "null"]
+    },
     "decided_on": {
       "description": "When the choice was made, as YYYY-MM-DD. Quoted, so YAML reads it as a string.",
       "type": ["string", "null"],
@@ -218,6 +235,15 @@
         "type": "string",
         "pattern": "^([A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+#[0-9]+|[a-z][a-z0-9]{0,15}-[0-9]{3,}|member:[a-z0-9][a-z0-9-]{0,39}|path:(?!/)(?!(?:[^/]*/)*\\.{1,2}(?:/|$))(?!.*//)[^\\\\\\u0000-\\u001f]*[^/\\\\\\u0000-\\u001f])$"
       }
+    },
+    "out_of_scope": {
+      "description": "Workspace paths this decision puts out of scope (#2773): files or directories, from the workspace root, that a change carrying out the decision must not touch. chant workspace check --changes reports a change to one as change-out-of-scope while the decision is in hand, and the decision does not cover it even where its constrains would. Optional.",
+      "type": "array",
+      "items": {
+        "type": "string",
+        "pattern": "^(?!/)(?!(?:[^/]*/)*\\.{1,2}(?:/|$))(?!.*//)[^\\\\\\u0000-\\u001f]*[^/\\\\\\u0000-\\u001f]$"
+      },
+      "uniqueItems": true
     }
   },
   "allOf": [

package/src/workspace/conformance/index.ts

@@ -346,6 +346,9 @@ export function mcpToolCall(argv: readonly string[]): { name: string; arguments:
     else if (a === "--since") args.since = value();
     else if (a === "--compare-to") args.compareTo = value();
     else if (a === "--intent") args.intent = value();
+    else if (a === "--changes") args.range = value();
+    else if (a === "--work") args.work = value();
+    else if (a === "--severity") args.severity = value();
     else if (a === "--current") args.current = true;
     else if (a === "--composites") args.composites = true;
     else if (a.startsWith("-")) return undefined;
@@ -358,6 +361,8 @@ export function mcpToolCall(argv: readonly string[]): { name: string; arguments:
       return positional.length === 1 && kinds.length === 0 ? { name: "workspace-status", arguments: { ...args, env: positional[0] } } : undefined;
     case "records":
       return positional.length === 0 && kinds.length <= 1 ? { name: "workspace-records", arguments: { ...args, ...(kinds.length ? { kind: kinds[0] } : {}) } } : undefined;
+    case "check":
+      return positional.length === 0 && args.range !== undefined ? { name: "workspace-changes", arguments: { ...args, ...(kinds.length ? { kind: kinds } : {}) } } : undefined;
     case "graph":
       return positional.length === 0 ? { name: "workspace-graph", arguments: { ...args, ...(kinds.length ? { kind: kinds } : {}) } } : undefined;
     default:

package/src/workspace/decide.test.ts

@@ -0,0 +1,224 @@
+/**
+ * Answers to decision points as records (ws-058, #2739), with a stub model
+ * decider, on a workspace in a throwaway git repository: `points ask` and
+ * `points answer` as `decide.ts` runs them, `points --json` as
+ * `points-cli.ts` prints it, and WSP116 in `check`.
+ */
+
+import { cpSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+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 { answerPoint, askPoint, type PointsWriteDocument } from "./decide";
+import pointAnswerSchema from "./point-answer.schema.json";
+import { workspacePoints } from "./points-cli";
+import pointsSchema from "./points.schema.json";
+import pointsWriteSchema from "./points-write.schema.json";
+import type { ModelAsk, WireAnswer } from "./points";
+import { queryRecords } from "./records-cli";
+
+const REF = join(REPO, "reference-workspace");
+const POINTS = JSON.parse(readFileSync(join(REF, "decisions", "points.json"), "utf-8")) as { points: Record<string, unknown> };
+
+const points = {
+  points: {
+    ...POINTS.points,
+    "needs-decision": {
+      title: "Does this change need a decision",
+      question: { type: "noul", instructions: "Does the change make a choice nobody has recorded?", criteria: { true: "It needs a decision.", false: "It does not." } },
+      inputs: { commit: "the commit, as graph --intent lists it" },
+      deciders: [
+        { kind: "model", backend: "systemone", model: "jev-1.13.0", threshold: 0.8 },
+        { kind: "quorum", count: 2, roles: ["lead"] },
+      ],
+    },
+  },
+};
+
+const write = contract(pointsWriteSchema);
+const read = contract(pointsSchema);
+
+let root: string;
+const on = "2026-09-25";
+
+/** A stub model decider answering every point with `answer`, at the pinned model. */
+const stub =
+  (answer: WireAnswer): ModelAsk =>
+  async (req) => ({ model: req.model, answer });
+
+const big = { "work-item.criteria": 9, "work-item.fits_small": false, "work-item.fits_medium": false };
+const confident: WireAnswer = { type: "choice", choice: "large", probabilities: { small: 0.01, medium: 0.07, large: 0.92 }, confidence: 0.88 };
+const unsure: WireAnswer = { type: "choice", choice: "medium", probabilities: { small: 0.2, medium: 0.45, large: 0.35 }, confidence: 0.175 };
+
+function ok(doc: PointsWriteDocument): Extract<PointsWriteDocument, { question: unknown }> {
+  write.expectValid(doc);
+  if ("error" in doc) throw new Error(`${doc.error.code}: ${doc.error.message}`);
+  return doc;
+}
+
+function refused(doc: PointsWriteDocument): string {
+  write.expectValid(doc);
+  if (!("error" in doc)) throw new Error("expected a refusal");
+  return doc.error.code;
+}
+
+const answers = () => readdirSync(join(root, "answers")).filter((f) => f.endsWith(".md")).sort();
+const fm = (path: string) => readFileSync(join(root, path), "utf-8");
+
+beforeAll(() => {
+  root = repo(
+    {
+      "chant.workspace.json": JSON.stringify(
+        { name: "studio", schema: 1, members: [{ name: "app", dir: "app", kind: "other", because: "a plain Node server" }], records: [{ kind: "answers/answer.kind.mjs" }] },
+        null,
+        2,
+      ),
+      "app/server.mjs": "export const port = 8080;\n",
+      "decisions/points.json": JSON.stringify(points, null, 2),
+      ".chant/trust.json": JSON.stringify({ schema: 1, roles: { agent: ["bot"], lead: ["alice", "bob", "bot"] } }),
+    },
+    false,
+  );
+  cpSync(join(REF, "answers", "answer.kind.mjs"), join(root, "answers", "answer.kind.mjs"), { recursive: true });
+  cpSync(join(REF, "answers", "answer.schema.json"), join(root, "answers", "answer.schema.json"));
+  commitAll(root, "c0");
+});
+
+afterAll(cleanScratch);
+
+describe("points ask (#2739)", () => {
+  test("a table's answer is answered at once", async () => {
+    const doc = ok(await askPoint({ cwd: root, point: "slice-tier", inputs: { "work-item.fits_small": true }, subject: "W-001", on }));
+    expect(doc.question).toMatchObject({ state: "answered", open: false, answer: "small", decider: { kind: "table", row: 0 }, subject: "W-001", answeredOn: on, model: null });
+    expect(doc.written).toBe(true);
+  });
+
+  test("a model answer at or above its threshold is written as proposed, with its values and source", async () => {
+    const doc = ok(await askPoint({ cwd: root, point: "slice-tier", inputs: big, subject: "W-002", ask: stub(confident), on }));
+    expect(doc.question).toMatchObject({
+      state: "proposed",
+      open: true,
+      answer: "large",
+      decider: { kind: "model", backend: "systemone", model: "bosun-v3.1-1.7b" },
+      probabilities: { small: 0.01, medium: 0.07, large: 0.92 },
+      confidence: 0.88,
+      threshold: 0.8,
+      model: { answer: "large", confidence: 0.88, threshold: 0.8, observed: true },
+      escalations: [{ kind: "table", reason: "no row matches these inputs" }],
+    });
+    expect(doc.id).toBe(`slice-tier-${doc.question.inputsHash.slice(0, 12)}`);
+    expect(fm(doc.path)).toContain('source:\n  via: "cli"\n  model: "bosun-v3.1-1.7b"');
+    const records = await queryRecords({ kind: "answers/answer.kind.mjs", cwd: root });
+    if ("error" in records) throw new Error(records.error.message);
+    expect(records.records.find((r) => r.id === doc.id)).toMatchObject({ valid: true, state: "proposed", warnings: [] });
+  });
+
+  test("asking again with the same inputs returns the existing record", async () => {
+    const before = answers();
+    const first = ok(await askPoint({ cwd: root, point: "slice-tier", inputs: big, subject: "W-002", ask: stub(unsure), on }));
+    // Key order does not matter: the inputs hash over canonical JSON.
+    const again = ok(await askPoint({ cwd: root, point: "slice-tier", inputs: Object.fromEntries(Object.entries(big).reverse()), ask: stub(unsure) }));
+    for (const d of [first, again]) expect(d).toMatchObject({ reused: true, written: false, question: { state: "proposed", answer: "large" } });
+    expect(answers()).toEqual(before);
+  });
+
+  test("below its threshold the question is escalated and listed as open for a quorum, with the model's answer", async () => {
+    const doc = ok(await askPoint({ cwd: root, point: "slice-tier", inputs: { ...big, "work-item.criteria": 12 }, subject: "W-003", ask: stub(unsure), on }));
+    expect(doc.question).toMatchObject({ state: "escalated", open: true, answer: null, decider: { kind: "quorum", count: 1 } });
+    expect(fm(doc.path)).not.toMatch(/^answer:/m);
+    const listed = await workspacePoints({ cwd: root, open: true });
+    read.expectValid(listed);
+    if ("error" in listed) throw new Error(listed.error.message);
+    const q = listed.questions.find((x) => x.id === doc.id)!;
+    expect(q).toMatchObject({ state: "escalated", open: true, current: true, model: { answer: "medium", confidence: 0.175, threshold: 0.8, model: "bosun-v3.1-1.7b", observed: false } });
+    expect(q.escalations.map((e) => e.reason)).toEqual(["no row matches these inputs", "not observed: confidence 0.175 is below the threshold 0.8"]);
+    expect(listed.questions.every((x) => x.open)).toBe(true);
+    expect(listed.points.map((p) => p.name)).toEqual(["slice-tier", "ship-skip", "finding-triage", "needs-a-decision", "needs-decision"]);
+    expect(listed.points[0].inputs[0]).toEqual({ name: "work-item.criteria", output: "work-item", description: "acceptance criteria in the work item" });
+
+    // A later ask still escalating keeps the standing record; one a model answers rewrites it, as proposed.
+    const still = ok(await askPoint({ cwd: root, point: "slice-tier", inputs: { ...big, "work-item.criteria": 12 } }));
+    expect(still).toMatchObject({ reused: true, question: { state: "escalated" } });
+    const now = ok(await askPoint({ cwd: root, point: "slice-tier", inputs: { ...big, "work-item.criteria": 12 }, ask: stub(confident), on }));
+    expect(now).toMatchObject({ id: doc.id, path: doc.path, reused: false, question: { state: "proposed", subject: "W-003", answer: "large" } });
+  });
+
+  test("with --dry-run nothing is written, and the text is returned", async () => {
+    const before = answers();
+    const doc = ok(await askPoint({ cwd: root, point: "ship-skip", inputs: { "release.units": 3 }, dryRun: true, on }));
+    expect(doc).toMatchObject({ written: false, dryRun: true, question: { state: "answered", answer: false } });
+    expect((doc as { text?: string }).text).toContain("answer: false");
+    expect(answers()).toEqual(before);
+  });
+
+  test("refusals: an unknown point, undeclared inputs, a closed-failing backend", async () => {
+    expect(refused(await askPoint({ cwd: root, point: "nope", inputs: {} }))).toBe("point-unknown");
+    expect(refused(await askPoint({ cwd: root, point: "slice-tier", inputs: { "contract.size": 3 } }))).toBe("point-inputs-invalid");
+    expect(refused(await askPoint({ cwd: root, point: "slice-tier", inputs: [] }))).toBe("point-inputs-invalid");
+  });
+});
+
+describe("points answer (#2739)", () => {
+  test("a person confirms a model's proposal, which keeps the model as its decider", async () => {
+    const asked = ok(await askPoint({ cwd: root, point: "slice-tier", inputs: big, ask: stub(confident) }));
+    const doc = ok(await answerPoint({ cwd: root, id: asked.id, answer: "large", by: ["alice"], on }));
+    expect(doc.question).toMatchObject({ state: "answered", open: false, answer: "large", decider: { kind: "model", model: "bosun-v3.1-1.7b" }, confidence: 0.88, answeredBy: ["alice"], answeredOn: on });
+    expect(refused(await answerPoint({ cwd: root, id: asked.id, answer: "small", by: ["alice"] }))).toBe("record-closed");
+    // Asking again returns the confirmed answer.
+    expect(ok(await askPoint({ cwd: root, point: "slice-tier", inputs: big, ask: stub(unsure) }))).toMatchObject({ reused: true, question: { state: "answered" } });
+  });
+
+  test("people answering otherwise is the quorum's answer, and the proposal moves into the escalations", async () => {
+    const asked = ok(await askPoint({ cwd: root, point: "slice-tier", inputs: { ...big, "work-item.criteria": 4 }, ask: stub(confident), on }));
+    expect(refused(await answerPoint({ cwd: root, id: asked.id, answer: "tiny", by: ["alice"] }))).toBe("answer-not-candidate");
+    const doc = ok(await answerPoint({ cwd: root, id: asked.id, answer: "medium", by: ["bob"], on }));
+    expect(doc.question).toMatchObject({ state: "answered", answer: "medium", decider: { kind: "quorum", count: 1, by: ["bob"] }, probabilities: null, confidence: null });
+    expect(doc.question.escalations.at(-1)).toMatchObject({ kind: "model", answer: "large", confidence: 0.88, reason: "proposed large, and people answered medium" });
+  });
+
+  test("the quorum counts distinct people holding its roles, never an agent", async () => {
+    const asked = ok(await askPoint({ cwd: root, point: "needs-decision", inputs: { commit: { sha: "abc" } }, ask: stub({ type: "noul", noul: 0.55 }), on }));
+    expect(asked.question).toMatchObject({ state: "escalated", model: { answer: true, confidence: 0.55, observed: false } });
+    expect(refused(await answerPoint({ cwd: root, id: asked.id, answer: "yes", by: ["alice", "Alice ", "bot", "carol"] }))).toBe("quorum-not-met");
+    const doc = ok(await answerPoint({ cwd: root, id: asked.id, answer: "yes", by: ["alice", "bob"], on }));
+    expect(doc.question).toMatchObject({ state: "answered", answer: true, decider: { kind: "quorum", count: 2, roles: ["lead"], by: ["alice", "bob"] } });
+  });
+
+  test("an unknown id is refused", async () => {
+    expect(refused(await answerPoint({ cwd: root, id: "slice-tier-000000000000", answer: "small", by: ["alice"] }))).toBe("record-not-found");
+  });
+
+  test("every record written follows point-answer.schema.json, and the reference workspace carries a copy of it", () => {
+    expect(JSON.parse(readFileSync(join(REF, "answers", "answer.schema.json"), "utf-8"))).toEqual(pointAnswerSchema);
+    expect(answers().length).toBeGreaterThan(3);
+  });
+});
+
+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");
+    const changed = JSON.parse(readFileSync(file, "utf-8"));
+    changed.points["slice-tier"].title = "Which builder builds this work item";
+    writeFileSync(file, JSON.stringify(changed, null, 2));
+    const doc = await workspacePoints({ cwd: root });
+    read.expectValid(doc);
+    if ("error" in doc) throw new Error(doc.error.message);
+    const slice = doc.questions.filter((q) => q.point === "slice-tier");
+    expect(slice.every((q) => q.current === false && q.warnings.some((w) => w.code === "answer-point-changed"))).toBe(true);
+    expect((await runDeclarationChecks(root)).diagnostics.filter((d) => d.ruleId === "WSP116")).toEqual([]);
+
+    changed.points["slice-tier"].deciders.pop();
+    writeFileSync(file, JSON.stringify(changed, null, 2));
+    const report = await runDeclarationChecks(root);
+    expect(report.diagnostics.filter((d) => d.ruleId === "WSP116").map((d) => d.message)).toEqual([
+      "the workspace declares the answer kind answers/answer.kind.mjs, whose points file decisions/points.json has points.slice-tier.deciders, which must end in a quorum: when no table row or model answers, people do",
+    ]);
+    expect(report.ok).toBe(false);
+    const broken = await workspacePoints({ cwd: root });
+    read.expectValid(broken);
+    if ("error" in broken) throw new Error(broken.error.message);
+    expect(broken.sources[0].reason?.code).toBe("points-invalid");
+    expect(refused(await askPoint({ cwd: root, point: "slice-tier", inputs: big }))).toBe("points-invalid");
+  });
+});