@intentius/chant 0.90.0 → 0.93.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();

package/src/workspace/lineage-upgrade.ts

@@ -34,9 +34,9 @@
  */
 
 import { execFileSync, spawn } from "node:child_process";
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { basename, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { computePlanDigest } from "../lifecycle/plan-digest";
 import type { ResolvedGateApproval } from "../op/gate-approval";
 import { checkLineage, findingKey, type CheckFinding } from "./lineage-check";
@@ -56,10 +56,13 @@ import {
   type ManualStep,
 } from "./lineage-lock";
 import { mergeFile } from "./lineage-merge";
+import { reportPlan, runChantMigrations, type ChantMigrationReport } from "./chant-migrations";
+import { readDeclaration, readerVersion, WorkspaceReadError } from "./declaration";
 import { assertCodeAllowed, planMigrations, runMigration, splitMigrations, type LoadedMigration } from "./lineage-migrations";
 import { applyUpstream, type UpdateResult } from "./lineage-update";
 import { carryParameters, readManifest, substituteParameters } from "./template-manifest";
 import { repinSubstituted, type RepinnedRecord } from "./template-pins";
+import { workingTree } from "./tree";
 
 /** The kind the patch digest is taken under, so it never collides with another kind of plan. */
 export const UPGRADE_PLAN_KIND = "workspace-upgrade";
@@ -74,10 +77,12 @@ export class UpgradeError extends LockError {
 // ── Checks ───────────────────────────────────────────────────────────────────
 
 export interface UpgradeCheck {
-  name: "build" | "lint" | "workspace check";
+  name: "build" | "lint" | "workspace check" | "migration";
   status: "passed" | "failed" | "skipped";
   /** Why a check was skipped, or the tail of a failed command's output. */
   detail?: string;
+  /** The chant member `build` or `lint` ran in ("." for the scope root), when it is not the only one. */
+  member?: string;
 }
 
 /** Runs `chant build` or `chant lint` in a directory. */
@@ -141,6 +146,8 @@ export interface StagedUpgrade {
   to: string | null;
   commit?: { from?: string; to: string };
   migrations: string[];
+  /** The migrations chant ships (./chant-migrations.ts) that found something to move, applied or not. */
+  chantMigrations: ChantMigrationReport[];
   written: string[];
   merged: string[];
   removed: string[];
@@ -460,6 +467,25 @@ function tail(text: string, lines = 30): string {
   return text.trimEnd().split("\n").slice(-lines).join("\n");
 }
 
+/**
+ * The `chant` members `chant.workspace.json` declares in `dir` (#2804): a
+ * template built as a workspace, such as the studio kit's, keeps its chant
+ * project in a member (`delivery`), not at the scope's root, and the root
+ * itself never has a `chant.config`. Empty when `dir` declares no workspace,
+ * or the declaration cannot be read: the caller then falls back to `dir`
+ * itself.
+ */
+function chantMemberDirs(dir: string): string[] {
+  try {
+    return readDeclaration(workingTree(dir))
+      .members.filter((m) => m.kind === "chant")
+      .map((m) => m.dir);
+  } catch (err) {
+    if (err instanceof WorkspaceReadError) return [];
+    throw err;
+  }
+}
+
 /**
  * Stage an upgrade: steps 1 to 5 and the digest of step 6. Nothing in the
  * project's tree changes. The caller decides the gate, then applies the patch
@@ -568,6 +594,12 @@ export async function stageUpgrade(options: UpgradeOptions): Promise<StagedUpgra
       rmSync(scratch, { recursive: true, force: true });
     }
 
+    // chant's own migrations (#2737): planned from what the scope holds, and
+    // applied only when the plan has no conflict. A conflict fails the checks.
+    // Each is planned from the tree the ones before it left.
+    const chantRuns = lineage.kind === "template" ? runChantMigrations({ dir: scopeDir, lineage: staged, chantVersion: readerVersion() }) : [];
+    const chantMigrations: ChantMigrationReport[] = chantRuns.map((r) => reportPlan(r.plan, r.applied));
+
     // 4. Merge per file.
     const result = applyUpstream(scopeDir, staged, upstream.files, { base, merge: mergeFile });
     for (const path of result.written) if (upstream.executable.has(path)) chmodSync(join(scopeDir, path), 0o755);
@@ -607,12 +639,40 @@ export async function stageUpgrade(options: UpgradeOptions): Promise<StagedUpgra
 
     // 5. Checks.
     const checks: UpgradeCheck[] = [];
+    for (const m of chantMigrations.filter((m) => !m.applied)) {
+      checks.push({
+        name: "migration",
+        status: "failed",
+        detail: `${m.id} was not applied: ${m.conflicts.map((c) => `${c.path}: ${c.reason}`).join("\n")}`,
+      });
+    }
     if (changed) {
-      if (isChantProject(worktreeProject)) {
+      // Every `chant` member chant.workspace.json declares, so a template
+      // whose chant project sits in a member (the studio kit's `delivery/`)
+      // is built and linted there, not skipped for having no chant.config at
+      // the scope's root (#2804). A scope with no workspace declaration falls
+      // back to the root, as before.
+      const members = chantMemberDirs(worktreeProject);
+      const targets = members.length > 0 ? members : isChantProject(worktreeProject) ? ["."] : [];
+      if (targets.length > 0) {
         const run = options.runChant ?? spawnChant;
-        for (const command of ["build", "lint"] as const) {
-          const r = await run(command, worktreeProject);
-          checks.push(r.exitCode === 0 ? { name: command, status: "passed" } : { name: command, status: "failed", detail: tail(r.output) });
+        const namedMember = targets.length > 1 || targets[0] !== ".";
+        // A member that installs its packages in its own directory resolves them from its node_modules, which is not
+        // an ancestor of the staging worktree: link it in from the project (#2847). The patch and its digest are
+        // computed above, so the links never reach them, and dispose() removes them with the worktree.
+        for (const member of targets) {
+          if (member === ".") continue;
+          const from = join(root, member, "node_modules");
+          const to = join(worktreeProject, member, "node_modules");
+          if (existsSync(from) && !existsSync(to) && existsSync(dirname(to))) symlinkSync(from, to, "dir");
+        }
+        for (const member of targets) {
+          const dir = member === "." ? worktreeProject : join(worktreeProject, member);
+          const at = namedMember ? { member } : {};
+          for (const command of ["build", "lint"] as const) {
+            const r = await run(command, dir);
+            checks.push(r.exitCode === 0 ? { name: command, status: "passed", ...at } : { name: command, status: "failed", detail: tail(r.output), ...at });
+          }
         }
       } else {
         for (const name of ["build", "lint"] as const) checks.push({ name, status: "skipped", detail: "not a chant project (no chant.config)" });
@@ -627,7 +687,8 @@ export async function stageUpgrade(options: UpgradeOptions): Promise<StagedUpgra
       from: fromDir ? sourcePin(lineage.source) : lineage.ref ?? null,
       to: fromDir ? sourcePin(staged.source) : staged.ref ?? null,
       ...(upstream.commit ? { commit: { ...(lineage.address?.commit ? { from: lineage.address.commit } : {}), to: upstream.commit } } : {}),
-      migrations: plan.chain.map((m) => m.migration.id),
+      migrations: [...plan.chain.map((m) => m.migration.id), ...chantMigrations.filter((m) => m.applied).map((m) => m.id)],
+      chantMigrations,
       written: result.written,
       merged: result.merged,
       removed: result.removed,
@@ -721,7 +782,14 @@ export function describeStaged(staged: StagedUpgrade): string[] {
   const lines: string[] = [];
   const at = (p: string) => (staged.scope === "." ? p : `${staged.scope}/${p}`);
   lines.push(`${staged.scope}  ${staged.template}  ${staged.from ?? "(no ref)"} -> ${staged.to ?? "(no ref)"}`);
-  for (const id of staged.migrations) lines.push(`  migration: ${id}`);
+  const chantIds = new Set(staged.chantMigrations.map((m) => m.id));
+  for (const id of staged.migrations) if (!chantIds.has(id)) lines.push(`  migration: ${id}`);
+  for (const m of staged.chantMigrations) {
+    lines.push(`  chant migration: ${m.id} (${m.applied ? "applied" : "not applied: it has conflicts"}), to ${m.description}`);
+    for (const c of m.changes) lines.push(`    ${c.action === "delete" ? "delete" : "write"}: ${at(c.path)} (${c.why}${c.edited ? "; it was edited since the template, and the edit stays in git history" : ""})`);
+    for (const n of m.notMoved) lines.push(`    not moved: ${n.what} -> ${n.where}`);
+    for (const c of m.conflicts) lines.push(`    conflict: ${at(c.path)}: ${c.reason}`);
+  }
   for (const p of staged.written) lines.push(`  updated: ${at(p)}`);
   for (const p of staged.merged) lines.push(`  merged: ${at(p)}`);
   for (const p of staged.removed) lines.push(`  removed: ${at(p)}`);
@@ -735,7 +803,10 @@ export function describeStaged(staged: StagedUpgrade): string[] {
       `  governance: ${staged.governance.paths.join(", ")}; needs ${q.count} human approval(s)${q.roles ? ` with a role in ${q.roles.join(", ")}` : ""}, from the rules at ${staged.governance.rules.slice(0, 12)}`,
     );
   }
-  for (const c of staged.checks) lines.push(`  ${c.name}: ${c.status}${c.status === "skipped" && c.detail ? ` (${c.detail})` : ""}`);
+  for (const c of staged.checks) {
+    const label = c.member !== undefined ? `${c.name} (${c.member})` : c.name;
+    lines.push(`  ${label}: ${c.status}${c.status === "skipped" && c.detail ? ` (${c.detail})` : ""}`);
+  }
   lines.push(`  patch: ${staged.changedPaths.length} file(s)${staged.lock.tracked ? "" : ` and the untracked ${LOCK_FILE}`}, ${staged.digest}`);
   return lines;
 }

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

@@ -135,6 +135,63 @@ describe("chant workspace ls on built workspaces", () => {
     expect(doc.summary).toEqual({ members: 5, unreadable: 3, groups: 1, matches: 0 });
   });
 
+  test("lists declared diagrams flattened across the workspace and its members (#2764)", () => {
+    const root = repo({
+      "chant.workspace.json": JSON.stringify({
+        name: "acme",
+        schema: 1,
+        members: [
+          {
+            name: "docs",
+            dir: "docs",
+            kind: "other",
+            because: "the docs site",
+            diagrams: [
+              {
+                name: "architecture",
+                title: "Studio architecture",
+                source: "docs/diagrams/architecture.d2",
+                render: "docs/diagrams/architecture.svg",
+                renderer: { tool: "d2", version: "0.9.0", args: ["--layout=elk", "--theme=0", "--pad=40", "--omit-version"] },
+                sourceHash: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+              },
+            ],
+          },
+        ],
+        diagrams: [
+          {
+            name: "boundary",
+            title: "chant and hud",
+            source: null,
+            render: "docs/diagrams/boundary.svg",
+            renderer: { tool: "graphviz", version: "9.0.0", args: [] },
+          },
+        ],
+      }),
+      "docs/README.md": "",
+    });
+    const doc = result(listWorkspace({ cwd: root }));
+    expectValid(doc);
+    expect(doc.diagrams).toEqual([
+      {
+        name: "boundary",
+        title: "chant and hud",
+        source: null,
+        render: "docs/diagrams/boundary.svg",
+        renderer: { tool: "graphviz", version: "9.0.0", args: [] },
+        member: null,
+      },
+      {
+        name: "architecture",
+        title: "Studio architecture",
+        source: "docs/diagrams/architecture.d2",
+        render: "docs/diagrams/architecture.svg",
+        renderer: { tool: "d2", version: "0.9.0", args: ["--layout=elk", "--theme=0", "--pad=40", "--omit-version"] },
+        member: "docs",
+      },
+    ]);
+  });
+
   test("a nested workspace member is readable by its own declaration, and ls inside it lists the inner one", () => {
     const root = repo({
       "chant.workspace.json": declaration([{ name: "kit", dir: "vendor/kit", kind: "workspace" }]),

package/src/workspace/ls.schema.json

@@ -8,7 +8,7 @@
     "result": {
       "description": "The declaration was read. Exit code 0, even when some members can't be read.",
       "type": "object",
-      "required": ["$schema", "contract", "chant", "at", "workspace", "members", "groups", "summary"],
+      "required": ["$schema", "contract", "chant", "at", "workspace", "members", "groups", "diagrams", "summary"],
       "properties": {
         "$schema": { "const": "https://intentius.io/chant/schemas/workspace/ls/v1/ls.schema.json" },
         "contract": { "const": 1 },
@@ -61,6 +61,11 @@
           "type": "array",
           "items": { "$ref": "#/$defs/group" }
         },
+        "diagrams": {
+          "description": "Added in contract 1 by #2764. Every declared diagram artifact, flattened across the workspace and its members: the workspace's own first, then each member's, in file order.",
+          "type": "array",
+          "items": { "$ref": "#/$defs/diagram" }
+        },
         "summary": {
           "type": "object",
           "required": ["members", "unreadable", "groups", "matches"],
@@ -138,9 +143,49 @@
               }
             }
           ]
+        },
+        "acceptance": {
+          "description": "Added in contract 1 by #2772. For a work kind whose work block names acceptance criteria: each current work item that lists some, in path order, with how many of its criteria passing evidence meets, read in the tree read. Null for any other kind, and when the kind or its records can't be read.",
+          "oneOf": [
+            { "type": "null" },
+            {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "required": ["item", "state", "met", "total"],
+                "properties": {
+                  "item": { "type": "string", "description": "The work item's id." },
+                  "state": { "type": ["string", "null"], "description": "The item's state." },
+                  "met": { "type": "integer", "minimum": 0, "description": "Criteria met by evidence naming them, with result pass and the criterion's verification; a manual verdict counts only from someone other than the implementer." },
+                  "total": { "type": "integer", "minimum": 0, "description": "Criteria the item lists." }
+                }
+              }
+            }
+          ]
         }
       }
     },
+    "diagram": {
+      "description": "A diagram artifact the declaration names (#2764), pinned to the renderer its render was made with. chant runs no renderer; everything here comes straight from the declaration.",
+      "type": "object",
+      "required": ["name", "title", "source", "render", "renderer", "member"],
+      "properties": {
+        "name": { "type": "string" },
+        "title": { "type": "string" },
+        "source": { "type": ["string", "null"], "description": "From the workspace root, with / separators. Null for an SVG with no source." },
+        "render": { "type": "string", "description": "From the workspace root, with / separators." },
+        "renderer": {
+          "type": "object",
+          "required": ["tool", "version", "args"],
+          "properties": {
+            "tool": { "enum": ["d2", "mermaid", "graphviz"] },
+            "version": { "type": "string", "description": "The exact release the render was made with, such as 0.9.0." },
+            "args": { "type": "array", "items": { "type": "string" }, "description": "Passed before the input and output paths, in order." }
+          }
+        },
+        "member": { "type": ["string", "null"], "description": "The member that declares it, or null for the workspace's own." }
+      }
+    },
     "group": {
       "type": "object",
       "required": ["name", "kind", "glob", "matches", "skipped", "reason"],

package/src/workspace/ls.ts

@@ -13,6 +13,11 @@
  * and each member's, with each kind file's own name when it loads (#2680).
  * Loading one imports it, so {@link listWorkspace} lists them unloaded and
  * {@link listWorkspaceWithKinds}, which the command runs, loads them.
+ *
+ * The declared diagram artifacts are listed too, flattened across the
+ * workspace and its members into one `diagrams` array (#2764). Unlike record
+ * kinds, nothing about a diagram is loaded: everything printed comes
+ * straight from the declaration, and chant runs no renderer to list it.
  */
 
 import { existsSync } from "node:fs";
@@ -20,11 +25,13 @@ import { resolve } from "node:path";
 import { formatError } from "../cli/format";
 import type { CommandContext } from "../cli/registry";
 import {
+  declaredDiagrams,
   readDeclaration,
   readerVersion,
   resolveGroups,
   WorkspaceReadError,
   type Declaration,
+  type DiagramDeclaration,
   type ErrorLocation,
   type Member,
   type WorkspaceErrorCode,
@@ -74,6 +81,20 @@ export interface LsRecordKind {
   kind: string | null;
   /** Why the kind file can't be loaded, or null. */
   reason: { code: DeclaredKindReasonCode; message: string } | null;
+  /**
+   * For a work kind with acceptance criteria (#2772): each current work item
+   * that lists criteria, with how many passing evidence meets. Null for any
+   * other kind, and when the kind or its records can't be read.
+   */
+  acceptance: LsAcceptance[] | null;
+}
+
+/** A work item's acceptance criteria, counted (#2772). */
+export interface LsAcceptance {
+  item: string;
+  state: string | null;
+  met: number;
+  total: number;
 }
 
 export interface LsMember {
@@ -89,6 +110,25 @@ export interface LsMember {
   records: LsRecordKind[];
 }
 
+/**
+ * A diagram artifact the declaration names (#2764), flattened across the
+ * workspace and its members: hud reads one list, the way it already reads
+ * `records --json`'s flat `assets[]`. `sourceHash`, the declaration's own
+ * bookkeeping for `chant workspace check`'s drift finding, is not printed
+ * here; a reader that draws diagrams has no use for it.
+ */
+export interface LsDiagram {
+  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: DiagramDeclaration["renderer"];
+  /** The member that declares it, or null for the workspace's own. */
+  member: string | null;
+}
+
 export interface LsGroup {
   name: string;
   kind: "examples";
@@ -117,6 +157,8 @@ export type LsDocument =
       };
       members: LsMember[];
       groups: LsGroup[];
+      /** Every declared diagram, the workspace's own first, then each member's, in file order (#2764). */
+      diagrams: LsDiagram[];
       summary: { members: number; unreadable: number; groups: number; matches: number };
     }
   | {
@@ -162,11 +204,12 @@ export async function listWorkspaceWithKinds(query: LsQuery): Promise<LsDocument
   const { doc, declaration, tree, rootOnDisk } = readListing(query);
   if (!declaration || "error" in doc) return doc;
   const { loadDeclaredKinds } = await import("./declared-kinds");
-  const loaded = await loadDeclaredKinds(declaration, tree!, rootOnDisk!);
+  const loaded = await loadDeclaredKinds(declaration, tree!, rootOnDisk!, { acceptance: true, ...(doc.at !== null ? { at: doc.at } : {}) });
   const byPath = new Map(loaded.map((k) => [k.declared.path, k]));
   const fill = (r: LsRecordKind): LsRecordKind => {
     const k = byPath.get(r.path)!;
-    return { ...r, name: r.name ?? k.kind, kind: k.kind, reason: k.reason };
+    const acceptance = k.acceptance ? k.acceptance.map((a) => ({ item: a.item, state: a.state, met: a.met, total: a.total })) : null;
+    return { ...r, name: r.name ?? k.kind, kind: k.kind, reason: k.reason, acceptance };
   };
   return {
     ...doc,
@@ -175,7 +218,7 @@ export async function listWorkspaceWithKinds(query: LsQuery): Promise<LsDocument
   };
 }
 
-const unloaded = (records: Declaration["records"]): LsRecordKind[] => records.map((r) => ({ name: r.name, path: r.path, kind: null, reason: null }));
+const unloaded = (records: Declaration["records"]): LsRecordKind[] => records.map((r) => ({ name: r.name, path: r.path, kind: null, reason: null, acceptance: null }));
 
 function readListing(query: LsQuery): { doc: LsDocument; declaration?: Declaration; tree?: WorkspaceTree; rootOnDisk?: string } {
   const chant = readerVersion();
@@ -213,6 +256,14 @@ function readListing(query: LsQuery): { doc: LsDocument; declaration?: Declarati
           ? { code: "no-matches", message: `no directory ${g.group.globs.join(" or ")} matches${tree.label} holds a chant project` }
           : null,
     }));
+    const diagrams: LsDiagram[] = declaredDiagrams(declaration).map((d) => ({
+      name: d.name,
+      title: d.title,
+      source: d.source,
+      render: d.render,
+      renderer: d.renderer,
+      member: d.member,
+    }));
     const doc: LsDocument = {
       ...head,
       at,
@@ -227,6 +278,7 @@ function readListing(query: LsQuery): { doc: LsDocument; declaration?: Declarati
       },
       members,
       groups: lsGroups,
+      diagrams,
       summary: {
         members: members.length,
         unreadable: members.filter((m) => !m.readable).length,
@@ -296,8 +348,15 @@ function formatLs(doc: Extract<LsDocument, { members: unknown }>): string {
     kinds.forEach(({ r }, i) => {
       lines.push(rendered[i + 1]);
       if (r.reason) lines.push(`  ${r.reason.code}: ${r.reason.message}`);
+      for (const a of r.acceptance ?? []) lines.push(`  ${a.item} ${a.state ?? "-"}: ${a.met}/${a.total} criteria met`);
     });
   }
+  if (doc.diagrams.length > 0) {
+    lines.push("");
+    const rows = [["DIAGRAM", "MEMBER", "SOURCE", "RENDER", "RENDERER"]];
+    for (const d of doc.diagrams) rows.push([d.name, d.member ?? "(workspace)", d.source ?? "-", d.render, `${d.renderer.tool} ${d.renderer.version}`]);
+    lines.push(...table(rows));
+  }
   if (doc.groups.length > 0) {
     lines.push("");
     const rows = [["GROUP", "KIND", "GLOB", "PROJECTS"]];

package/src/workspace/point-answer.schema.json

@@ -0,0 +1,95 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "urn:intentius:chant:point-answer:1",
+  "title": "Decision point answer front matter",
+  "description": "The front matter of one answer to a decision point (ws-058, #2739), as `chant workspace points ask` and `points answer` write it into the records directory of a record kind with an `answers` block. One record per point, declaration and inputs: its id is the point's name and the first 12 hex digits of the inputs hash, so the same question is answered once. A table's answer is `answered`; a model's answer at or above its threshold is `proposed` until a person confirms it; a question no decider before the quorum answered is `escalated`, open for people. A workspace copies this file next to its answer kind, as reference-workspace/answers/ does. Values stay within what YAML and JSON share. Fields other than these must start with x-.",
+  "type": "object",
+  "additionalProperties": false,
+  "patternProperties": { "^x-": {} },
+  "required": ["id", "title", "point", "point_version", "question_type", "candidates", "inputs", "inputs_hash", "state", "decider", "asked_on"],
+  "properties": {
+    "id": { "type": "string", "pattern": "^[a-z][a-z0-9-]*-[0-9a-f]{12}$", "description": "The point's name, a hyphen, and the first 12 hex digits of inputs_hash." },
+    "title": { "type": "string", "minLength": 1 },
+    "point": { "type": "string", "pattern": "^[a-z][a-z0-9-]*$", "description": "The point in the points file this answers." },
+    "point_version": { "$ref": "#/definitions/sha256", "description": "sha256 of the point's declaration when it was asked. Editing the question or any decider changes it." },
+    "question_type": { "enum": ["noul", "choice", "score"] },
+    "candidates": { "type": "array", "minItems": 2, "items": { "type": ["string", "boolean"] }, "description": "The answers the question allowed: true and false, a choice's options, or a score's levels." },
+    "inputs": { "type": "object", "description": "The state the deciders saw, input name to value." },
+    "inputs_hash": { "$ref": "#/definitions/sha256", "description": "sha256 of the point, its version and its inputs. The same hash is answered once." },
+    "constrains": { "type": "array", "items": { "type": "string", "minLength": 1 }, "description": "What the question is about, such as a work item's id." },
+    "state": { "enum": ["escalated", "proposed", "answered"] },
+    "answer": { "type": ["string", "boolean"] },
+    "decider": {
+      "type": "object",
+      "required": ["kind"],
+      "properties": {
+        "kind": { "enum": ["table", "model", "quorum"] },
+        "row": { "type": "integer", "minimum": 0, "description": "table: the row that matched." },
+        "backend": { "type": "string", "minLength": 1 },
+        "model": { "type": "string", "minLength": 1, "description": "model: the model id that answered, as the backend reported it." },
+        "count": { "type": "integer", "minimum": 1 },
+        "roles": { "type": "array", "items": { "type": "string" } },
+        "by": { "type": "array", "items": { "type": "string" }, "description": "quorum: who answered." }
+      },
+      "additionalProperties": false
+    },
+    "probabilities": { "$ref": "#/definitions/probabilities" },
+    "confidence": { "$ref": "#/definitions/unit" },
+    "threshold": { "$ref": "#/definitions/unit" },
+    "escalations": {
+      "type": "array",
+      "description": "The deciders asked before the one that answered, or before the quorum, and why each did not answer.",
+      "items": { "$ref": "#/definitions/escalation" }
+    },
+    "answered_by": { "type": "array", "minItems": 1, "items": { "type": "string", "minLength": 1 }, "description": "The people who answered or confirmed it." },
+    "asked_on": { "$ref": "#/definitions/date" },
+    "answered_on": { "$ref": "#/definitions/date" },
+    "source": {
+      "type": "object",
+      "description": "Where the answer came from (#2708): via, client and model, the model id that answered when a model decider did."
+    }
+  },
+  "allOf": [
+    {
+      "if": { "properties": { "state": { "const": "proposed" } }, "required": ["state"] },
+      "then": { "required": ["answer"], "properties": { "decider": { "properties": { "kind": { "const": "model" } } } } }
+    },
+    {
+      "if": { "properties": { "state": { "const": "answered" } }, "required": ["state"] },
+      "then": { "required": ["answer", "answered_on"] }
+    },
+    {
+      "if": { "properties": { "state": { "const": "escalated" } }, "required": ["state"] },
+      "then": { "not": { "required": ["answer"] }, "properties": { "decider": { "properties": { "kind": { "const": "quorum" } } } } }
+    },
+    {
+      "if": { "properties": { "decider": { "properties": { "kind": { "const": "model" } }, "required": ["kind"] } }, "required": ["decider"] },
+      "then": { "required": ["probabilities", "confidence", "threshold"], "properties": { "decider": { "required": ["backend", "model"] } } }
+    },
+    {
+      "if": { "properties": { "state": { "const": "answered" }, "decider": { "properties": { "kind": { "const": "quorum" } }, "required": ["kind"] } }, "required": ["state", "decider"] },
+      "then": { "required": ["answered_by"], "properties": { "decider": { "required": ["by"] } } }
+    }
+  ],
+  "definitions": {
+    "sha256": { "type": "string", "pattern": "^[0-9a-f]{64}$" },
+    "unit": { "type": "number", "minimum": 0, "maximum": 1 },
+    "date": { "type": "string", "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$" },
+    "probabilities": { "type": "object", "additionalProperties": { "$ref": "#/definitions/unit" } },
+    "escalation": {
+      "type": "object",
+      "required": ["kind", "reason"],
+      "properties": {
+        "kind": { "enum": ["table", "model"] },
+        "reason": { "type": "string", "minLength": 1 },
+        "backend": { "type": "string" },
+        "model": { "type": "string" },
+        "answer": { "type": ["string", "boolean", "null"] },
+        "probabilities": { "$ref": "#/definitions/probabilities" },
+        "confidence": { "$ref": "#/definitions/unit" },
+        "threshold": { "$ref": "#/definitions/unit" }
+      },
+      "additionalProperties": false
+    }
+  }
+}