@intentius/chant 0.91.0 → 0.94.0

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";
@@ -70,6 +71,8 @@ export interface PointView {
   questionType: string;
   instructions: string;
   candidates: (string | boolean)[];
+  /** What each candidate means, as the points file declares it: an object of strings for noul and choice, an array for score. */
+  criteria: Record<string, string> | string[];
   /** Each input: its name, the read-contract output it names, and its description. */
   inputs: { name: string; output: string; description: string }[];
   deciders: Decider[];
@@ -136,7 +139,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);
@@ -152,13 +165,14 @@ export async function workspacePoints(query: PointsQuery): Promise<PointsDocumen
           questionType: p.question.type,
           instructions: p.question.instructions,
           candidates: candidates(p.question),
+          criteria: p.question.criteria,
           inputs: Object.entries(p.inputs).map(([n, description]) => ({ name: n, output: inputOutput(n), description })),
           deciders: p.deciders,
           quorum: quorumOf(p),
         });
       }
       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) {

package/src/workspace/points-write.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://intentius.io/chant/schemas/workspace/points-write/v1/points-write.schema.json",
   "title": "chant workspace points ask and answer output",
-  "description": "What `chant workspace points ask` and `points answer` print (ws-058, #2739): the answer record asked for or written, as `points --json` lists a question. ask returns the record that is there when the same point, declaration and inputs were answered or proposed before (reused), and otherwise writes one: answered from a table, proposed from a model at or above its threshold, escalated to people below it. answer records people's answer to an open question once the point's quorum is met. Nothing is committed, and nothing is written on a refusal or with --dry-run. The error codes are a closed list, each in the one closed list of `reason-codes.ts`. Written at contract version 1 of the write documents.",
+  "description": "What `chant workspace points ask` and `points answer` print (ws-058, #2739): the answer record asked for or written, as `points --json` lists a question. ask returns the record that is there when the same point, declaration and inputs were answered or proposed before (reused), and otherwise writes one: answered from a table, proposed from a model at or above its threshold, escalated to people below it. answer records people's answer to an open question once the point's quorum is met. Nothing is committed to the working branch, and nothing is written on a refusal or with --dry-run. In a steward's turn a new record goes on the lifecycle ledger instead of the working tree (#2786), as a commit on chant/lifecycle, and a record already held there is rewritten there. The error codes are a closed list, each in the one closed list of `reason-codes.ts`. Written at contract version 1 of the write documents.",
   "oneOf": [
     {
       "$ref": "#/$defs/result"
@@ -372,6 +372,13 @@
             "type": "string"
           }
         },
+        "ledger": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "description": "Where the record is held when it is on the lifecycle ledger rather than in the working tree (#2786): chant/lifecycle:<path>, which git show reads. A question asked in a steward's turn is held there, since a steward never writes the checkout; people's answer to it is written there too. null for a record in the working tree. path is where the record reads as being either way."
+        },
         "askedOn": {
           "type": [
             "string",
@@ -465,6 +472,7 @@
                 "point-decider-failed",
                 "answer-not-candidate",
                 "quorum-not-met",
+                "answer-in-steward-turn",
                 "record-not-found",
                 "record-closed",
                 "record-id-taken",
@@ -473,6 +481,8 @@
                 "record-id-duplicate",
                 "record-supersedes-unknown",
                 "record-supersedes-conflict",
+                "record-remediates-unknown",
+                "record-remediates-not-closed",
                 "session-seal-mismatch",
                 "session-verdict-unknown-record"
               ]

package/src/workspace/points.schema.json

@@ -191,6 +191,7 @@
         "questionType",
         "instructions",
         "candidates",
+        "criteria",
         "inputs",
         "deciders",
         "quorum"
@@ -236,6 +237,23 @@
             ]
           }
         },
+        "criteria": {
+          "description": "What each candidate means, as the points file declares it: noul and choice give an object of strings keyed by candidate, score an array of ordered level descriptions.",
+          "oneOf": [
+            {
+              "type": "object",
+              "additionalProperties": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          ]
+        },
         "inputs": {
           "type": "array",
           "items": {
@@ -583,6 +601,39 @@
             "type": "string"
           }
         },
+        "askedBy": {
+          "description": "The steward whose turn asked the question (#2749), and the run it was in, or null. The steward waits on the question and never answers it: a person does.",
+          "oneOf": [
+            {
+              "type": "null"
+            },
+            {
+              "type": "object",
+              "required": [
+                "steward",
+                "run"
+              ],
+              "properties": {
+                "steward": {
+                  "type": "string"
+                },
+                "run": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                }
+              }
+            }
+          ]
+        },
+        "ledger": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "description": "Where the record is held when it is on the lifecycle ledger rather than in the working tree (#2786): chant/lifecycle:<path>, which git show reads. A question asked in a steward's turn is held there, since a steward never writes the checkout; people's answer to it is written there too. null for a record in the working tree. path is where the record reads as being either way."
+        },
         "askedOn": {
           "type": [
             "string",