@intentius/chant 0.84.0 → 0.86.0

package/src/workspace/records-cli.ts

@@ -8,8 +8,13 @@
  * the exit code is 0 whenever the read itself worked. Only a kind, schema or
  * revision that cannot be read exits 1.
  *
- * It needs no `chant.workspace.json`. The kind is passed explicitly, so
- * nothing is inferred (#2525 rule 1).
+ * It needs no `chant.workspace.json`. The kind is passed explicitly, or,
+ * without `--kind`, it is every record kind the declaration names (#2680), so
+ * nothing is inferred (#2525 rule 1). Several kinds print one document per
+ * kind, in the declaration's order, inside one set.
+ *
+ * With `--since <rev>` it prints what changed between two revisions instead,
+ * through `records-since.ts` (#2673).
  */
 
 import { execFileSync } from "node:child_process";
@@ -20,8 +25,26 @@ import type { CommandContext } from "../cli/registry";
 import { findWorkspaceRoot } from "../project-root";
 import { fileDigest, isWorkspacePath } from "./record-assets";
 import { gitRevisionSource, gitRoot, resolveRevision, workingTreeSource } from "./record-source";
-import { loadRecordKind, readRecords, RecordReadError, type LoadedRecordKind, type ReadErrorCode, type ReadRecordsResult, type RecordEntry, type RecordHistory } from "./records";
-import { gitTree, workingTree } from "./tree";
+import { declaredRecordKinds, readDeclaration, WorkspaceReadError, type RecordKindDeclaration } from "./declaration";
+import { declaredKindFile } from "./declared-kinds";
+import { locateWorkspace } from "./which-chant";
+import {
+  computeQuorum,
+  DEFAULT_QUORUM,
+  loadRecordKind,
+  normalisePrincipal,
+  readRecords,
+  RecordReadError,
+  type LoadedRecordKind,
+  type Quorum,
+  type ReadErrorCode,
+  type ReadRecordsResult,
+  type RecordEntry,
+  type RecordFormat,
+  type RecordHistory,
+} from "./records";
+import { gitTree, workingTree, type WorkspaceTree } from "./tree";
+import type { DecisionWork } from "./work";
 import { activeAttestors, type ProvenanceLevel } from "./trust/attestor";
 import { policyAtBase, recordProvenance, resolveBase, type BaseSource, type RecordProvenance } from "./trust/provenance";
 
@@ -31,7 +54,8 @@ export const RECORDS_CONTRACT_VERSION = 1;
 /** `$id` of the JSON Schema for the `--json` output, shipped beside this file. */
 export const RECORDS_OUTPUT_SCHEMA_ID = "https://intentius.io/chant/schemas/workspace/records/v1/records.schema.json";
 
-const USAGE = "chant workspace records --kind <kind file> [--current] [--at <rev>] [--base <rev>] [--require attested] [--json] | chant workspace records pin <path>";
+const USAGE =
+  "chant workspace records [--kind <kind file>] [--current] [--at <rev>] [--base <rev>] [--require attested] [--json] | chant workspace records [--kind <kind file>] --since <rev> [--at <rev>] [--json] | chant workspace records pin <path> | chant workspace records new|amend|review (#2670)";
 
 /** Exit code when the read worked and a record falls below `--require`. */
 export const EXIT_BELOW_REQUIRED = 2;
@@ -46,8 +70,14 @@ export interface RecordsQuery {
   cwd: string;
 }
 
-/** A record as the output carries it: the entry plus its provenance (#2547). */
-export type RecordView = RecordEntry & { provenance: RecordProvenance };
+/**
+ * A record as the output carries it: the entry plus its provenance (#2547),
+ * and its quorum when the kind has a reviews list (#2671).
+ */
+export type RecordView = RecordEntry & { provenance: RecordProvenance; quorum?: Quorum | null };
+
+/** The role in the trust policy whose holders' verdicts the quorum does not count (#2671). */
+export const AGENT_ROLE = "agent";
 
 /** Where provenance was judged from (#2547). */
 export interface TrustView {
@@ -65,7 +95,7 @@ export type RecordsDocument =
   | {
       $schema: string;
       contract: number;
-      kind: { name: string; schema: string; file: string };
+      kind: { name: string; schema: string; file: string; format: RecordFormat };
       at: string | null;
       /** The directory pinned paths resolve in, from the repository root: the workspace holding the kind file, or the repository root (#2549). */
       workspaceRoot: string;
@@ -73,9 +103,58 @@ export type RecordsDocument =
       trust: TrustView;
       records: RecordView[];
       summary: { total: number; valid: number; invalid: number; superseded: number };
+      /** For a work kind (#2683): each decision its decision kind reads, with the work records implementing it. */
+      decisions?: DecisionWork[];
     }
   | { $schema: string; contract: number; error: { code: ReadErrorCode; message: string } };
 
+/** Where a document in a {@link RecordsSetDocument} comes from: the declaration's entry for its kind (#2680). */
+export interface DeclaredKindView {
+  /** The member that declares the kind, or null for the workspace's own. */
+  member: string | null;
+  /** The kind file from the workspace root. */
+  path: string;
+  /** The name the declaration gives the kind, or null. */
+  name: string | null;
+}
+
+/**
+ * The `records` output without `--kind` when the declaration names record
+ * kinds (#2680): one {@link RecordsDocument} per kind, in the declaration's
+ * order, each with the entry that declares it.
+ */
+export interface RecordsSetDocument {
+  $schema: string;
+  contract: number;
+  kinds: (RecordsDocument & { declared: DeclaredKindView })[];
+}
+
+/**
+ * The record kinds the declaration nearest above `cwd` names, in the tree
+ * `at` reads, with each kind file on disk. Empty when there is no declaration.
+ * Throws a {@link WorkspaceReadError} for one that can't be read.
+ */
+export function declaredKindFiles(cwd: string, at?: string): { declared: RecordKindDeclaration; file: string }[] {
+  let located;
+  try {
+    located = locateWorkspace(cwd, at);
+  } catch (err) {
+    if (err instanceof WorkspaceReadError && err.code === "declaration-missing") return [];
+    throw err;
+  }
+  return declaredRecordKinds(readDeclaration(located.tree)).map((declared) => ({ declared, file: declaredKindFile(declared, located.rootOnDisk) }));
+}
+
+/** Read every declared kind in `kinds`, as {@link queryRecords} reads one. */
+export async function queryDeclaredRecords(kinds: { declared: RecordKindDeclaration; file: string }[], query: Omit<RecordsQuery, "kind">): Promise<RecordsSetDocument> {
+  const out: RecordsSetDocument["kinds"] = [];
+  for (const k of kinds) {
+    const doc = await queryRecords({ ...query, kind: k.file });
+    out.push({ ...doc, declared: { member: k.declared.member, path: k.declared.path, name: k.declared.name } });
+  }
+  return { $schema: RECORDS_OUTPUT_SCHEMA_ID, contract: RECORDS_CONTRACT_VERSION, kinds: out };
+}
+
 /** A records read, before provenance. */
 export interface RecordsRead {
   loaded: LoadedRecordKind;
@@ -86,15 +165,32 @@ export interface RecordsRead {
   at: string | null;
   /** Where pinned paths resolve, relative to `root` ("." for the root itself). */
   workspaceRoot: string;
+  /** The workspace root's tree, as read: the working tree, or the revision under `--at`. */
+  tree: WorkspaceTree;
   result: ReadRecordsResult;
 }
 
+/**
+ * The quorum the workspace declares: the declaration at the workspace root
+ * of the tree read, or the default when there is none, or when it can't be
+ * read (#2671). Records need no declaration, so neither does this.
+ */
+function declaredQuorum(tree: WorkspaceTree): { need: number; needFrom: "declaration" | "default" } {
+  try {
+    const q = readDeclaration(tree).quorum;
+    if (q !== null) return { need: q, needFrom: "declaration" };
+  } catch {
+    // No declaration, or one this read can't use: the default applies.
+  }
+  return { need: DEFAULT_QUORUM, needFrom: "default" };
+}
+
 /**
  * Where a kind's pinned paths resolve: the workspace whose declaration sits
  * nearest above the kind file, when it is inside the repository, or else the
  * repository root. Relative to `root`, with / separators.
  */
-function pinRoot(kindFile: string, root: string): string {
+export function pinRoot(kindFile: string, root: string): string {
   const found = findWorkspaceRoot(dirname(kindFile));
   if (!found) return ".";
   const rel = relative(root, realpathOr(found.dir)).split(sep).join("/");
@@ -146,14 +242,20 @@ export async function readRecordsFor(query: Omit<RecordsQuery, "base">): Promise
     assets = gitTree(top, at, workspaceRoot === "." ? "" : workspaceRoot);
   }
   const history = top ? gitHistory(top, at ?? "HEAD", workspaceRoot) : undefined;
-  const result = await readRecords(loaded, { root, source, current: !!query.current, assets, ...(history ? { history } : {}) });
-  return { loaded, root, top, at, workspaceRoot, result };
+  // A session kind's verdicts name records of another kind, read from the same tree (#2673).
+  let subjects: { records: RecordEntry[]; reviews: string } | undefined;
+  if (loaded.kind.session) {
+    const subjectKind = await loadRecordKind(resolve(dirname(loaded.file), loaded.kind.session.subjects.kind), cwd);
+    subjects = { records: (await readRecords(subjectKind, { root, source })).records, reviews: subjectKind.kind.reviews?.field ?? "reviews" };
+  }
+  const result = await readRecords(loaded, { root, source, current: !!query.current, assets, workspaceRoot, ...(history ? { history } : {}), ...(subjects ? { subjects } : {}) });
+  return { loaded, root, top, at, workspaceRoot, tree: assets, result };
 }
 
 /** Run the query and build the document `--json` prints. Never throws a {@link RecordReadError}. */
 export async function queryRecords(query: RecordsQuery): Promise<RecordsDocument> {
   try {
-    const { loaded, root, top, at, workspaceRoot, result } = await readRecordsFor(query);
+    const { loaded, root, top, at, workspaceRoot, tree, result } = await readRecordsFor(query);
     // Provenance, judged by the policy at base and never by the tree read (#2547).
     const base = top ? resolveBase(top, query.base) : { commit: null, from: null };
     const policy = top ? policyAtBase(top, base) : policyAtBase(root, base);
@@ -164,6 +266,15 @@ export async function queryRecords(query: RecordsQuery): Promise<RecordsDocument
       paths: result.records.map((r) => r.path),
       attestors: policy.active ? await activeAttestors() : [],
     });
+    // The quorum: the need from the declaration in the tree read, agents and
+    // whether verdicts need a seal from the policy at base (#2671).
+    const quorumOptions = loaded.kind.reviews
+      ? {
+          ...declaredQuorum(tree),
+          agents: new Set((policy.roles[AGENT_ROLE] ?? []).map(normalisePrincipal)),
+          attestation: policy.active,
+        }
+      : undefined;
     return {
       $schema: RECORDS_OUTPUT_SCHEMA_ID,
       contract: RECORDS_CONTRACT_VERSION,
@@ -171,13 +282,19 @@ export async function queryRecords(query: RecordsQuery): Promise<RecordsDocument
         name: loaded.kind.name,
         schema: loaded.kind.schema.id,
         file: relative(root, loaded.file).split("\\").join("/"),
+        format: loaded.kind.format,
       },
       at,
       workspaceRoot,
       current: !!query.current,
       trust: { base: base.commit, baseFrom: base.from, active: policy.active, signersPath: policy.signersPath, problems: policy.problems },
-      records: result.records.map((r) => ({ ...r, provenance: provenance.get(r.path)! })),
+      records: result.records.map((r) => ({
+        ...r,
+        provenance: provenance.get(r.path)!,
+        ...(quorumOptions ? { quorum: computeQuorum(loaded.kind, r, quorumOptions) } : {}),
+      })),
       summary: result.summary,
+      ...(result.decisions ? { decisions: result.decisions } : {}),
     };
   } catch (err) {
     if (!(err instanceof RecordReadError)) throw err;
@@ -204,6 +321,9 @@ export function pinFile(file: string, cwd: string): { path: string; sha256: stri
 
 export async function runWorkspaceRecords(ctx: CommandContext): Promise<number> {
   const { args } = ctx;
+  if (args.extraPositional === "new" || args.extraPositional === "amend" || args.extraPositional === "review") {
+    return (await import("./records-write")).runRecordsWrite(ctx);
+  }
   if (args.extraPositional === "pin") {
     if (!args.extraPositional2) {
       console.error(formatError({ message: "pin needs the path of a file", hint: USAGE }));
@@ -218,17 +338,27 @@ export async function runWorkspaceRecords(ctx: CommandContext): Promise<number>
     return 0;
   }
   if (args.extraPositional) {
-    console.error(formatError({ message: `chant workspace records takes no argument but pin (got ${args.extraPositional})`, hint: USAGE }));
-    return 1;
-  }
-  if (!args.kind) {
-    console.error(formatError({ message: "--kind <kind file> is required", hint: USAGE }));
+    console.error(formatError({ message: `chant workspace records takes no argument but pin, new, amend or review (got ${args.extraPositional})`, hint: USAGE }));
     return 1;
   }
+  if (!args.kind) return runDeclaredRecords(args);
   if (args.require !== undefined && args.require !== "attested") {
     console.error(formatError({ message: `--require takes one level, attested, not ${JSON.stringify(args.require)}`, hint: USAGE }));
     return 1;
   }
+  if (args.since !== undefined) {
+    if (args.current || args.require !== undefined || args.base !== undefined) {
+      console.error(formatError({ message: "--since compares two revisions and takes no --current, --require or --base", hint: USAGE }));
+      return 1;
+    }
+    // Loaded here, so a plain records read never loads it (#2673).
+    const { formatSince, queryRecordsSince } = await import("./records-since");
+    const since = await queryRecordsSince({ kind: args.kind, since: args.since, at: args.at, cwd: process.cwd() });
+    if (args.json) console.log(JSON.stringify(since, null, 2));
+    else if ("error" in since) console.error(formatError({ message: `${since.error.code}: ${since.error.message}`, hint: USAGE }));
+    else console.log(formatSince(since));
+    return "error" in since ? 1 : 0;
+  }
   const doc = await queryRecords({ kind: args.kind, current: args.current, at: args.at, base: args.base, cwd: process.cwd() });
   if (args.json) {
     console.log(JSON.stringify(doc, null, 2));
@@ -256,7 +386,92 @@ export async function runWorkspaceRecords(ctx: CommandContext): Promise<number>
   return 0;
 }
 
-function realpathOr(dir: string): string {
+/**
+ * `records` without `--kind` (#2680): every record kind the declaration
+ * names, or, when it names none or there is no declaration, the error it has
+ * always been. A kind whose read fails is listed with its error, the others
+ * are still read, and the exit code is 1.
+ */
+async function runDeclaredRecords(args: CommandContext["args"]): Promise<number> {
+  if (args.require !== undefined && args.require !== "attested") {
+    console.error(formatError({ message: `--require takes one level, attested, not ${JSON.stringify(args.require)}`, hint: USAGE }));
+    return 1;
+  }
+  let declared: { declared: RecordKindDeclaration; file: string }[];
+  try {
+    declared = declaredKindFiles(process.cwd(), args.at);
+  } catch (err) {
+    if (!(err instanceof WorkspaceReadError)) throw err;
+    console.error(formatError({ message: `${err.code}: ${err.describe()}; without --kind, the declaration names the record kinds`, hint: USAGE }));
+    return 1;
+  }
+  if (declared.length === 0) {
+    console.error(formatError({ message: "--kind <kind file> is required", hint: USAGE }));
+    return 1;
+  }
+  if (args.since !== undefined) return runDeclaredSince(declared, args);
+  const set = await queryDeclaredRecords(declared, { current: args.current, at: args.at, base: args.base, cwd: process.cwd() });
+  if (args.json) console.log(JSON.stringify(set, null, 2));
+  for (const doc of args.json ? [] : set.kinds) {
+    if ("error" in doc) {
+      console.error(formatError({ message: `${doc.declared.path}: ${doc.error.code}: ${doc.error.message}`, hint: USAGE }));
+      continue;
+    }
+    console.log(`${doc.declared.name ?? doc.kind.name} (${doc.declared.path})`);
+    console.log(formatRecords(doc.records, doc.summary, doc.at));
+  }
+  if (set.kinds.some((d) => "error" in d)) return 1;
+  if (args.require) {
+    const results = set.kinds.filter((d): d is Extract<typeof d, { records: unknown }> => !("error" in d));
+    const all = results.flatMap((d) => d.records);
+    const below = belowRequired(all, args.require);
+    if (below.length > 0) {
+      const inactive = results.find((d) => !d.trust.active);
+      console.error(
+        formatError({
+          message: `${below.length} of ${all.length} records are not ${args.require}: ${below
+            .slice(0, 5)
+            .map((r) => `${r.path} (${r.provenance.level})`)
+            .join(", ")}${below.length > 5 ? ", ..." : ""}`,
+          hint: inactive ? `there is no signers file (${inactive.trust.signersPath}) at base` : "run with --json to see each record's reason",
+        }),
+      );
+      return EXIT_BELOW_REQUIRED;
+    }
+  }
+  return 0;
+}
+
+/**
+ * `records --since` without `--kind` (#2680): what changed in every declared
+ * kind, one `records-since` document per kind inside one set, in the
+ * declaration's order. A kind whose read fails is listed with its error, and
+ * the exit code is 1.
+ */
+async function runDeclaredSince(declared: { declared: RecordKindDeclaration; file: string }[], args: CommandContext["args"]): Promise<number> {
+  if (args.current || args.require !== undefined || args.base !== undefined) {
+    console.error(formatError({ message: "--since compares two revisions and takes no --current, --require or --base", hint: USAGE }));
+    return 1;
+  }
+  const { formatSince, queryRecordsSince, RECORDS_SINCE_OUTPUT_SCHEMA_ID } = await import("./records-since");
+  const kinds = [];
+  for (const k of declared) {
+    const doc = await queryRecordsSince({ kind: k.file, since: args.since!, at: args.at, cwd: process.cwd() });
+    kinds.push({ ...doc, declared: { member: k.declared.member, path: k.declared.path, name: k.declared.name } });
+  }
+  if (args.json) console.log(JSON.stringify({ $schema: RECORDS_SINCE_OUTPUT_SCHEMA_ID, contract: RECORDS_CONTRACT_VERSION, kinds }, null, 2));
+  for (const doc of args.json ? [] : kinds) {
+    if ("error" in doc) {
+      console.error(formatError({ message: `${doc.declared.path}: ${doc.error.code}: ${doc.error.message}`, hint: USAGE }));
+      continue;
+    }
+    console.log(`${doc.declared.name ?? doc.kind.name} (${doc.declared.path})`);
+    console.log(formatSince(doc));
+  }
+  return kinds.some((d) => "error" in d) ? 1 : 0;
+}
+
+export function realpathOr(dir: string): string {
   try {
     return realpathSync(dir);
   } catch {
@@ -279,8 +494,20 @@ function formatRecords(records: RecordView[], summary: { total: number; valid: n
     const superseded = r.supersededBy ? `  superseded by ${r.supersededBy}` : "";
     const attested = r.provenance.level === "attested" ? `  attested by ${r.provenance.principal}` : "";
     lines.push(`${(r.id ?? "-").padEnd(idWidth)}  ${(r.state ?? "-").padEnd(stateWidth)}  ${title}${superseded}${attested}${flag}`);
+    if (r.ready !== undefined) {
+      const blocked = (r.blockedBy ?? []).map((b) => `${b.id} (${b.state ?? "unknown"})`).join(", ");
+      const implemented = (r.implements ?? []).map((d) => `${d.id} (${d.state ?? "unknown"})`).join(", ");
+      const status = [r.ready ? "ready" : blocked ? `blocked by ${blocked}` : "", implemented ? `implements ${implemented}` : ""].filter(Boolean).join("; ");
+      if (status) lines.push(`${" ".repeat(idWidth + 2)}${status}`);
+    }
     for (const reason of r.reasons) lines.push(`${" ".repeat(idWidth + 2)}${reason.code}: ${reason.message} (${r.path})`);
     for (const warning of r.warnings) lines.push(`${" ".repeat(idWidth + 2)}warning ${warning.code}: ${warning.message} (${r.path})`);
+    const q = r.quorum;
+    if (q && q.counted.length + q.notCounted.length > 0) {
+      const verdict = q.metWithObjections ? "met with objections" : q.met ? "met" : "not met";
+      const concerns = q.openConcerns.length > 0 ? `, ${q.openConcerns.length} open ${q.openConcerns.length === 1 ? "concern" : "concerns"}` : "";
+      lines.push(`${" ".repeat(idWidth + 2)}quorum ${q.agreed} of ${q.need} agreed, ${verdict}; ${q.notCounted.length} not counted${concerns}`);
+    }
   }
   lines.push(
     `${summary.total} records${at ? ` at ${at.slice(0, 8)}` : ""}: ${summary.valid} valid, ${summary.invalid} invalid, ${summary.superseded} superseded`,

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

@@ -5,13 +5,14 @@
  * doesn't exist yet, so the chant repo's own decision files stand in for it.
  */
 
-import { cpSync, mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { cpSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import Ajv2020 from "ajv/dist/2020";
 import { afterAll, describe, expect, test } from "vitest";
 import { queryRecords, RECORDS_CONTRACT_VERSION, RECORDS_OUTPUT_SCHEMA_ID, type RecordsDocument } from "./records-cli";
-import { READ_ERROR_CODES, RECORD_REASON_CODES } from "./records";
+import { READ_ERROR_CODES, RECORD_REASON_CODES, RECORD_WARNING_CODES, recordTextDigest, REVIEW_REASON_CODES } from "./records";
+import { WORK_WARNING_CODES } from "./work";
 import schema from "./records.schema.json";
 import { PROVENANCE_LEVELS } from "./trust/attestor";
 
@@ -77,6 +78,80 @@ describe("records output schema", () => {
     expect(doc.summary.invalid).toBe(2);
   });
 
+  test("a workspace-sourced decision with no evidence validates, with its warning (#2654)", async () => {
+    const root = copyDecisions();
+    const dir = join(root, "docs", "design", "decisions");
+    const text = readFileSync(join(dir, "ws-003-seal-scope.md"), "utf-8")
+      .replace(/^id: .*$/m, 'id: "ws-900"')
+      .replace(/^source:\n(?:  .*\n)*/m, 'source:\n  kind: "workspace"\n  member: "app"\n')
+      .replace(/^evidence:\n(?:  .*\n)*/m, "evidence: []\n");
+    writeFileSync(join(dir, "ws-900-extra.md"), text);
+    const doc = await queryRecords({ kind: KIND, current: true, cwd: root });
+    expectValid(doc);
+    if ("error" in doc) throw new Error(doc.error.message);
+    const r = doc.records.find((x) => x.id === "ws-900");
+    expect(r?.valid).toBe(true);
+    expect(r?.warnings?.map((w) => w.code)).toEqual(["record-no-evidence"]);
+  });
+
+  test("lists exactly the codes a verdict is not counted for (#2671)", () => {
+    expect(schema.$defs.verdict.properties.reason.properties.code.enum).toEqual([...REVIEW_REASON_CODES]);
+  });
+
+  test("every record carries its digest and quorum, and the chant repo's decisions need the default two (#2671, #2672)", async () => {
+    const doc = await queryRecords({ kind: KIND, current: true, cwd: REPO });
+    if ("error" in doc) throw new Error(doc.error.message);
+    for (const r of doc.records) {
+      expect(r.digest).toMatch(/^[0-9a-f]{64}$/);
+      expect(r.quorum).toMatchObject({ need: 2, needFrom: "default", agreed: 0, met: false, metWithObjections: false });
+    }
+  });
+
+  test("a decision with verdicts validates, with each verdict counted or not and why (#2671, #2672)", async () => {
+    const root = copyDecisions();
+    const dir = join(root, "docs", "design", "decisions");
+    writeFileSync(
+      join(root, "chant.workspace.json"),
+      JSON.stringify({ name: "w", schema: 1, quorum: 1, members: [{ name: "docs", dir: "docs", kind: "other", because: "decisions only" }] }),
+    );
+    const base = readFileSync(join(dir, "ws-003-seal-scope.md"), "utf-8").replace(/^id: .*$/m, 'id: "ws-900"');
+    const digest = recordTextDigest(base);
+    const entry = (reviewer: string, verdict: string, extra = "") => `  - reviewer: "${reviewer}"\n    verdict: "${verdict}"\n    on: "2026-09-24"${extra}`;
+    const reviews = [
+      entry("alice", "agree", `\n    digest: "${digest}"`),
+      entry("Alice ", "agree", `\n    digest: "${digest}"`),
+      entry("lex00", "agree"),
+      entry("bob", "dissent", `\n    note: "a case is missing"\n    digest: "${"0".repeat(64)}"`),
+    ];
+    writeFileSync(join(dir, "ws-900-extra.md"), base.replace(/^reviews: \[\]$/m, `reviews:\n${reviews.join("\n")}`));
+    const doc = await queryRecords({ kind: KIND, current: true, cwd: root });
+    expectValid(doc);
+    if ("error" in doc) throw new Error(doc.error.message);
+    const r = doc.records.find((x) => x.id === "ws-900")!;
+    expect(r.valid).toBe(true);
+    expect(r.digest).toBe(digest);
+    expect(r.warnings.map((w) => w.code)).toEqual(["review-undigested"]);
+    const q = r.quorum!;
+    expect(q).toMatchObject({ need: 1, needFrom: "declaration", agreed: 1, met: true, metWithObjections: true });
+    expect(q.counted.map((v) => v.reviewer)).toEqual(["Alice "]);
+    expect(q.notCounted.map((v) => [v.reviewer, v.reason?.code])).toEqual([
+      ["alice", "review-duplicate"],
+      ["lex00", "review-decider"],
+      ["bob", "review-older-digest"],
+    ]);
+    expect(q.openConcerns.map((c) => c.reviewer)).toEqual(["bob"]);
+    // A counted verdict with a reason, or a not-counted one without, is refused.
+    const bad = structuredClone(doc);
+    const record = bad.records.find((x) => x.id === "ws-900")!;
+    record.quorum!.counted[0].reason = { code: "review-duplicate", message: "x" };
+    expect(validate(bad)).toBe(false);
+  });
+
+  test("lists exactly the warning codes the code can return", () => {
+    // A work kind's records carry the work warnings too, except work-done-gap-open, which only graph --intent raises (#2683).
+    expect(schema.$defs.warning.properties.code.enum).toEqual([...RECORD_WARNING_CODES, ...WORK_WARNING_CODES.filter((c) => c !== "work-done-gap-open")]);
+  });
+
   test("every failure validates with its code", async () => {
     const root = copyDecisions();
     const docs = [