@intentius/chant 0.89.0 → 0.91.0

package/src/workspace/conformance/index.ts

@@ -131,6 +131,14 @@ export interface WorkspaceReaderConformanceOptions {
   chantCommand?: string[];
   /** How long one chant run may take, in milliseconds. Default 120000. */
   timeoutMs?: number;
+  /**
+   * How the reader's chant calls reach chant (#2707). `cli`, the default,
+   * runs the command. `mcp` answers each call with the matching tool of one
+   * `chant serve mcp` session started in the workspace, and also runs the
+   * command, so the suite holds the tool's document to the command's: they
+   * must be equal. `check` has no tool and is not applicable over MCP.
+   */
+  over?: "cli" | "mcp";
 }
 
 export interface WorkspaceReaderConformanceConfig extends WorkspaceReaderConformanceOptions {
@@ -289,14 +297,151 @@ export function checkReaderRead(command: ReadContractCommand, args: string[], ca
 }
 
 /** The commands to exercise and the ones skipped, from `commands`. Throws on a name that is not a contract command. */
-export function selectCommands(commands?: readonly ReadContractCommand[]): { checked: ReadContractCommand[]; skipped: ReadContractCommand[] } {
-  if (commands === undefined) return { checked: [...READ_CONTRACT_COMMANDS], skipped: [] };
+export function selectCommands(commands?: readonly ReadContractCommand[], over: "cli" | "mcp" = "cli"): { checked: ReadContractCommand[]; skipped: ReadContractCommand[] } {
+  const served = over === "mcp" ? READ_CONTRACT_COMMANDS.filter((c) => MCP_READ_TOOLS[c] !== undefined) : [...READ_CONTRACT_COMMANDS];
+  if (commands === undefined) return { checked: served, skipped: READ_CONTRACT_COMMANDS.filter((c) => !served.includes(c)) };
   const unknown = commands.filter((c) => !(READ_CONTRACT_COMMANDS as readonly string[]).includes(c));
   if (unknown.length > 0) throw new Error(`not read-contract commands: ${unknown.join(", ")}; the commands are ${READ_CONTRACT_COMMANDS.join(", ")}`);
   if (commands.length === 0) throw new Error("commands is empty; list at least one read-contract command");
+  const toolless = commands.filter((c) => !served.includes(c));
+  if (toolless.length > 0) throw new Error(`chant serve mcp has no tool for ${toolless.join(", ")}; over MCP the commands are ${served.join(", ")}`);
   return { checked: READ_CONTRACT_COMMANDS.filter((c) => commands.includes(c)), skipped: READ_CONTRACT_COMMANDS.filter((c) => !commands.includes(c)) };
 }
 
+// ── Over MCP (#2707) ─────────────────────────────────────────────────────────
+
+/** The `chant serve mcp` tool that answers each read-contract command. `check` has none. */
+export const MCP_READ_TOOLS: Partial<Record<ReadContractCommand, string>> = {
+  ls: "workspace-ls",
+  graph: "workspace-graph",
+  status: "workspace-status",
+  records: "workspace-records",
+  "graph --intent": "workspace-graph",
+  "graph --composites": "workspace-graph",
+};
+
+/**
+ * The tool call that answers `chant <argv>`, a read-contract command with its
+ * arguments and JSON flag, or undefined when no tool does. Flags map to the
+ * tool's arguments of the same meaning; the JSON flag is dropped, since a tool
+ * always returns the document.
+ */
+export function mcpToolCall(argv: readonly string[]): { name: string; arguments: Record<string, unknown> } | undefined {
+  if (argv[0] !== "workspace") return undefined;
+  const verb = argv[1];
+  const rest = argv.slice(2);
+  const args: Record<string, unknown> = {};
+  const positional: string[] = [];
+  const kinds: string[] = [];
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    const value = (): string | undefined => rest[++i];
+    if (a === "--json") continue;
+    if (a === "--format" && rest[i + 1] === "json") {
+      i++;
+      continue;
+    }
+    if (a === "--kind") kinds.push(value() ?? "");
+    else if (a === "--at") args.at = value();
+    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 === "--current") args.current = true;
+    else if (a === "--composites") args.composites = true;
+    else if (a.startsWith("-")) return undefined;
+    else positional.push(a);
+  }
+  switch (verb) {
+    case "ls":
+      return positional.length === 0 && kinds.length === 0 ? { name: "workspace-ls", arguments: args } : undefined;
+    case "status":
+      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 "graph":
+      return positional.length === 0 ? { name: "workspace-graph", arguments: { ...args, ...(kinds.length ? { kind: kinds } : {}) } } : undefined;
+    default:
+      return undefined;
+  }
+}
+
+/** One `chant serve mcp` session over stdio: JSON-RPC lines in, one response line per request out. */
+export interface McpSession {
+  /** Call a tool and return its structured result, or reject with the error the server gave. */
+  call(name: string, args: Record<string, unknown>): Promise<unknown>;
+  close(): void;
+}
+
+/**
+ * Start `chant serve mcp` in `cwd` and initialize it as `clientInfo`. The
+ * server speaks over stdio only (ws-052): nothing here opens a port.
+ */
+export async function startMcpSession(
+  command: string[],
+  cwd: string,
+  options: { clientInfo?: { name: string; version?: string }; timeoutMs?: number } = {},
+): Promise<McpSession> {
+  const child = spawn(command[0], [...command.slice(1), "serve", "mcp"], { cwd, env: { ...process.env, NO_COLOR: "1" }, stdio: ["pipe", "pipe", "pipe"] });
+  const pending = new Map<number, { settle: (v: unknown) => void; fail: (e: Error) => void; timer: ReturnType<typeof setTimeout> }>();
+  let stderr = "";
+  let buffered = "";
+  let next = 1;
+  const failAll = (e: Error) => {
+    for (const p of pending.values()) {
+      clearTimeout(p.timer);
+      p.fail(e);
+    }
+    pending.clear();
+  };
+  child.stderr.setEncoding("utf-8").on("data", (s: string) => (stderr += s));
+  child.stdout.setEncoding("utf-8").on("data", (s: string) => {
+    buffered += s;
+    let nl: number;
+    while ((nl = buffered.indexOf("\n")) >= 0) {
+      const line = buffered.slice(0, nl).trim();
+      buffered = buffered.slice(nl + 1);
+      if (!line) continue;
+      let msg: { id?: number; result?: unknown; error?: { message: string } };
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const p = msg.id !== undefined ? pending.get(msg.id) : undefined;
+      if (!p) continue;
+      pending.delete(msg.id!);
+      clearTimeout(p.timer);
+      if (msg.error) p.fail(new Error(msg.error.message));
+      else p.settle(msg.result);
+    }
+  });
+  child.on("error", (e) => failAll(new Error(`could not start chant serve mcp: ${e.message}`)));
+  child.on("close", (code) => failAll(new Error(`chant serve mcp exited (${code})${stderr.trim() ? `: ${stderr.trim()}` : ""}`)));
+  const request = (method: string, params: Record<string, unknown>): Promise<unknown> =>
+    new Promise((settle, fail) => {
+      const id = next++;
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        fail(new Error(`chant serve mcp did not answer ${method} in time`));
+      }, options.timeoutMs ?? 120_000);
+      pending.set(id, { settle, fail, timer });
+      child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+    });
+  await request("initialize", { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: options.clientInfo ?? { name: "chant-reader-conformance" } });
+  child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })}\n`);
+  return {
+    async call(name, args) {
+      const result = (await request("tools/call", { name, arguments: args })) as { isError?: boolean; structuredContent?: unknown; content?: { text?: string }[] };
+      if (result.isError) throw new Error(result.content?.[0]?.text ?? `${name} failed`);
+      return result.structuredContent ?? JSON.parse(result.content?.[0]?.text ?? "null");
+    },
+    close() {
+      child.stdin.end();
+      child.kill();
+    },
+  };
+}
+
 const GIT_ENV = { GIT_CONFIG_GLOBAL: process.platform === "win32" ? "NUL" : "/dev/null", GIT_CONFIG_NOSYSTEM: "1" };
 
 function git(cwd: string, ...args: string[]): void {
@@ -381,14 +526,39 @@ function runChant(command: string[], argv: string[], cwd: string, timeoutMs: num
  * A transport that runs chant in the workspace `target()` names and records
  * every call and what it printed. `reset()` clears the record before a read.
  */
-export function recordingTransport(target: () => { workspaceDir: string; chantCommand: string[] }, timeoutMs = 120_000) {
+export function recordingTransport(target: () => { workspaceDir: string; chantCommand: string[] }, timeoutMs = 120_000, over: "cli" | "mcp" = "cli") {
   const calls: string[][] = [];
   const printed: ChantRun[] = [];
+  /** Over MCP: where a tool's document and the command's differ. */
+  const problems: string[] = [];
+  let session: Promise<McpSession> | undefined;
+  const viaMcp = async (argv: string[]): Promise<ChantRun> => {
+    const t = target();
+    const call = mcpToolCall(argv);
+    if (!call) return { argv: [...argv], status: null, stdout: "", stderr: `no chant serve mcp tool answers chant ${argv.join(" ")}` };
+    session ??= startMcpSession(t.chantCommand, t.workspaceDir, { timeoutMs });
+    let doc: unknown;
+    try {
+      doc = await (await session).call(call.name, call.arguments);
+    } catch (e) {
+      return { argv: [...argv], status: 1, stdout: "", stderr: `${call.name}: ${(e as Error).message}` };
+    }
+    // The command the tool stands for, run directly: the two documents must be equal.
+    const cli = await runChant(t.chantCommand, argv, t.workspaceDir, timeoutMs);
+    let printedDoc: unknown;
+    try {
+      printedDoc = JSON.parse(cli.stdout);
+    } catch {
+      printedDoc = undefined;
+    }
+    if (!isDeepStrictEqual(doc, printedDoc)) problems.push(`${argv.slice(1).join(" ")}: the MCP tool ${call.name} returned a document other than chant ${argv.join(" ")} printed`);
+    return { argv: [...argv], status: 0, stdout: JSON.stringify(doc), stderr: "" };
+  };
   const transport: ChantTransport = {
     async run(argv) {
       calls.push([...argv]);
       const t = target();
-      const run = await runChant(t.chantCommand, argv, t.workspaceDir, timeoutMs);
+      const run = over === "mcp" ? await viaMcp(argv) : await runChant(t.chantCommand, argv, t.workspaceDir, timeoutMs);
       printed.push(run);
       return run;
     },
@@ -397,9 +567,16 @@ export function recordingTransport(target: () => { workspaceDir: string; chantCo
     transport,
     calls,
     printed,
+    problems,
     reset() {
       calls.length = 0;
       printed.length = 0;
+      problems.length = 0;
+    },
+    /** Stop the MCP session, when one was started. */
+    async close() {
+      if (session) (await session.catch(() => undefined))?.close();
+      session = undefined;
     },
   };
 }
@@ -415,7 +592,7 @@ export async function readAndCheck(reader: WorkspaceReader, recorder: ReturnType
     const stderr = recorder.printed[0]?.stderr.trim();
     return { command, args, problems: [`${command}: the reader threw: ${(e as Error).message}${stderr ? `; chant's stderr: ${stderr}` : ""}`] };
   }
-  return { command, args, problems: checkReaderRead(command, args, recorder.calls, recorder.printed, doc) };
+  return { command, args, problems: [...checkReaderRead(command, args, recorder.calls, recorder.printed, doc), ...recorder.problems] };
 }
 
 /**
@@ -435,10 +612,10 @@ export async function readAndCheck(reader: WorkspaceReader, recorder: ReturnType
  * ```
  */
 export async function runWorkspaceReaderConformance(reader: WorkspaceReaderFactory, options: WorkspaceReaderConformanceOptions = {}): Promise<WorkspaceReaderConformanceReport> {
-  const { checked, skipped } = selectCommands(options.commands);
+  const { checked, skipped } = selectCommands(options.commands, options.over);
   const target = conformanceTarget(options);
+  const recorder = recordingTransport(() => target, options.timeoutMs, options.over);
   try {
-    const recorder = recordingTransport(() => target, options.timeoutMs);
     const built = reader(recorder.transport);
     const before = treeDigest(target.workspaceDir);
     const results: ReaderReadResult[] = [];
@@ -448,6 +625,7 @@ export async function runWorkspaceReaderConformance(reader: WorkspaceReaderFacto
     if (changed.length > 0) problems.push(`workspace: the reads changed files: ${changed.join(", ")}`);
     return { problems, checked, skipped, results, workspaceDir: target.workspaceDir };
   } finally {
+    await recorder.close();
     target.dispose();
   }
 }

package/src/workspace/conformance/vitest.ts

@@ -9,6 +9,7 @@
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import {
   conformanceTarget,
+  MCP_READ_TOOLS,
   READ_CONTRACT_COMMANDS,
   READ_CONTRACT_SCHEMAS,
   readAndCheck,
@@ -20,25 +21,33 @@ import {
 } from "./index";
 
 export function describeWorkspaceReaderConformance(config: WorkspaceReaderConformanceConfig): void {
-  const { checked } = selectCommands(config.commands);
+  const { checked } = selectCommands(config.commands, config.over);
   let target: ReturnType<typeof conformanceTarget> | undefined;
-  const recorder = recordingTransport(() => {
-    if (!target) throw new Error("the conformance workspace is not ready");
-    return target;
-  }, config.timeoutMs);
+  const recorder = recordingTransport(
+    () => {
+      if (!target) throw new Error("the conformance workspace is not ready");
+      return target;
+    },
+    config.timeoutMs,
+    config.over,
+  );
+  const over = config.over === "mcp" ? " over MCP (#2707)" : "";
 
-  describe(`workspace reader conformance (#2657): ${config.name}`, () => {
+  describe(`workspace reader conformance (#2657)${over}: ${config.name}`, () => {
     let before: Record<string, string> | undefined;
     const reader = config.reader(recorder.transport);
 
     beforeAll(() => {
       target = conformanceTarget(config);
     }, 300_000);
-    afterAll(() => target?.dispose());
+    afterAll(async () => {
+      await recorder.close();
+      target?.dispose();
+    });
 
     for (const command of READ_CONTRACT_COMMANDS) {
       if (!checked.includes(command)) {
-        it.skip(`${command}: not applicable, the reader does not list it in commands`, () => {});
+        it.skip(`${command}: not applicable, ${config.over === "mcp" && !MCP_READ_TOOLS[command] ? "chant serve mcp has no tool for it" : "the reader does not list it in commands"}`, () => {});
         continue;
       }
       it(

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", "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");
+  });
+});