@intentius/chant 0.91.0 → 0.94.0

package/src/workspace/declaration.ts

@@ -96,6 +96,17 @@ export interface Suppression {
 /** What `checks` may set a declaration check's severity to. */
 export type CheckSeverity = "error" | "warning" | "info" | "off";
 
+/** How `chant workspace check --changes` treats its findings (#2773): not at all, as warnings, or as failures. */
+export type ChangeSeverity = "off" | "warn" | "fail";
+
+/** The declaration's `changes` block (#2773): the severity of the forward coverage check, and the paths it never reports. */
+export interface ChangesPolicy {
+  /** Absent from the declaration, `warn`. */
+  severity: ChangeSeverity;
+  /** Globs over files, relative to the workspace root, whose changes need no record: lockfiles, generated output. */
+  ignore: string[];
+}
+
 export interface MemberRole {
   name: string;
   /** Relative to the member's directory, or null for the whole member. */
@@ -128,6 +139,40 @@ export interface LinkDeclaration {
   pointer: string;
 }
 
+/** A renderer a diagram is pinned to (#2764): a closed list of tools chant does not run. */
+export const DIAGRAM_TOOLS = ["d2", "mermaid", "graphviz"] as const;
+export type DiagramTool = (typeof DIAGRAM_TOOLS)[number];
+
+/** The renderer a diagram's render was made with (#2764). chant never runs it; it is recorded so a reader can. */
+export interface DiagramRenderer {
+  tool: DiagramTool;
+  /** The exact release the render was made with, such as "0.9.0". */
+  version: string;
+  /** Passed before the input and output paths, in order. */
+  args: string[];
+}
+
+/**
+ * A diagram artifact the declaration names (#2764): the workspace's own, in
+ * the top-level `diagrams`, or a member's, in that member's `diagrams`. A
+ * name is given once across the declaration, like a record kind's.
+ */
+export interface DiagramDeclaration {
+  name: string;
+  title: string;
+  /** From the workspace root, with / separators. Null for an SVG with no source. */
+  source: string | null;
+  /** From the workspace root, with / separators. */
+  render: string;
+  renderer: DiagramRenderer;
+  /** sha256 hex of the source's bytes when the render was last produced, for `chant workspace check`'s drift finding. Null when not recorded, or when source is null: the render is then never checked for drift. */
+  sourceHash: string | null;
+  /** The member that declares it, or null for the workspace's own. */
+  member: string | null;
+  /** The entry's JSON Pointer in the file, for messages. */
+  pointer: string;
+}
+
 /**
  * A record kind the declaration names (#2680): the workspace's own, in the
  * top-level `records`, or a member's, in that member's `records`.
@@ -165,6 +210,12 @@ export interface BoxDeclaration {
   capabilities: BoxCapability[];
   /** The host and slot of the box's isolation, or null when the block declares none (#2727). The values are derived in `boxes.ts`. */
   isolation: BoxIsolationDeclaration | null;
+  /**
+   * The id of the decision record that says what the box is for, or null when
+   * the block names none (#2850). A box starts as a question: the record is
+   * proposed with no choice until the person who answers it decides it.
+   */
+  intent: string | null;
   /** The block's JSON Pointer in the file, for messages. */
   pointer: string;
 }
@@ -208,6 +259,8 @@ export interface Member {
   links: LinkDeclaration[];
   /** The record kinds this member declares, in file order (#2680). */
   records: RecordKindDeclaration[];
+  /** The diagram artifacts this member declares, in file order (#2764). */
+  diagrams: DiagramDeclaration[];
   /** The member's box block, or null when it declares none (#2726). */
   box: BoxDeclaration | null;
   upstream: string | null;
@@ -252,8 +305,12 @@ export interface Declaration {
   quorum: number | null;
   /** The workspace's own record kinds, from the top-level `records`, in file order (#2680). A member's are on the member. */
   records: RecordKindDeclaration[];
+  /** The workspace's own diagram artifacts, from the top-level `diagrams`, in file order (#2764). A member's are on the member. */
+  diagrams: DiagramDeclaration[];
   /** The hosts boxes run on, in file order (#2727). */
   hosts: Host[];
+  /** The forward coverage check's policy (#2773), or null when the declaration has no `changes` block. */
+  changes: ChangesPolicy | null;
   /** The file, relative to the workspace root's tree (`chant.workspace.json` or `.jsonc`). */
   file: string;
 }
@@ -466,6 +523,7 @@ export function parseDeclaration(text: string, file: string, reader: string = re
       pointer: `${pointer}/links/${j}`,
     }));
     const records = recordKindsOf(e.records, e.dir as string, e.name as string, `${pointer}/records`);
+    const diagrams = diagramsOf(e.diagrams, e.name as string, `${pointer}/diagrams`);
     const box = boxOf(e.box, `${pointer}/box`);
     return {
       type: "member",
@@ -477,6 +535,7 @@ export function parseDeclaration(text: string, file: string, reader: string = re
       outputs: e.outputs === undefined ? null : [...(e.outputs as string[])],
       links,
       records,
+      diagrams,
       box,
       upstream: (e.upstream as string | undefined) ?? null,
       because: (e.because as string | undefined) ?? null,
@@ -572,6 +631,17 @@ export function parseDeclaration(text: string, file: string, reader: string = re
     }
   }
 
+  // A diagram name is given once across the declaration (#2764): a reader keys diagrams by name.
+  const ownDiagrams = diagramsOf(obj.diagrams, null, "/diagrams");
+  const byDiagramName = new Map<string, DiagramDeclaration>();
+  for (const d of [...ownDiagrams, ...members.flatMap((m) => m.diagrams)]) {
+    const first = byDiagramName.get(d.name);
+    if (first) {
+      throw new WorkspaceReadError("declaration-invalid", `the diagram name ${JSON.stringify(d.name)} is already used by the diagram at ${first.pointer}`, at(`${d.pointer}/name`));
+    }
+    byDiagramName.set(d.name, d);
+  }
+
   const hosts = hostsOf(obj, members, at);
 
   const pins = ((obj.pins as Record<string, string>[] | undefined) ?? []).map((p) => ({
@@ -592,11 +662,19 @@ export function parseDeclaration(text: string, file: string, reader: string = re
     checks: { ...((obj.checks as Record<string, CheckSeverity> | undefined) ?? {}) },
     quorum: typeof obj.quorum === "number" ? obj.quorum : null,
     records: ownRecords,
+    diagrams: ownDiagrams,
     hosts,
+    changes: changesOf(obj.changes as Record<string, unknown> | undefined),
     file,
   };
 }
 
+/** The `changes` block, already validated, with its defaults (#2773). */
+function changesOf(block: Record<string, unknown> | undefined): ChangesPolicy | null {
+  if (block === undefined) return null;
+  return { severity: (block.severity as ChangeSeverity | undefined) ?? "warn", ignore: [...((block.ignore as string[] | undefined) ?? [])] };
+}
+
 /** The `records` list at `pointer`, already validated, with each kind file's path from the workspace root. */
 function recordKindsOf(raw: unknown, dir: string, member: string | null, pointer: string): RecordKindDeclaration[] {
   return ((raw as { kind: string; name?: string }[] | undefined) ?? []).map((r, i) => ({
@@ -608,6 +686,29 @@ function recordKindsOf(raw: unknown, dir: string, member: string | null, pointer
   }));
 }
 
+/**
+ * The `diagrams` list at `pointer`, already validated. `source` and `render`
+ * are workspace-root-relative as written: unlike a generated file or a
+ * record kind, a diagram's files need not sit inside the declaring member's
+ * directory, so there is no member-relative form to resolve (#2764).
+ */
+function diagramsOf(raw: unknown, member: string | null, pointer: string): DiagramDeclaration[] {
+  return (
+    (raw as
+      | { name: string; title: string; source?: string | null; render: string; renderer: { tool: DiagramTool; version: string; args?: string[] }; sourceHash?: string | null }[]
+      | undefined) ?? []
+  ).map((d, i) => ({
+    name: d.name,
+    title: d.title,
+    source: d.source ?? null,
+    render: d.render,
+    renderer: { tool: d.renderer.tool, version: d.renderer.version, args: [...(d.renderer.args ?? [])] },
+    sourceHash: d.sourceHash ?? null,
+    member,
+    pointer: `${pointer}/${i}`,
+  }));
+}
+
 /** The `box` block at `pointer`, already validated, or null when there is none (#2726, #2727). */
 function boxOf(raw: unknown, pointer: string): BoxDeclaration | null {
   if (raw === undefined) return null;
@@ -618,6 +719,7 @@ function boxOf(raw: unknown, pointer: string): BoxDeclaration | null {
     ports?: Record<string, number>;
     state?: Record<string, string>;
     cookies?: string[];
+    intent?: string;
   };
   return {
     capabilities: (b.capabilities ?? []).map((c, i) => ({ name: c.name, broker: c.broker ?? null, scope: [...(c.scope ?? [])], pointer: `${pointer}/capabilities/${i}` })),
@@ -626,6 +728,7 @@ function boxOf(raw: unknown, pointer: string): BoxDeclaration | null {
       b.host === undefined
         ? null
         : { host: b.host, slot: b.slot!, ports: { ...(b.ports ?? {}) }, state: { ...(b.state ?? {}) }, cookies: [...(b.cookies ?? [])] },
+    intent: b.intent ?? null,
     pointer,
   };
 }
@@ -687,6 +790,15 @@ export function declaredRecordKinds(declaration: Declaration): RecordKindDeclara
   return [...declaration.records, ...declaration.members.flatMap((m) => m.records)];
 }
 
+/**
+ * Every diagram artifact the declaration names (#2764), in the order readers
+ * use them: the workspace's own first, then each member's, members in file
+ * order and each list in its own order.
+ */
+export function declaredDiagrams(declaration: Declaration): DiagramDeclaration[] {
+  return [...declaration.diagrams, ...declaration.members.flatMap((m) => m.diagrams)];
+}
+
 /** Whether `path` is `dir` or sits under it. Both are tree-relative; `"."` is the root. */
 export function isInside(path: string, dir: string): boolean {
   if (dir === ".") return true;

package/src/workspace/declared-kinds.test.ts

@@ -111,20 +111,20 @@ describe("workspace ls lists the declared kinds (#2680)", () => {
     ]);
     const doc = result(await listWorkspaceWithKinds({ cwd: root }));
     expect(doc.contract).toBe(1);
-    expect(doc.workspace.records).toEqual([{ name: "decision", path: "decisions/decision.kind.mjs", kind: "decision", reason: null }]);
+    expect(doc.workspace.records).toEqual([{ name: "decision", path: "decisions/decision.kind.mjs", kind: "decision", reason: null, acceptance: null }]);
     const design = doc.members.find((m) => m.name === "design")!;
     expect(design.readable).toBe(true);
     expect(design.records).toEqual([
-      { name: "notes", path: "design/notes/note.kind.mjs", kind: "note", reason: null },
-      { name: null, path: "design/gone.kind.mjs", kind: null, reason: { code: "kind-unreadable", message: "kind file design/gone.kind.mjs does not exist" } },
-      { name: null, path: "design/broken.kind.mjs", kind: null, reason: { code: "kind-invalid", message: "kind file design/broken.kind.mjs is not a record kind: it has no recordKind export" } },
+      { name: "notes", path: "design/notes/note.kind.mjs", kind: "note", reason: null, acceptance: null },
+      { name: null, path: "design/gone.kind.mjs", kind: null, reason: { code: "kind-unreadable", message: "kind file design/gone.kind.mjs does not exist" }, acceptance: null },
+      { name: null, path: "design/broken.kind.mjs", kind: null, reason: { code: "kind-invalid", message: "kind file design/broken.kind.mjs is not a record kind: it has no recordKind export" }, acceptance: null },
     ]);
     expect(doc.members.find((m) => m.name === "app")!.records).toEqual([]);
   });
 
   test("listWorkspace lists them unloaded, and a workspace that names none lists empty arrays", async () => {
     const doc = result(listWorkspace({ cwd: workspace() }));
-    expect(doc.workspace.records).toEqual([{ name: null, path: "decisions/decision.kind.mjs", kind: null, reason: null }]);
+    expect(doc.workspace.records).toEqual([{ name: null, path: "decisions/decision.kind.mjs", kind: null, reason: null, acceptance: null }]);
     const none = result(await listWorkspaceWithKinds({ cwd: repo({ "chant.workspace.json": decl(members()), "app/x": "", "design/x": "" }) }));
     expect(none.workspace.records).toEqual([]);
     expect(none.members.map((m) => m.records)).toEqual([[], []]);
@@ -242,6 +242,32 @@ describe("records without --kind reads every declared kind (#2680)", () => {
     expect(await run(workspace(), "--current")).toBe(0);
     expect(out.filter((l) => l.includes("("))).toEqual(["decision (decisions/decision.kind.mjs)", "notes (design/notes/note.kind.mjs)"]);
   });
+
+  test("--at an unknown revision with --json prints the error document, not just text on stderr (#2860)", async () => {
+    const root = workspace();
+    expect(await run(root, "--at", "refs/heads/no-such-branch", "--json")).toBe(1);
+    expect(err).toEqual([]);
+    const printed = JSON.parse(out.join("\n"));
+    expectValid(printed);
+    expect(printed).toEqual({
+      $schema: recordsSchema.$id,
+      contract: 1,
+      error: { code: "revision-unknown", message: expect.stringContaining("refs/heads/no-such-branch") as unknown as string },
+    });
+
+    out.length = 0;
+    err.length = 0;
+    expect(await run(root, "--at", "refs/heads/no-such-branch")).toBe(1);
+    expect(out).toEqual([]);
+    expect(err.join("\n")).toContain("revision-unknown");
+  });
+
+  test("a declaration-level code the records schema doesn't carry, such as declaration-invalid, stays text-only even with --json (#2860)", async () => {
+    const root = repo({ "chant.workspace.json": decl(members(), { records: [{ kind: "a.kind.mjs", file: "b" }] }), "app/x": "", "design/x": "" });
+    expect(await run(root, "--json")).toBe(1);
+    expect(out).toEqual([]);
+    expect(err.join("\n")).toContain("declaration-invalid");
+  });
 });
 
 describe("records new, amend and review without --kind (#2680)", () => {

package/src/workspace/declared-kinds.ts

@@ -36,6 +36,25 @@ export interface DeclaredKind {
    * other kind, and when the kind wasn't loaded.
    */
   points?: { file: string; problems: { field: string | null; message: string }[] };
+  /**
+   * For a work kind with acceptance criteria (#2772), read with
+   * `acceptance: true`: each current record that lists criteria, with how
+   * many are met. Absent for any other kind, when the kind wasn't loaded,
+   * and when its records can't be read (`records` reports why).
+   */
+  acceptance?: DeclaredAcceptance[];
+}
+
+/** One work record's acceptance criteria, counted, as `ls`, `status` and `check` read them (#2772). */
+export interface DeclaredAcceptance {
+  item: string;
+  state: string | null;
+  met: number;
+  total: number;
+  /** The record file on disk, absolute. */
+  file: string;
+  /** The record's `work-acceptance-unmet` warning, when it is done with a criterion unmet; null otherwise. */
+  unmet: string | null;
 }
 
 /** The kind file of `declared` on disk, under the workspace root `rootOnDisk`. */
@@ -53,7 +72,7 @@ export async function loadDeclaredKinds(
   declaration: Declaration,
   tree: WorkspaceTree,
   rootOnDisk: string,
-  options: { load?: boolean } = {},
+  options: { load?: boolean; acceptance?: boolean; at?: string } = {},
 ): Promise<DeclaredKind[]> {
   const declared = declaredRecordKinds(declaration);
   if (declared.length === 0) return [];
@@ -73,6 +92,10 @@ export async function loadDeclaredKinds(
       const loaded = await records.loadRecordKind(file);
       const entry: DeclaredKind = { declared: d, file, kind: loaded.kind.name, reason: null };
       if (loaded.kind.answers) entry.points = await checkPoints(resolve(dirname(file), loaded.kind.answers.points), rootOnDisk, tree);
+      if (loaded.kind.work?.acceptance && options.acceptance) {
+        const counted = await countAcceptance(file, rootOnDisk, options.at);
+        if (counted) entry.acceptance = counted;
+      }
       out.push(entry);
     } catch (err) {
       if (!(err instanceof records.RecordReadError)) throw err;
@@ -83,6 +106,28 @@ export async function loadDeclaredKinds(
   return out;
 }
 
+/** The acceptance counts of a work kind's current records, or undefined when they can't be read. */
+async function countAcceptance(file: string, rootOnDisk: string, at: string | undefined): Promise<DeclaredAcceptance[] | undefined> {
+  const { readRecordsFor } = await import("./records-cli");
+  const { RecordReadError } = await import("./records");
+  try {
+    const read = await readRecordsFor({ kind: file, cwd: rootOnDisk, current: true, ...(at !== undefined ? { at } : {}) });
+    return read.result.records
+      .filter((r): r is typeof r & { id: string; acceptance: NonNullable<typeof r.acceptance> } => r.id !== null && r.acceptance != null)
+      .map((r) => ({
+        item: r.id,
+        state: r.state,
+        met: r.acceptance.met,
+        total: r.acceptance.total,
+        file: join(read.root, ...r.path.split("/")),
+        unmet: r.warnings.find((w) => w.code === "work-acceptance-unmet")?.message ?? null,
+      }));
+  } catch (err) {
+    if (err instanceof RecordReadError) return undefined;
+    throw err;
+  }
+}
+
 /** An answer kind's points file (ws-058), read from `tree` and validated as `points ask` reads it. */
 async function checkPoints(abs: string, rootOnDisk: string, tree: WorkspaceTree): Promise<NonNullable<DeclaredKind["points"]>> {
   const file = relative(rootOnDisk, abs).split(sep).join("/");

package/src/workspace/generated-files.ts

@@ -22,6 +22,7 @@
 import { relative, resolve, sep } from "node:path";
 import { findWorkspaceRoot } from "../project-root";
 import { isInside, readDeclaration, type Declaration } from "./declaration";
+import { memberHolding } from "./record-assets";
 import { workingTree } from "./tree";
 
 /** What `chant update` rewrites, registered as implicit generated entries. */
@@ -79,6 +80,19 @@ export function declaredFilesUnder(declaration: Declaration, dir: string): Map<s
   return out;
 }
 
+/**
+ * Whether a workspace path (from the workspace root) is a generated file:
+ * declared in its member's `generated` entries, or one core registers. The
+ * `generated` of `graph --intent`'s region and file nodes and of `check
+ * --changes`'s paths.
+ */
+export function isGeneratedPath(declaration: Declaration, path: string): boolean {
+  const m = declaration.members.find((x) => x.name === memberHolding(path, declaration.members));
+  const dir = m?.dir ?? ".";
+  const rel = dir === "." ? path : path.slice(dir.length + 1);
+  return classifyFile(rel, declaredFilesUnder(declaration, dir)).class === "generated";
+}
+
 /**
  * The declared generated files for the absolute directory `absDir`, from the
  * nearest `chant.workspace.json` above it. Empty when there is none, which is

package/src/workspace/graph-cli.ts

@@ -220,7 +220,7 @@ export async function workspaceGraph(query: GraphQuery): Promise<GraphResult> {
       try {
         const read = await readRecordsFor({ kind: query.kind, cwd: query.cwd, at: query.at });
         const name = read.loaded.kind.name;
-        graph.records = read.result.records.map((r) => ({ kind: name, id: r.id, path: r.path, state: r.state, valid: r.valid, supersededBy: r.supersededBy }));
+        graph.records = read.result.records.map((r) => ({ kind: name, id: r.id, path: r.path, state: r.state, valid: r.valid, supersededBy: r.supersededBy, remediatedBy: r.remediatedBy }));
         graph.links.push(...recordLinkRows(name, read.result.records, read.loaded.kind.constrains?.field, located.tree, declaration.members));
       } catch (err) {
         if (!(err instanceof RecordReadError)) throw err;

package/src/workspace/graph.schema.json

@@ -752,7 +752,8 @@
         "path",
         "state",
         "valid",
-        "supersededBy"
+        "supersededBy",
+        "remediatedBy"
       ],
       "properties": {
         "kind": {
@@ -784,6 +785,13 @@
             "string",
             "null"
           ]
+        },
+        "remediatedBy": {
+          "description": "Added in contract 1 by #2774. The ids of records whose remediates link names this one.",
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
         }
       }
     }

package/src/workspace/intent-joins.test.ts

@@ -36,7 +36,7 @@ describe("the data form reads every trailer value (#2663)", () => {
   });
 
   test("trailerValues keeps git's order, trims, and drops empty values and repeats", () => {
-    expect(trailerValues({ "Chud-Evidence": ["h1", "h2"], "chud-evidence": ["h2", " h3", "  "] }, "CHUD-EVIDENCE")).toEqual(["h1", "h2", "h3"]);
+    expect(trailerValues({ "Acme-Evidence": ["h1", "h2"], "acme-evidence": ["h2", " h3", "  "] }, "ACME-EVIDENCE")).toEqual(["h1", "h2", "h3"]);
     expect(trailerValues({}, "X")).toEqual([]);
     expect(trailerValue({ X: ["  "] }, "x")).toBeUndefined();
   });
@@ -45,16 +45,16 @@ describe("the data form reads every trailer value (#2663)", () => {
 describe("commitJoinsName (#2663)", () => {
   test("names the findings of either form, and leaves the data form's own keys alone", () => {
     const join = () => undefined;
-    expect(readCommitJoins({ commitJoins: join, commitJoinsName: "chud" })).toEqual({ form: "function", join, name: "chud" });
-    expect(readCommitJoins({ commitJoins: { trailers: { unit: "Unit" } }, commitJoinsName: "chud" })).toEqual({ form: "data", data: { trailers: { unit: "Unit" } }, name: "chud" });
+    expect(readCommitJoins({ commitJoins: join, commitJoinsName: "acme" })).toEqual({ form: "function", join, name: "acme" });
+    expect(readCommitJoins({ commitJoins: { trailers: { unit: "Unit" } }, commitJoinsName: "acme" })).toEqual({ form: "data", data: { trailers: { unit: "Unit" } }, name: "acme" });
     expect(readCommitJoins({ commitJoins: join })).toEqual({ form: "function", join });
     // A name inside the data form is still a key the data form does not have.
-    expect(readCommitJoins({ commitJoins: { name: "chud", trailers: {} } })).toMatch(/Unrecognized key/);
+    expect(readCommitJoins({ commitJoins: { name: "acme", trailers: {} } })).toMatch(/Unrecognized key/);
   });
 
   test("a name that can't be a plugin:<name>: segment, or one with no joins, is refused", () => {
     for (const bad of ["a:b", "a b", "", 7]) expect(readCommitJoins({ commitJoins: () => undefined, commitJoinsName: bad }), String(bad)).toMatch(/^commitJoinsName:/);
-    expect(readCommitJoins({ commitJoinsName: "chud" })).toMatch(/no commitJoins/);
+    expect(readCommitJoins({ commitJoinsName: "acme" })).toMatch(/no commitJoins/);
     expect(readCommitJoins({})).toBeUndefined();
   });
 });

package/src/workspace/intent-joins.ts

@@ -2,10 +2,10 @@
  * The commit-join hook of the intent graph (#2651; #2650 C1 and C13).
  *
  * Commits, decisions and artifacts come from core. Units of work, contracts
- * and evidence come from a plugin, such as chud's development model, because
- * core ships no model of them (#2555, "Core ships no decision kind"). A kind
- * file passed to `chant workspace graph --intent --kind <file>` supplies them
- * through one export, `commitJoins`, in one of two forms:
+ * and evidence come from a plugin, such as a workspace's own development
+ * model, because core ships no model of them (#2555, "Core ships no decision
+ * kind"). A kind file passed to `chant workspace graph --intent --kind <file>`
+ * supplies them through one export, `commitJoins`, in one of two forms:
  *
  * - A function `commitJoins(commit, context)` that returns the unit, contract
  *   and evidence for one commit, or nothing. It is given the commit's sha,
@@ -36,7 +36,7 @@
  * `<name>` is the kind's name by default: its record kind's name, or the
  * file's name without `.kind.mjs`. A kind file may name its findings itself
  * with a sibling export, `commitJoinsName` (#2663), so joins that live beside
- * a record kind called `decision` can still report `plugin:chud:<code>`. It is
+ * a record kind called `decision` can still report `plugin:acme:<code>`. It is
  * a sibling export rather than a property because the data form is a closed
  * object whose keys are all joins, and a function's `name` property is
  * already its own name.

package/src/workspace/intent.schema.json

@@ -600,7 +600,9 @@
                   "record-schema-invalid",
                   "record-id-duplicate",
                   "record-supersedes-unknown",
-                  "record-supersedes-conflict"
+                  "record-supersedes-conflict",
+                  "record-remediates-unknown",
+                  "record-remediates-not-closed"
                 ]
               },
               "message": {
@@ -794,7 +796,9 @@
                   "record-schema-invalid",
                   "record-id-duplicate",
                   "record-supersedes-unknown",
-                  "record-supersedes-conflict"
+                  "record-supersedes-conflict",
+                  "record-remediates-unknown",
+                  "record-remediates-not-closed"
                 ]
               },
               "message": {
@@ -941,6 +945,8 @@
                   "work-done-unpinned",
                   "work-closed-without-date",
                   "work-done-gap-open",
+                  "work-acceptance-unmet",
+                  "work-acceptance-self-verified",
                   "answer-points-unreadable",
                   "answer-point-unknown",
                   "answer-point-changed"

package/src/workspace/intent.ts

@@ -38,7 +38,7 @@ import { realpathSync } from "node:fs";
 import { basename, dirname, relative, resolve, sep } from "node:path";
 import { declaredRecordKinds, readDeclaration, readerVersion, resolveGroups, WORKSPACE_ERROR_CODES, WorkspaceReadError, type Declaration } from "./declaration";
 import { declaredKindFile } from "./declared-kinds";
-import { classifyFile, declaredFilesUnder } from "./generated-files";
+import { isGeneratedPath } from "./generated-files";
 import { entityDecisions, hasTrailer, readCommitJoins, runCommitJoins, type CommitJoins, type IntentCommit, type JoinedEntity, type PluginFinding } from "./intent-joins";
 import { loadKindRegistry } from "./kinds";
 import { resolveLinks, type LinkTableRow } from "./links";
@@ -541,13 +541,6 @@ function filesUnder(tree: WorkspaceTree, dir: string): string[] {
   return out;
 }
 
-function isGenerated(declaration: Declaration, path: string): boolean {
-  const m = declaration.members.find((x) => x.name === memberHolding(path, declaration.members));
-  const dir = m?.dir ?? ".";
-  const rel = dir === "." ? path : path.slice(dir.length + 1);
-  return classifyFile(rel, declaredFilesUnder(declaration, dir)).class === "generated";
-}
-
 function stringOr(v: unknown): string | null {
   return typeof v === "string" ? v : null;
 }
@@ -707,9 +700,9 @@ async function walk(query: IntentQuery, head: Head): Promise<IntentResult> {
   // The region, its files and its member.
   const member = region.path === "." ? (declaration.members.find((m) => m.dir === ".")?.name ?? null) : memberHolding(region.path, declaration.members);
   const rid = regionId(region.path, region.lines);
-  add<RegionNode>({ id: rid, kind: "region", path: region.path, lines: region.lines, member, at: located.at, type, generated: type === "file" ? isGenerated(declaration, region.path) : null, node: region.node });
+  add<RegionNode>({ id: rid, kind: "region", path: region.path, lines: region.lines, member, at: located.at, type, generated: type === "file" ? isGeneratedPath(declaration, region.path) : null, node: region.node });
   const files = type === "dir" ? filesUnder(located.tree, region.path) : [];
-  for (const f of files) add<FileNode>({ id: `file:${f}`, kind: "file", path: f, member: memberHolding(f, declaration.members), generated: isGenerated(declaration, f) });
+  for (const f of files) add<FileNode>({ id: `file:${f}`, kind: "file", path: f, member: memberHolding(f, declaration.members), generated: isGeneratedPath(declaration, f) });
   const memberNode = (name: string) => {
     const m = declaration.members.find((x) => x.name === name);
     return add<MemberNode>({ id: `member:${name}`, kind: "member", name, dir: m?.dir ?? "", memberKind: m?.kind ?? "" });

package/src/workspace/lineage-check.ts

@@ -16,6 +16,9 @@
  *
  * `chant workspace upgrade` runs the same checks in its staging worktree
  * before it reaches its gate.
+ *
+ * `--changes <base>..<head>` runs the forward coverage check instead
+ * (`changes-cli.ts`, #2773), which prints a document of its own.
  */
 
 import { realpathSync } from "node:fs";
@@ -84,7 +87,8 @@ export function findingKey(f: CheckFinding): string {
   return `${f.code}\0${f.scope ?? ""}\0${f.path ?? ""}`;
 }
 
-const USAGE = "chant workspace check [--at <rev>] [--json] [--format stylish|json|sarif] [--generated] [--kind <kind file>]";
+const USAGE =
+  "chant workspace check [--at <rev>] [--json] [--format stylish|json|sarif] [--generated] [--kind <kind file>]\n       chant workspace check --changes <base>..<head> [--work <id>] [--severity off|warn|fail] [--kind <kind file>...] [--json]";
 const FORMATS = ["stylish", "json", "sarif"] as const;
 
 /** A lock finding as a lint diagnostic, for `--format json` and `--format sarif`. */
@@ -223,6 +227,17 @@ export async function runWorkspaceCheck(ctx: CommandContext): Promise<number> {
     console.error(formatError({ message: `chant workspace check takes no argument (got ${ctx.args.extraPositional})`, hint: USAGE }));
     return 1;
   }
+  // The forward coverage check (#2773) is its own document.
+  if (ctx.args.changes !== undefined) {
+    if (ctx.args.at !== undefined) {
+      console.error(formatError({ message: "--changes reads the records at the range's head, so it takes no --at", hint: USAGE }));
+      return 1;
+    }
+    const { handToRootChant } = await import("./which-chant");
+    const handed = await handToRootChant(root, undefined);
+    if (handed !== undefined) return handed;
+    return (await import("./changes-cli")).runWorkspaceChanges(ctx, root);
+  }
   const format = (ctx.args.format || "stylish") as (typeof FORMATS)[number];
   if (!FORMATS.includes(format)) {
     console.error(formatError({ message: `--format ${format} is not a check format; use stylish, json or sarif`, hint: USAGE }));

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

@@ -71,7 +71,7 @@ export async function upgradeCommand(opts: UpgradeCommandOptions): Promise<Upgra
         }),
       );
     }
-    if (!staged.changed) {
+    if (!staged.changed && staged.checksOk) {
       if (!opts.json) console.error(formatSuccess(`scope "${staged.scope}" is already at ${staged.to ?? "its source"}; nothing to upgrade`));
       return report("up-to-date", 0);
     }

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

@@ -124,6 +124,76 @@ describe("chant workspace upgrade", () => {
     expect(git(proj, ["worktree", "list"]).split("\n")).toHaveLength(1);
   });
 
+  test("builds and lints the chant member chant.workspace.json declares, not the scope root (#2804)", async () => {
+    release("v2.0.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",
+    });
+    const calls: Array<{ command: string; cwd: string }> = [];
+    const recording: ChantRunner = async (command, cwd) => {
+      calls.push({ command, cwd });
+      return { exitCode: 0, output: "" };
+    };
+
+    const staged = await stageUpgrade({ root: proj, to: "v2.0.0", runChant: recording });
+    try {
+      // Never at the scope root: it has no chant.config once the project is a workspace.
+      expect(calls.every((c) => c.cwd === join(staged.worktreeProject, "delivery"))).toBe(true);
+      expect(calls.map((c) => c.command).sort()).toEqual(["build", "lint"]);
+      expect(staged.checks).toEqual(
+        expect.arrayContaining([
+          { name: "build", status: "passed", member: "delivery" },
+          { name: "lint", status: "passed", member: "delivery" },
+        ]),
+      );
+    } finally {
+      staged.dispose();
+    }
+  });
+
+  test("a member's own node_modules is linked into the staging worktree for its checks, and stays out of the patch (#2847)", async () => {
+    release("v2.0.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",
+    });
+    // The member installs its packages itself; git never sees them.
+    put(proj, "delivery/node_modules/member-only/package.json", JSON.stringify({ name: "member-only", version: "1.0.0" }) + "\n");
+    writeFileSync(join(proj, ".git", "info", "exclude"), "node_modules\n");
+    const seen: string[] = [];
+    const recording: ChantRunner = async (command, cwd) => {
+      if (existsSync(join(cwd, "node_modules", "member-only", "package.json"))) seen.push(command);
+      return { exitCode: 0, output: "" };
+    };
+
+    const staged = await stageUpgrade({ root: proj, to: "v2.0.0", runChant: recording });
+    try {
+      expect(seen.sort()).toEqual(["build", "lint"]);
+      expect(staged.changedPaths.some((p) => p.includes("node_modules"))).toBe(false);
+      expect(staged.patch).not.toContain("node_modules");
+    } finally {
+      staged.dispose();
+    }
+    // Disposing the worktree removes the link, never the member's own packages.
+    expect(existsSync(join(proj, "delivery", "node_modules", "member-only", "package.json"))).toBe(true);
+  });
+
+  test("a member's failing build fails the upgrade's checks before the gate (#2804)", async () => {
+    release("v2.0.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",
+    });
+    const failingBuild: ChantRunner = async (command) => (command === "build" ? { exitCode: 1, output: "boom\n" } : { exitCode: 0, output: "" });
+
+    const result = await upgradeCommand({ root: proj, to: "v2.0.0", runChant: failingBuild });
+    expect(result.outcome).toBe("checks-failed");
+    expect(result.exitCode).toBe(1);
+    expect(result.staged!.checks).toEqual(
+      expect.arrayContaining([{ name: "build", status: "failed", detail: "boom", member: "delivery" }]),
+    );
+    // The tree is unchanged: an unbuildable migration never reaches the gate.
+    expect(git(proj, ["status", "--porcelain"])).toBe("");
+  });
+
   test("gates on the patch digest, then applies exactly the approved patch", async () => {
     release("v2.0.0", { "README.md": "starter v2\n" });
     const port = ledger();