@intentius/chant 0.91.0 → 0.94.0

package/src/workspace/points.test.ts

@@ -24,10 +24,11 @@ import {
 } from "./points";
 
 /**
- * chud's points, as template/delivery/decisions/points.yaml declares them at
- * jhgaylor/chud@43afcf1, as JSON.
+ * Points shaped like an externally authored template's decisions file
+ * (ported from chud, jhgaylor/chud@43afcf1's
+ * template/delivery/decisions/points.yaml), as JSON.
  */
-const CHUD = {
+const IMPORTED = {
   points: {
     "slice-tier": {
       title: "Which builder tier builds this contract",
@@ -63,7 +64,7 @@ const CHUD = {
     "ship-skip": {
       title: "May this release skip the human gate",
       question: {
-        type: "boolean",
+        type: "noul",
         instructions: "May this release pass the ship gate without a person approving it? The state is what the release plan would change.",
         criteria: {
           true: "An agent may pass the gate for this release (only in enforce mode).",
@@ -86,9 +87,9 @@ const CHUD = {
   },
 };
 
-/** chud's points with each input named as a read-contract output: the slice tier reads a work item, the ship gate a release. */
-function renamed(): typeof CHUD {
-  const copy = JSON.parse(JSON.stringify(CHUD)) as typeof CHUD;
+/** The imported points with each input named as a read-contract output: the slice tier reads a work item, the ship gate a release. */
+function renamed(): typeof IMPORTED {
+  const copy = JSON.parse(JSON.stringify(IMPORTED)) as typeof IMPORTED;
   const prefix: Record<string, string> = { "slice-tier": "work-item", "ship-skip": "release" };
   for (const [name, point] of Object.entries(copy.points) as [string, { inputs: Record<string, string>; deciders: { rows?: { when: Record<string, unknown> }[] }[] }][]) {
     const to = (k: string) => `${prefix[name]}.${k}`;
@@ -123,14 +124,14 @@ describe("the decision points schema (#2738)", () => {
     }
   });
 
-  test("chud's slice-tier and ship-skip validate unchanged, apart from the input names", () => {
-    // As chud declares them, only the input names are refused: each names no read-contract output.
-    const found = problems(CHUD);
+  test("the imported slice-tier and ship-skip validate unchanged, apart from the input names", () => {
+    // As the template declares them, only the input names are refused: each names no read-contract output.
+    const found = problems(IMPORTED);
     expect(found.length).toBeGreaterThan(0);
     for (const p of found) expect(p.message).toMatch(/is not a read-contract output|is not one of this point's inputs/);
     expect(found.filter((p) => p.message.includes("read-contract output")).map((p) => p.field)).toEqual([
-      ...Object.keys(CHUD.points["slice-tier"].inputs).map((k) => `points.slice-tier.inputs.${k}`),
-      ...Object.keys(CHUD.points["ship-skip"].inputs).map((k) => `points.ship-skip.inputs.${k}`),
+      ...Object.keys(IMPORTED.points["slice-tier"].inputs).map((k) => `points.slice-tier.inputs.${k}`),
+      ...Object.keys(IMPORTED.points["ship-skip"].inputs).map((k) => `points.ship-skip.inputs.${k}`),
     ]);
     // With the inputs renamed, nothing else changes and both validate.
     const points = parsePoints(text(renamed()), "points.json");
@@ -142,7 +143,7 @@ describe("the decision points schema (#2738)", () => {
 
   test("the reference workspace's points validate", () => {
     const points = parsePoints(readFileSync(join(REPO, "reference-workspace", "decisions", "points.json"), "utf-8"), "decisions/points.json");
-    expect(Object.keys(points)).toEqual(["slice-tier", "ship-skip"]);
+    expect(Object.keys(points)).toEqual(["slice-tier", "ship-skip", "finding-triage", "needs-a-decision"]);
   });
 
   test("a point whose chain does not end in a quorum is refused", () => {
@@ -156,7 +157,7 @@ describe("the decision points schema (#2738)", () => {
 
   test("a point with an unknown input is refused, and so is a row testing an undeclared one", () => {
     const v = renamed() as unknown as { points: Record<string, { inputs: Record<string, string>; deciders: { rows?: { when: Record<string, unknown> }[] }[] }> };
-    v.points["slice-tier"].inputs["contract.size"] = "chud's contract, which the read contract has no output for";
+    v.points["slice-tier"].inputs["contract.size"] = "a contract, which the read contract has no output for";
     expect(problems(v)).toEqual([
       {
         field: "points.slice-tier.inputs.contract.size",
@@ -168,7 +169,7 @@ describe("the decision points schema (#2738)", () => {
     expect(problems(w)).toEqual([{ field: "points.slice-tier.deciders.0.rows.0.when.work-item.tier", message: expect.stringContaining("is not one of this point's inputs") }]);
   });
 
-  test("the schema and the code refuse the rest of what chud refused, and an alias model id", () => {
+  test("the schema and the code refuse the rest of what an imported points file can get wrong, and an alias model id", () => {
     const cases: [(p: Record<string, unknown>) => void, RegExp][] = [
       [(p) => ((p.deciders as Record<string, unknown>[])[1].model = "jev-latest"), /is an alias/],
       [(p) => ((p.deciders as Record<string, unknown>[])[1].count = 2), /is only for a quorum decider/],

package/src/workspace/points.ts

@@ -20,7 +20,7 @@
  * runtime's decider or a test's stub supplies. Without one, a model decider is
  * not asked and the chain moves on.
  *
- * Taken from chud's `packages/runtime/src/decide.mjs` at 43afcf1: the chain,
+ * Ported from chud's `packages/runtime/src/decide.mjs` at 43afcf1: the chain,
  * the observation rule, the point version and the inputs hash. The records
  * are chant records: `decide.ts` writes them, and {@link applyAnswers} warns
  * about them on read.
@@ -48,7 +48,7 @@ export const POINT_INPUT_OUTPUTS = {
   record: { schema: "records", def: "record", description: "a record of any kind, as records --json lists it" },
   decision: { schema: "records", def: "record", description: "a decision record, as records --json lists it" },
   "work-item": { schema: "records", def: "record", description: "a work item record, as records --json lists it (#2683)" },
-  finding: { schema: "intent", def: "finding", description: "a finding of graph --intent" },
+  finding: { schema: "intent", def: "finding", description: "a finding of graph --intent, or of check --changes (#2794)" },
   region: { schema: "intent", def: "region", description: "the region an intent graph covers" },
   commit: { schema: "intent", def: "commit", description: "a commit in an intent graph's window" },
   member: { schema: "ls", def: "member", description: "a member, as ls lists it" },
@@ -71,7 +71,6 @@ export function inputOutput(name: string): string {
 export type QuestionType = "noul" | "choice" | "score";
 
 export interface Question {
-  /** `boolean` in a points file is read as `noul`. */
   type: QuestionType;
   instructions: string;
   criteria: Record<string, string> | string[];
@@ -220,20 +219,9 @@ export function schemaProblems(data: unknown): PointProblem[] {
   return out;
 }
 
-/** `boolean` read as `noul`. The declaration is otherwise kept as written. */
-function normalise(points: Record<string, Point>): Record<string, Point> {
-  const out: Record<string, Point> = {};
-  for (const [name, p] of Object.entries(points)) {
-    const type = (p.question.type as string) === "boolean" ? "noul" : p.question.type;
-    out[name] = { ...p, question: { ...p.question, type } };
-  }
-  return out;
-}
-
 /**
- * Parse and validate a points file's text. Returns its points, with
- * `boolean` read as `noul`. Throws a {@link PointsError} naming the file and
- * each field.
+ * Parse and validate a points file's text. Returns its points. Throws a
+ * {@link PointsError} naming the file and each field.
  */
 export function parsePoints(text: string, file: string): Record<string, Point> {
   let data: unknown;
@@ -244,7 +232,7 @@ export function parsePoints(text: string, file: string): Record<string, Point> {
   }
   const problems = schemaProblems(data);
   if (problems.length > 0) throw new PointsError(file, problems);
-  const points = normalise((data as { points: Record<string, Point> }).points);
+  const points = (data as { points: Record<string, Point> }).points;
   const more = pointProblems(points);
   if (more.length > 0) throw new PointsError(file, more);
   return points;

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

@@ -192,7 +192,15 @@ describe("every schema against the reference workspace (#2543)", () => {
       const doc = await workspacePoints({ cwd: FIXTURE, at });
       expectValid(doc);
       if ("error" in doc) throw new Error(doc.error.message);
-      expect(doc.points.map((p) => p.name)).toEqual(["slice-tier", "ship-skip"]);
+      expect(doc.points.map((p) => p.name)).toEqual(["slice-tier", "ship-skip", "finding-triage", "needs-a-decision"]);
+      const sliceTier = doc.points.find((p) => p.name === "slice-tier")!;
+      expect(sliceTier.criteria).toEqual({
+        small: "A haiku-class builder. The work item fits the small limits.",
+        medium: "A mid-size builder. The work item fits the medium limits.",
+        large: "The largest builder. The work item is bigger than the medium limits.",
+      });
+      const shipSkip = doc.points.find((p) => p.name === "ship-skip")!;
+      expect(shipSkip.criteria).toEqual({ true: "An agent may pass the gate for this release.", false: "A person approves the release at the gate." });
     }
     const open = await workspacePoints({ cwd: FIXTURE, open: true });
     expectValid(open);

package/src/workspace/reason-codes.test.ts

@@ -9,6 +9,7 @@ import { readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, test } from "vitest";
 import { REPO } from "./__fixtures__/contract-repo";
+import { CHANGES_ERROR_CODES, CHANGES_FINDING_CODES } from "./changes";
 import { MEMBER_RUN_REASON_CODES } from "./compose-graph";
 import { COMPOSITES_ENVIRONMENT_REASON_CODES, COMPOSITES_ERROR_CODES, COMPOSITES_REASON_CODES, COMPOSITES_RUNTIME_REASON_CODES } from "./composites";
 import { WORKSPACE_ERROR_CODES } from "./declaration";
@@ -26,7 +27,10 @@ import { RECORDS_SINCE_ERROR_CODES, RECORDS_SINCE_REASON_CODES } from "./records
 import { STATUS_ERROR_CODES, STATUS_GATE_REASON_CODES, STATUS_REASON_CODES, STATUS_STEWARD_REASON_CODES } from "./status";
 import { WORK_WARNING_CODES } from "./work";
 import { BOX_FINDING_CODES } from "./checks/boxes";
-import { WORK_ERROR_CODES, WORK_LEASE_REFUSALS } from "./work-cli";
+import { DIAGRAM_FINDING_CODES } from "./checks/diagrams";
+import { WORK_ERROR_CODES, WORK_HISTORY_ERROR_CODES, WORK_LEASE_REFUSALS } from "./work-cli";
+import { WORK_EVIDENCE_ERROR_CODES } from "./work-evidence";
+import { RECORD_FINDING_CODES } from "./checks/records";
 import { ANSWER_WARNING_CODES } from "./points";
 import { POINTS_ERROR_CODES, POINTS_SOURCE_REASON_CODES } from "./points-cli";
 import { POINTS_WRITE_ERROR_CODES } from "./decide";
@@ -42,6 +46,7 @@ const PER_COMMAND: Record<string, readonly string[]> = {
   CHECK_CODES,
   CHECK_ERROR_CODES,
   BOX_FINDING_CODES,
+  DIAGRAM_FINDING_CODES,
   STATUS_REASON_CODES,
   STATUS_ERROR_CODES,
   STATUS_GATE_REASON_CODES,
@@ -62,12 +67,17 @@ const PER_COMMAND: Record<string, readonly string[]> = {
   INTENT_ERROR_CODES,
   INTENT_FINDING_CODES,
   INTENT_REASON_CODES,
+  CHANGES_FINDING_CODES,
+  CHANGES_ERROR_CODES,
   COMPOSITES_ERROR_CODES,
   COMPOSITES_REASON_CODES,
   COMPOSITES_RUNTIME_REASON_CODES,
   COMPOSITES_ENVIRONMENT_REASON_CODES,
   WORK_ERROR_CODES,
+  WORK_HISTORY_ERROR_CODES,
   WORK_LEASE_REFUSALS,
+  WORK_EVIDENCE_ERROR_CODES,
+  RECORD_FINDING_CODES,
   ANSWER_WARNING_CODES,
   POINTS_ERROR_CODES,
   POINTS_SOURCE_REASON_CODES,
@@ -147,11 +157,11 @@ describe("the closed list of reason codes", () => {
   });
 
   test("a plugin's finding codes are in its own namespace, outside the list, and the intent schema accepts them (#2656)", () => {
-    expect(isPluginCode("plugin:chud:contract-criteria-changed")).toBe(true);
-    expect(isPluginCode("plugin:chud:contract-criteria-changed", "chud")).toBe(true);
-    expect(isPluginCode("plugin:chud:contract-criteria-changed", "units")).toBe(false);
-    for (const bad of ["plugin:chud", "plugin::x", "plugin:chud:Upper", "plugin:chud:a:b", "intent-commit-bare", 7]) expect(isPluginCode(bad), String(bad)).toBe(false);
-    expect(isReasonCode("plugin:chud:contract-criteria-changed")).toBe(false);
+    expect(isPluginCode("plugin:acme:contract-criteria-changed")).toBe(true);
+    expect(isPluginCode("plugin:acme:contract-criteria-changed", "acme")).toBe(true);
+    expect(isPluginCode("plugin:acme:contract-criteria-changed", "units")).toBe(false);
+    for (const bad of ["plugin:acme", "plugin::x", "plugin:acme:Upper", "plugin:acme:a:b", "intent-commit-bare", 7]) expect(isPluginCode(bad), String(bad)).toBe(false);
+    expect(isReasonCode("plugin:acme:contract-criteria-changed")).toBe(false);
     const { validate } = contract(intentSchema);
     const finding = (code: string) => ({ id: `finding:${code}:1`, kind: "finding", code, message: "m", concerns: [] });
     const doc = (code: string) => ({
@@ -168,9 +178,9 @@ describe("the closed list of reason codes", () => {
       reasons: [],
       summary: { commits: 0, decisions: 0, artifacts: 0, findings: 1 },
     });
-    expect(validate(doc("plugin:chud:contract-criteria-changed"))).toBe(true);
+    expect(validate(doc("plugin:acme:contract-criteria-changed"))).toBe(true);
     expect(validate(doc("intent-commit-bare"))).toBe(true);
-    expect(validate(doc("plugin:chud:Nope"))).toBe(false);
+    expect(validate(doc("plugin:acme:Nope"))).toBe(false);
     expect(validate(doc("made-up-code"))).toBe(false);
   });
 

package/src/workspace/reason-codes.ts

@@ -60,13 +60,15 @@ export const REASONS = {
   // A member's stewards status can't fully list (status, #2731).
   "stewards-unreadable": "An *.op.ts file could not be imported, so a steward it declares may be missing.",
   "stewards-conflict": "A steward was dropped: its name, or an Op it lists, belongs to another steward.",
-  "steward-runs-unreadable": "Reading an Op's run ledger failed, so its last run is null.",
+  "steward-runs-unreadable": "Reading an Op's run ledger, or a ConvergeOp's converge ledger, failed, so its last run or last tick is null.",
   // A record that isn't valid (records).
   "record-unparseable": "No front matter, a YAML error or a value outside the JSON subset of YAML, or for a JSON kind a file that is not one object or repeats a member name.",
   "record-schema-invalid": "The record's front matter, or its JSON object, does not match the kind's schema.",
   "record-id-duplicate": "Another record earlier in path order has the same id.",
   "record-supersedes-unknown": "A supersedes link names an id no record has.",
   "record-supersedes-conflict": "A second closed record supersedes a record another one already superseded.",
+  "record-remediates-unknown": "A remediates link names an id no record has.",
+  "record-remediates-not-closed": "A remediates link names a record that isn't closed; a record still open is amended instead.",
   // A review session that isn't valid (records, #2673).
   "session-seal-mismatch": "A closed session's seal is not the digest of its text: the session changed after it closed.",
   "session-verdict-unknown-record": "A session's verdict names a record that none of the session kind's subject records has.",
@@ -86,6 +88,8 @@ export const REASONS = {
   "work-done-unpinned": "A work record is done and its evidence list is empty: nothing shows the work was done.",
   "work-closed-without-date": "A work record is done or dropped and has no closing date.",
   "work-done-gap-open": "A work record is done, and the finding it came from still fires on its region. graph --intent raises it, and records does by walking that region.",
+  "work-acceptance-unmet": "A work record is done, and one of its acceptance criteria has no passing evidence of the verification it expects. check fails on it (WSP117).",
+  "work-acceptance-self-verified": "A passing manual verdict on a work record's criterion names the record's implementer, so it does not count: a manual verdict comes from someone else.",
   // An answer to a decision point that is valid but warned about (records, points, ws-058, #2739).
   "answer-points-unreadable": "The points file the answer kind names can't be read, or is not valid.",
   "answer-point-unknown": "The answer's point is not declared in the points file the answer kind names.",
@@ -136,7 +140,8 @@ export const REASONS = {
   "point-inputs-invalid": "The inputs given to an ask are not a JSON object of the point's declared inputs.",
   "point-decider-failed": "A model decider that fails closed (unreachable: fail) could not answer, so the ask wrote nothing.",
   "answer-not-candidate": "The people's answer is not one of the question's candidates.",
-  "quorum-not-met": "Too few of the people who answered count toward the point's quorum: distinct, not holding the agent role, and holding one of its roles when it names any.",
+  "quorum-not-met": "Too few of the people who answered count toward the point's quorum: distinct, not holding the agent role, not the steward that asked, and holding one of its roles when it names any.",
+  "answer-in-steward-turn": "The answer was given during a steward's turn, or by a process it started: a steward never answers a decision point, and a person answers it through hud or at a shell.",
   // records --since that fails (#2673).
   "since-rev-unknown": "--since names no commit, or a session with no opening revision and no commit that added it.",
   "since-session-unknown": "--since has the shape of a session id and names no commit, and no session the kind or the declaration reads has that id.",
@@ -164,6 +169,9 @@ export const REASONS = {
   "intent-decision-unimplemented": "A decided decision constrains the region, no work item that is not dropped implements it, and no commit falls in its window.",
   "intent-work-blocked": "A work item constraining the region has commits in its window while a work item it needs is not done.",
   "intent-work-open-decided-code": "Commits in the region are a decision's own work while the work item implementing that decision is still open.",
+  // The forward coverage check (check --changes, #2773): findings, one per changed path.
+  "change-uncovered": "A path the diff changes is covered by no current decided record and no open work item, by path or by its member.",
+  "change-out-of-scope": "A record in hand for the change, such as the work item it is for or a decision that item implements, lists a path the diff changes in its out_of_scope.",
   // Composite instances joined to components (graph --composites, #2662): why the list is empty or has no component.
   "composites-no-chant-member": "No member of kind chant was read, so nothing declares a composite instance or a component.",
   "composites-none-declared": "The members read declare no composite instance.",
@@ -175,14 +183,25 @@ export const REASONS = {
   "environments-none-declared": "The member's chant.config.ts declares no environments, so only local and the environments in its ledger are listed.",
   "environments-ledger-undeclared": "The member's ledger has releases in an environment its config's environments don't cover, so chant run --env would refuse it and it is not listed.",
   "environments-ledger-unreadable": "The chant/lifecycle branch exists and the member's ledger environments could not be listed.",
+  // A declared diagram's source or render (check, #2764). Each is also a WSP finding.
+  "diagram-source-missing": "A declared diagram's source file does not exist in the tree read.",
+  "diagram-render-missing": "A declared diagram's render file does not exist in the tree read.",
+  "diagram-render-drift": "A declared diagram records a sourceHash, and the source's bytes now hash to something else: the render is stale for its source.",
   // A box that holds a credential (check, #2726). Each is also a WSP finding.
   "box-credential-declared": "A file in a box member's directory carries a literal secret: a credential's shape, or a literal where a credential goes. A variable or secret-manager reference is not one.",
   "box-capability-unbrokered": "A capability in a member's box block names no broker, so the box would hold its credential.",
+  // The credential fountain itself hands a persistent box (check, #2780). Also a WSP finding.
+  "box-fountain-callback-undeclared": "A box member builds a fountain Box, whose persistent sandbox fountain gives a callback token scoped to its owner, and the member's box block does not declare the fountain-callback capability brokered by fountain with scope owner.",
+  // A box's intent, the decision record its box block names (check, #2850). Each is also a WSP finding.
+  "box-intent-unknown": "A box block names an intent, and no record of a declared kind named decision has that id.",
+  "box-intent-unconstrained": "The decision record a box names as its intent constrains no member or path of this workspace: no member: entry for a declared member and no path: entry at, above or inside one's directory.",
   // The work lease (chant workspace work claim|renew|release, #2732): why the command could not run.
   "work-kind-missing": "No work kind to find the item in: --kind names a kind with no work block, or the declaration names no work kind.",
   "work-kind-ambiguous": "More than one declared work kind has a record with the id, so --kind must name one.",
   "work-item-unknown": "No work record has the id, so there is nothing to lease.",
   "work-item-closed": "A claim on a work item in a closed state, such as done or dropped: there is no work left to claim.",
+  // Evidence attached to a criterion under the run's work lease (#2772): why it was refused. Nothing is written.
+  "work-criterion-unknown": "The work record lists no acceptance criterion with the id the evidence names, or its kind has no acceptance criteria.",
   // The work lease: why a claim, renew or release was refused (exit 2).
   "lease-held": "Someone holds a live lease on the work item: another worker, or, for a claim, the same one.",
   "lease-not-held": "Nobody holds a live lease on the work item: it expired, was released or was never claimed.",

package/src/workspace/records-amend.schema.json

@@ -180,6 +180,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/records-cli.ts

@@ -24,7 +24,7 @@ import { formatError } from "../cli/format";
 import type { CommandContext } from "../cli/registry";
 import { findWorkspaceRoot } from "../project-root";
 import { fileDigest, isWorkspacePath } from "./record-assets";
-import { gitRevisionSource, gitRoot, resolveRevision, workingTreeSource } from "./record-source";
+import { gitRevisionSource, gitRoot, resolveRevision, workingTreeSource, type RecordSource } from "./record-source";
 import { declaredRecordKinds, readDeclaration, WorkspaceReadError, type RecordKindDeclaration } from "./declaration";
 import { declaredKindFile } from "./declared-kinds";
 import { locateWorkspace } from "./which-chant";
@@ -249,7 +249,15 @@ function gitHistory(top: string, rev: string, prefix: string): RecordHistory {
  * with each pin checked in the same tree. Throws a {@link RecordReadError}.
  * `chant workspace graph` and `check` read records through this too.
  */
-export async function readRecordsFor(query: Omit<RecordsQuery, "base">): Promise<RecordsRead> {
+export async function readRecordsFor(
+  query: Omit<RecordsQuery, "base"> & {
+    /**
+     * Lay more records over a working-tree read, such as the answer records a
+     * steward keeps on the lifecycle ledger (#2786). Not called with `at`.
+     */
+    overlay?: (source: RecordSource, kind: { loaded: LoadedRecordKind; root: string }) => Promise<RecordSource>;
+  },
+): Promise<RecordsRead> {
   // git reports its top through symlinks resolved (/var is /private/var on
   // macOS), so the directory has to be too, or record paths leave the repository.
   const cwd = realpathOr(query.cwd);
@@ -266,6 +274,7 @@ export async function readRecordsFor(query: Omit<RecordsQuery, "base">): Promise
     source = gitRevisionSource(top, at);
     assets = gitTree(top, at, workspaceRoot === "." ? "" : workspaceRoot);
   }
+  if (at === null && query.overlay) source = await query.overlay(source, { loaded, root });
   const history = top ? gitHistory(top, at ?? "HEAD", workspaceRoot) : undefined;
   // A session kind's verdicts name records of another kind, read from the same tree (#2673).
   let subjects: { records: RecordEntry[]; reviews: string } | undefined;
@@ -501,6 +510,14 @@ export async function runWorkspaceRecords(ctx: CommandContext): Promise<number>
  * names, or, when it names none or there is no declaration, the error it has
  * always been. A kind whose read fails is listed with its error, the others
  * are still read, and the exit code is 1.
+ *
+ * Locating the declaration itself can fail before any kind is known. For
+ * `not-a-git-repository` and `revision-unknown`, the codes a single kind's
+ * read can also fail with (#2860), `--json` prints the same
+ * `{ $schema, contract, error: { code, message } }` document that read
+ * failure would, so a reader of `--json` never sees a silent exit 1. A
+ * declaration-level code the schema doesn't carry (`declaration-invalid` and
+ * the rest of `WorkspaceErrorCode`) still prints text on stderr only.
  */
 async function runDeclaredRecords(args: CommandContext["args"]): Promise<number> {
   if (args.require !== undefined && args.require !== "attested") {
@@ -512,7 +529,12 @@ async function runDeclaredRecords(args: CommandContext["args"]): Promise<number>
     declared = declaredKindFiles(process.cwd(), args.at);
   } catch (err) {
     if (!(err instanceof WorkspaceReadError)) throw err;
-    console.error(formatError({ message: `${err.code}: ${err.describe()}; without --kind, the declaration names the record kinds`, hint: USAGE }));
+    const message = `${err.describe()}; without --kind, the declaration names the record kinds`;
+    if (args.json && (err.code === "not-a-git-repository" || err.code === "revision-unknown")) {
+      console.log(JSON.stringify({ $schema: RECORDS_OUTPUT_SCHEMA_ID, contract: RECORDS_CONTRACT_VERSION, error: { code: err.code, message } }, null, 2));
+    } else {
+      console.error(formatError({ message: `${err.code}: ${message}`, hint: USAGE }));
+    }
     return 1;
   }
   if (declared.length === 0) {
@@ -602,9 +624,10 @@ function formatRecords(records: RecordView[], summary: { total: number; valid: n
     const title = typeof r.data?.title === "string" ? r.data.title : r.path;
     const flag = r.valid ? "" : "  INVALID";
     const superseded = r.supersededBy ? `  superseded by ${r.supersededBy}` : "";
+    const remediated = r.remediatedBy.length > 0 ? `  remediated by ${r.remediatedBy.join(", ")}` : "";
     const attested = r.provenance.level === "attested" ? `  attested by ${r.provenance.principal}` : "";
     const sealed = r.attested === true ? `  sealed by ${(r.data?.[RECORD_SEAL_FIELD] as { signer: string }).signer}` : "";
-    lines.push(`${(r.id ?? "-").padEnd(idWidth)}  ${(r.state ?? "-").padEnd(stateWidth)}  ${title}${superseded}${attested}${sealed}${flag}`);
+    lines.push(`${(r.id ?? "-").padEnd(idWidth)}  ${(r.state ?? "-").padEnd(stateWidth)}  ${title}${superseded}${remediated}${attested}${sealed}${flag}`);
     if (r.ready !== undefined) {
       const blocked = (r.blockedBy ?? []).map((b) => `${b.id} (${b.state ?? "unknown"})`).join(", ");
       const implemented = (r.implements ?? []).map((d) => `${d.id} (${d.state ?? "unknown"})`).join(", ");

package/src/workspace/records-close.schema.json

@@ -176,6 +176,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/records-formats.test.ts

@@ -3,11 +3,11 @@
  * kinds without a lifecycle, a supersedes field of bare ids, schema files a
  * schema `$ref`s, and content-addressed ids.
  *
- * The fixtures are shaped like chud's records (jhgaylor/chud#78: units,
- * evidence named by the hash of its bytes, sessions, driver closures and
- * Markdown contracts, with draft-07 schemas that `$ref` a shared
- * `defs.schema.json`), trimmed to the fields that matter here. Each one reads
- * through a kind file alone: no reader code.
+ * The fixtures are shaped like a development-model plugin's records (ported
+ * from chud, jhgaylor/chud#78: units, evidence named by the hash of its
+ * bytes, sessions, driver closures and Markdown contracts, with draft-07
+ * schemas that `$ref` a shared `defs.schema.json`), trimmed to the fields
+ * that matter here. Each one reads through a kind file alone: no reader code.
  */
 
 import { execFileSync } from "node:child_process";
@@ -29,7 +29,7 @@ const validateOutput = new Ajv2020({ strict: true, allErrors: true }).compile(sc
 let root: string;
 beforeEach(() => {
   root = realpathSync(mkdtempSync(join(tmpdir(), "chant-record-formats-")));
-  writeChudModel();
+  writeAcmeModel();
 });
 afterEach(() => rmSync(root, { recursive: true, force: true }));
 
@@ -72,9 +72,9 @@ async function failure(kind: string): Promise<{ code: string; message: string }>
 const codes = (r: { reasons: Array<{ code: string }> }) => r.reasons.map((x) => x.code);
 const warned = (r: { warnings: Array<{ code: string }> }) => r.warnings.map((x) => x.code);
 
-// ── chud's model, as kind files ──────────────────────────────────────────────
+// ── acme's model, as kind files ──────────────────────────────────────────────
 
-const BASE = "https://schemas.example.test/chud-runtime/v0";
+const BASE = "https://schemas.example.test/acme-runtime/v0";
 const ref = (name: string) => ({ $ref: `defs.schema.json#/definitions/${name}` });
 
 const DEFS = {
@@ -106,7 +106,7 @@ const UNIT_SCHEMA = {
     scope: { type: "array", minItems: 1, items: ref("text") },
     base_commit: ref("gitId"),
     result: { type: "object", required: ["commit", "ref"], properties: { commit: { type: ["string", "null"] }, ref: { type: ["string", "null"] } } },
-    // A bare hash, as chud writes today, or a pin chant checks.
+    // A bare hash, as acme writes today, or a pin chant checks.
     evidence: {
       type: "array",
       items: { anyOf: [ref("sha256"), { type: "object", required: ["path", "sha256"], properties: { path: ref("text"), sha256: ref("sha256") } }] },
@@ -178,7 +178,7 @@ const CONTRACT_SCHEMA = {
   },
 };
 
-/** A kind file: data only, the way chud's model package would ship it. */
+/** A kind file: data only, the way acme's model package would ship it. */
 function kindFile(kind: Record<string, unknown>): string {
   return `export const recordKind = ${JSON.stringify(kind, null, 2)};\n`;
 }
@@ -235,7 +235,7 @@ const KINDS: Record<string, Record<string, unknown>> = {
   },
 };
 
-function writeChudModel(): void {
+function writeAcmeModel(): void {
   write("design/schemas/defs.schema.json", json(DEFS));
   write("design/schemas/unit.schema.json", json(UNIT_SCHEMA));
   write("design/schemas/evidence.schema.json", json(EVIDENCE_SCHEMA));
@@ -304,7 +304,7 @@ test("the output schema lists exactly the formats a kind file may name", () => {
 });
 
 describe("format json", () => {
-  test("chud's units, sessions and driver closures read through kind files alone", async () => {
+  test("acme's units, sessions and driver closures read through kind files alone", async () => {
     write("design/units/U-0001.json", json(unit("U-0001", { outcome: "done", closed_at: "2026-09-24T11:00:00.000Z" })));
     write("design/units/U-0002.json", json(unit("U-0002")));
     write("design/sessions/S-0001.json", json(SESSION));
@@ -407,7 +407,7 @@ describe("the write commands through a declared kind (#2680)", () => {
   test.each(["unit", "evidence"])("refuse the declared %s kind with write-usage-invalid", async (kind) => {
     write(
       "chant.workspace.json",
-      json({ name: "chud", schema: 1, members: [{ name: "design", dir: "design", kind: "other", because: "chud's records" }], records: [{ kind: `design/${kind}.kind.mjs` }] }),
+      json({ name: "acme", schema: 1, members: [{ name: "design", dir: "design", kind: "other", because: "acme's records" }], records: [{ kind: `design/${kind}.kind.mjs` }] }),
     );
     write("design/units/U-0001.json", json(unit("U-0001")));
     write("fields.json", "{}\n");
@@ -510,7 +510,7 @@ describe("kinds without a lifecycle", () => {
   const contract = (id: string, status: string, supersedes?: string | string[]) =>
     `---\nid: "${id}"\nstatus: "${status}"\n${supersedes === undefined ? "" : `supersedes: ${JSON.stringify(supersedes)}\n`}---\n\n# ${id}\n`;
 
-  test("supersedes as one id, as chud's contracts write it, derives supersededBy under approval ranks", async () => {
+  test("supersedes as one id, as acme's contracts write it, derives supersededBy under approval ranks", async () => {
     write("design/contracts/C-001-first.md", contract("C-001", "approved"));
     write("design/contracts/C-002-second.md", contract("C-002", "approved", "C-001"));
     write("design/contracts/C-003-draft.md", contract("C-003", "draft", "C-002"));
@@ -588,7 +588,7 @@ describe("schema.refs", () => {
 // ── 4. Content-addressed ids ─────────────────────────────────────────────────
 
 describe("idFrom sha256", () => {
-  test("chud's evidence reads with the hash of its bytes as its id, in the tree and under --at", async () => {
+  test("acme's evidence reads with the hash of its bytes as its id, in the tree and under --at", async () => {
     const h = writeEvidence();
     const bytes = readFileSync(join(root, "design", "evidence", `${h}.json`));
     expect(createHash("sha256").update(bytes).digest("hex")).toBe(h);

package/src/workspace/records-new.schema.json

@@ -169,6 +169,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/records-review.schema.json

@@ -264,6 +264,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/records-sessions-write.e2e.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Sessions from a UI (#2693), through the command line: `records close` with
+ * the declared session kind, and `records --since <session id>` without
+ * --kind. Four CLI spawns put it near 13s on CI, close to the unit shards'
+ * per-test budget, so it runs in the test-e2e job (#2817). The rest of #2693
+ * is in records-sessions-write.test.ts.
+ */
+
+import { spawnSync } from "node:child_process";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { afterAll, describe, expect, test } from "vitest";
+import { cleanScratch, commitAll, contract, git, REPO } from "./__fixtures__/contract-repo";
+import { declareSessions, newSessionFields, sessionsRepo, SESSIONS_KIND } from "./__fixtures__/sessions";
+import closeSchema from "./records-close.schema.json";
+import { type RecordsSinceDocument } from "./records-since";
+import sinceSchema from "./records-since.schema.json";
+import { newRecord } from "./records-write";
+import newSchema from "./records-new.schema.json";
+
+afterAll(cleanScratch);
+
+const close = contract(closeSchema);
+const since = contract(sinceSchema);
+const created = contract(newSchema);
+
+/** The reference fixture with a declaration, committed. */
+function declared(): string {
+  const root = sessionsRepo();
+  declareSessions(root);
+  commitAll(root, "declare");
+  return root;
+}
+
+/** Open S-0002 through records new, and commit it. */
+async function opened(root: string): Promise<{ path: string; head: string }> {
+  const head = git(root, "rev-parse", "HEAD");
+  const doc = await newRecord({ kind: SESSIONS_KIND, fields: newSessionFields(), cwd: root });
+  created.expectValid(doc);
+  if ("error" in doc) throw new Error(`${doc.error.code}: ${doc.error.message}`);
+  expect(doc.id).toBe("S-0002");
+  commitAll(root, "open S-0002");
+  return { path: doc.path, head };
+}
+
+describe("records --since <session id> (#2693)", () => {
+  test(
+    "through the CLI: close with the declared session kind, and --since <session id> without --kind",
+    async () => {
+      const root = declared();
+      await opened(root);
+      const run = (...args: string[]) =>
+        spawnSync(process.execPath, ["--import", pathToFileURL(join(REPO, "node_modules/tsx/dist/loader.mjs")).href, join(REPO, "packages/core/src/cli/main.ts"), "workspace", "records", ...args], {
+          cwd: root,
+          encoding: "utf-8",
+          env: { ...process.env, NO_COLOR: "1" },
+          timeout: 60_000,
+        });
+      const closed = run("close", "S-0002");
+      expect(closed.status, closed.stderr).toBe(0);
+      close.expectValid(JSON.parse(closed.stdout));
+      const again = run("close", "S-0002");
+      expect(again.status).toBe(1);
+      expect(JSON.parse(again.stdout).error.code).toBe("record-closed");
+      commitAll(root, "close");
+      const set = run("--since", "S-0002", "--json");
+      expect(set.status, set.stderr).toBe(0);
+      const kinds = JSON.parse(set.stdout).kinds as RecordsSinceDocument[];
+      for (const k of kinds) since.expectValid(k);
+      expect(kinds.map((k) => ("session" in k ? k.session?.id : null))).toEqual(["S-0002", "S-0002"]);
+      const text = run("--kind", SESSIONS_KIND, "--since", "S-0002");
+      expect(text.stdout).toContain("session S-0002 (closed)");
+      expect(text.stdout).toContain("S-0002  new, closed");
+    },
+    120_000,
+  );
+});