@intentius/chant 0.91.0 → 0.93.0

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();

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/points-cli.ts

@@ -15,7 +15,7 @@
  */
 
 import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { relative, resolve, sep } from "node:path";
 import { formatError } from "../cli/format";
 import type { CommandContext } from "../cli/registry";
 import { declaredRecordKinds, readDeclaration, readerVersion, WorkspaceReadError, type ErrorLocation, type WorkspaceErrorCode } from "./declaration";
@@ -24,6 +24,7 @@ import { answerPoint, askPoint, questionView, POINTS_WRITE_CONTRACT_VERSION, POI
 import { candidates, inputOutput, pointsFileOf, pointVersion, quorumOf, readPointsThrough, type Decider, type ModelAsk, type WireAnswer } from "./points";
 import type { ReasonCode } from "./reason-codes";
 import { gitRevisionSource, workingTreeSource } from "./record-source";
+import { readLedgerAnswers, withLedgerAnswers, type LedgerAnswers } from "./answers-ledger";
 import { loadRecordKind, RecordReadError, type ReadErrorCode } from "./records";
 import { readRecordsFor } from "./records-cli";
 import { locateWorkspace } from "./which-chant";
@@ -136,7 +137,17 @@ export async function workspacePoints(query: PointsQuery): Promise<PointsDocumen
         if (k.given) sources.push({ kind: k.shown, points: null, reason: { code: "kind-invalid", message: `the ${loaded.kind.name} kind has no answers block, so it holds no answers to decision points` } });
         continue;
       }
-      const read = await readRecordsFor({ kind: k.file, cwd: query.cwd, at: query.at });
+      // Without --at, the questions a steward keeps on the lifecycle ledger are read too (#2786).
+      let ledger = undefined as LedgerAnswers | undefined;
+      const read = await readRecordsFor({
+        kind: k.file,
+        cwd: query.cwd,
+        at: query.at,
+        overlay: async (base, { loaded: l, root }) => {
+          ledger = await readLedgerAnswers({ file: l.file, name: l.kind.name, dirRel: relative(root, l.dir).split(sep).join("/") || "." });
+          return withLedgerAnswers(base, ledger);
+        },
+      });
       const source = read.at !== null && read.top ? gitRevisionSource(read.top, read.at) : workingTreeSource(read.root);
       const file = pointsFileOf(read.loaded, read.root);
       const parsed = readPointsThrough(source, file);
@@ -158,7 +169,7 @@ export async function workspacePoints(query: PointsQuery): Promise<PointsDocumen
         });
       }
       for (const e of read.result.records) {
-        const view = questionView(e, typeof e.data?.point === "string" ? declared[e.data.point] : undefined);
+        const view = questionView(e, typeof e.data?.point === "string" ? declared[e.data.point] : undefined, ledger?.byPath.get(e.path)?.ledger ?? null);
         if (view && (!query.open || view.open)) questions.push(view);
       }
     } catch (err) {