@intentius/chant 0.93.0 → 0.94.0

package/src/workspace/checks/boxes.ts

@@ -37,11 +37,23 @@
  * imports `Box` from `@intentius/chant-lexicon-fountain` and calls it, read as
  * syntax and never run. Upstream, managoat/fountain#2497 asks for a way to run
  * a persistent agent with no callback token.
+ *
+ * WSP126 (`box-intent-unknown`) and WSP127 (`box-intent-unconstrained`), #2850,
+ * read the decision record a box block names as its intent (`box-intent.ts`).
+ * WSP126 fails when no record of a declared kind named decision has the id.
+ * WSP127 warns when the record's constrains names no member or path of this
+ * workspace at all: no `member:` entry for a declared member and no `path:`
+ * entry at, above or inside one's directory. It need not reach the box's own
+ * member: the decision an intent names can constrain the member whose app the
+ * box runs, on a workspace where the box block sits on a different member,
+ * the box's steward (studio's template, #2857). Both read the working
+ * tree's records, so neither runs under `--at`.
  */
 
 import * as ts from "typescript";
 import type { WorkspaceCheck, WorkspaceCheckContext, WorkspaceDiagnostic } from "../checks";
 import type { Member } from "../declaration";
+import { constrainsWorkspace } from "../box-intent";
 import type { ReasonCode } from "../reason-codes";
 import { joinPath, skippedDir, type WorkspaceTree } from "../tree";
 import { BOX_ISOLATION_CHECKS } from "./box-isolation";
@@ -53,11 +65,15 @@ export const BOX_FINDING_CODES = [
   "box-isolation-collision",
   "box-isolation-literal",
   "box-fountain-callback-undeclared",
+  "box-intent-unknown",
+  "box-intent-unconstrained",
 ] as const satisfies readonly ReasonCode[];
 
 export const WSP_BOX_CREDENTIAL = "WSP121";
 export const WSP_BOX_UNBROKERED = "WSP122";
 export const WSP_BOX_FOUNTAIN_CALLBACK = "WSP125";
+export const WSP_BOX_INTENT_UNKNOWN = "WSP126";
+export const WSP_BOX_INTENT_UNCONSTRAINED = "WSP127";
 
 /** The fountain lexicon's package, whose `Box` composite runs a persistent sandbox. */
 const FOUNTAIN_LEXICON = "@intentius/chant-lexicon-fountain";
@@ -439,4 +455,54 @@ export const BOX_CHECKS: readonly WorkspaceCheck[] = [
       return out;
     },
   },
+  {
+    id: WSP_BOX_INTENT_UNKNOWN,
+    name: "box-intent-unknown",
+    description: "The intent a box block names is the id of a decision record: a record of a declared kind named decision.",
+    severity: "error",
+    configurable: true,
+    check(ctx) {
+      const out: WorkspaceDiagnostic[] = [];
+      for (const i of ctx.facts?.boxIntents ?? []) {
+        if (i.record) continue;
+        out.push({
+          checkId: this.id,
+          severity: this.severity,
+          code: "box-intent-unknown",
+          message: `box-intent-unknown: member ${i.member}'s box names the intent ${i.id}, and ${i.why}; propose the decision with chant workspace records new, or fix the id`,
+          entity: i.member,
+          pointer: i.pointer,
+        });
+      }
+      return out;
+    },
+  },
+  {
+    id: WSP_BOX_INTENT_UNCONSTRAINED,
+    name: "box-intent-unconstrained",
+    description:
+      "The decision record a box names as its intent constrains a member or path of this workspace: member:<a declared member's name>, or a path: entry at, above or inside a declared member's directory. It need not be the box's own member: a box one member runs can be what a decision about another member constrains.",
+    severity: "warning",
+    configurable: true,
+    check(ctx) {
+      const out: WorkspaceDiagnostic[] = [];
+      const members = ctx.declaration.members;
+      for (const i of ctx.facts?.boxIntents ?? []) {
+        if (!i.record) continue;
+        if (i.record.constrains.some((c) => constrainsWorkspace(c, members))) continue;
+        out.push({
+          checkId: this.id,
+          severity: this.severity,
+          code: "box-intent-unconstrained",
+          message:
+            `box-intent-unconstrained: member ${i.member}'s box names the intent ${i.id} (${i.record.path}), whose constrains ` +
+            (i.record.constrains.length === 0 ? "is empty" : `names ${i.record.constrains.join(", ")}`) +
+            `, and none of it is a member or path of this workspace; add member:<name> for the member the intent is about, or a path: entry at, above or inside a member's directory`,
+          entity: i.member,
+          pointer: i.pointer,
+        });
+      }
+      return out;
+    },
+  },
 ];

package/src/workspace/checks.ts

@@ -33,6 +33,7 @@
  * | WSP121, WSP122 | boxes: no literal credential, every capability brokered (#2726) |
  * | WSP123, WSP124 | box isolation: no shared port, state path or cookie, no literal machine path (#2727) |
  * | WSP125 | boxes: a fountain Box declares the callback token fountain gives its sandbox (#2780) |
+ * | WSP126, WSP127 | box intent: the decision record a box names exists, and constrains a member or path of this workspace (#2850, #2857) |
  * | WSP131 to WSP133 | diagram artifacts: source and render exist, a recorded source hash still matches (#2764) |
  */
 
@@ -54,6 +55,7 @@ import { RECORD_CHECKS, type RecordFacts } from "./checks/records";
 import { BOX_CHECKS } from "./checks/boxes";
 import { DIAGRAM_CHECKS } from "./checks/diagrams";
 import { loadDeclaredKinds, type DeclaredKind } from "./declared-kinds";
+import { resolveBoxIntents, type ResolvedBoxIntent } from "./box-intent";
 
 /**
  * What the checks beyond the declaration read, gathered from the checkout
@@ -71,6 +73,8 @@ export interface WorkspaceFacts {
   records?: RecordFacts;
   /** The record kinds the declaration names, each loaded, or only looked for under `--at` (#2680). */
   declaredKinds?: readonly DeclaredKind[];
+  /** The decision record each box's intent names, read from the working tree (#2850). */
+  boxIntents?: readonly ResolvedBoxIntent[];
 }
 
 /** What every declaration check reads. */
@@ -469,7 +473,14 @@ export async function runDeclarationChecks(
   // The declared record kinds load from the working tree; under --at only whether each exists at the revision is checked (#2680).
   // A declared work kind's acceptance criteria are counted in the working tree too (#2772).
   const declaredKinds = options.gather === false ? undefined : await loadDeclaredKinds(declaration, tree, root, { load: !options.tree, acceptance: !options.tree });
-  const facts: WorkspaceFacts = { ...gathered, ...(options.records ? { records: options.records } : {}), ...(declaredKinds ? { declaredKinds } : {}) };
+  // A box's intent is read from the working tree's records, so not under --at (#2850).
+  const boxIntents = declaredKinds && !options.tree ? await resolveBoxIntents(declaration, root, declaredKinds) : undefined;
+  const facts: WorkspaceFacts = {
+    ...gathered,
+    ...(options.records ? { records: options.records } : {}),
+    ...(declaredKinds ? { declaredKinds } : {}),
+    ...(boxIntents ? { boxIntents } : {}),
+  };
   const ctx: WorkspaceCheckContext = { declaration, tree, groups, kinds: registry, kindProblems: problems, facts };
   const findings = runWorkspaceChecks(ctx);
   const { active, suppressed } = applyCheckSettings(declaration, findings);

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

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://intentius.io/chant/schemas/workspace/decision-points/v1/decision-points.schema.json",
   "title": "Decision points",
-  "description": "A workspace's decision points (ws-058, #2738): the recurring questions it asks of its own graph, declared as data in a JSON file that an answer record kind names in `answers.points`. Each point is a typed question (`noul`, `choice` with 2 to 255 options, or `score` with 2 to 10 ordered levels, the question types of the POST /v1/systemone wire format, #2491), the inputs it reads, each named as a read-contract output, and an ordered chain of deciders: `table` rows, `model` deciders with a backend, a pinned model id and a threshold, and a `quorum` of people, always last. Taken from chud's decision-points.schema.json; `boolean` is read as `noul`. What JSON Schema cannot say is checked in code (`points.ts`): an input's output is one the read contract has, a table row tests declared inputs and answers a candidate, a field belongs to its decider's kind, a model id is pinned rather than an alias, and the chain ends in its one quorum. Unknown fields are refused, except fields whose names start with x-.",
+  "description": "A workspace's decision points (ws-058, #2738): the recurring questions it asks of its own graph, declared as data in a JSON file that an answer record kind names in `answers.points`. Each point is a typed question (`noul`, `choice` with 2 to 255 options, or `score` with 2 to 10 ordered levels, the question types of the POST /v1/systemone wire format, #2491), the inputs it reads, each named as a read-contract output, and an ordered chain of deciders: `table` rows, `model` deciders with a backend, a pinned model id and a threshold, and a `quorum` of people, always last. What JSON Schema cannot say is checked in code (`points.ts`): an input's output is one the read contract has, a table row tests declared inputs and answers a candidate, a field belongs to its decider's kind, a model id is pinned rather than an alias, and the chain ends in its one quorum. Unknown fields are refused, except fields whose names start with x-.",
   "type": "object",
   "required": ["points"],
   "properties": {
@@ -44,7 +44,7 @@
       "type": "object",
       "required": ["type", "instructions", "criteria"],
       "properties": {
-        "type": { "enum": ["noul", "boolean", "choice", "score"], "description": "boolean is chud's name for noul, read as noul." },
+        "type": { "enum": ["noul", "choice", "score"] },
         "instructions": { "$ref": "#/$defs/text" },
         "criteria": {
           "description": "The candidates. noul: {true, false} descriptions. choice: option to description, 2 to 255 options. score: 2 to 10 ordered levels.",
@@ -54,7 +54,7 @@
       "additionalProperties": false,
       "allOf": [
         {
-          "if": { "properties": { "type": { "enum": ["noul", "boolean"] } } },
+          "if": { "properties": { "type": { "const": "noul" } } },
           "then": {
             "properties": {
               "criteria": {

package/src/workspace/declaration.schema.json

@@ -402,8 +402,13 @@
     },
     "box": {
       "type": "object",
-      "description": "The member is a box, or holds a box's declarations (#2726). A box holds no credential: each capability it needs outside itself is reached through a broker, a runtime such as a lobby or a door, which holds the credential and enforces the scope. chant workspace check fails when a file in the member's directory carries a literal secret (WSP121) and when a capability names no broker (WSP122). chant workspace status --json lists the capabilities, so a broker can read the scopes. Its host, slot, ports, state and cookies state the box's isolation (#2727): chant derives each value from the box's identity, its host, the member's name and its slot, and prints them in chant workspace status --json, so a runtime reads them instead of choosing its own. chant workspace check fails when two boxes on a host resolve to the same value (WSP123) and when a box hard-codes a machine path (WSP124). A member that builds the fountain lexicon's Box declares the callback token fountain gives its persistent sandbox as the capability fountain-callback, brokered by fountain, with scope owner, or chant workspace check fails (WSP125, #2780). Added in schema 1 by chant 0.91.0, so a declaration that uses it sets minReader to 0.91.0 or newer.",
+      "description": "The member is a box, or holds a box's declarations (#2726). A box holds no credential: each capability it needs outside itself is reached through a broker, a runtime such as a lobby or a door, which holds the credential and enforces the scope. chant workspace check fails when a file in the member's directory carries a literal secret (WSP121) and when a capability names no broker (WSP122). chant workspace status --json lists the capabilities, so a broker can read the scopes. Its host, slot, ports, state and cookies state the box's isolation (#2727): chant derives each value from the box's identity, its host, the member's name and its slot, and prints them in chant workspace status --json, so a runtime reads them instead of choosing its own. chant workspace check fails when two boxes on a host resolve to the same value (WSP123) and when a box hard-codes a machine path (WSP124). A member that builds the fountain lexicon's Box declares the callback token fountain gives its persistent sandbox as the capability fountain-callback, brokered by fountain, with scope owner, or chant workspace check fails (WSP125, #2780). Its intent names the decision record that says what the box is for (#2850): chant workspace status --json reports the record's state and answer, and chant workspace check fails when no decision record has the id (WSP126) and warns when the record constrains no member or path of this workspace (WSP127, #2857). Added in schema 1 by chant 0.91.0, so a declaration that uses it sets minReader to 0.91.0 or newer.",
       "properties": {
+        "intent": {
+          "type": "string",
+          "minLength": 1,
+          "description": "The id of the decision record that says what the box is for (#2850), a record of a declared kind named decision. A new box starts as a question: the record is proposed with a null choice until the person who answers it decides it. The record constrains a member or path of this workspace, with member:<a member's name> or a path: entry at, above or inside a member's directory. It need not be this member: the intent can constrain the app the box runs when that app is another member (#2857). When it constrains this member, chant workspace graph --intent shows it for the box's files. Added by chant 0.94.0, so a declaration that uses it sets minReader to 0.94.0 or newer."
+        },
         "capabilities": {
           "type": "array",
           "description": "Each capability the box reaches outside itself, named once. None when omitted.",

package/src/workspace/declaration.ts

@@ -210,6 +210,12 @@ export interface BoxDeclaration {
   capabilities: BoxCapability[];
   /** The host and slot of the box's isolation, or null when the block declares none (#2727). The values are derived in `boxes.ts`. */
   isolation: BoxIsolationDeclaration | null;
+  /**
+   * The id of the decision record that says what the box is for, or null when
+   * the block names none (#2850). A box starts as a question: the record is
+   * proposed with no choice until the person who answers it decides it.
+   */
+  intent: string | null;
   /** The block's JSON Pointer in the file, for messages. */
   pointer: string;
 }
@@ -713,6 +719,7 @@ function boxOf(raw: unknown, pointer: string): BoxDeclaration | null {
     ports?: Record<string, number>;
     state?: Record<string, string>;
     cookies?: string[];
+    intent?: string;
   };
   return {
     capabilities: (b.capabilities ?? []).map((c, i) => ({ name: c.name, broker: c.broker ?? null, scope: [...(c.scope ?? [])], pointer: `${pointer}/capabilities/${i}` })),
@@ -721,6 +728,7 @@ function boxOf(raw: unknown, pointer: string): BoxDeclaration | null {
       b.host === undefined
         ? null
         : { host: b.host, slot: b.slot!, ports: { ...(b.ports ?? {}) }, state: { ...(b.state ?? {}) }, cookies: [...(b.cookies ?? [])] },
+    intent: b.intent ?? null,
     pointer,
   };
 }

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

@@ -242,6 +242,32 @@ describe("records without --kind reads every declared kind (#2680)", () => {
     expect(await run(workspace(), "--current")).toBe(0);
     expect(out.filter((l) => l.includes("("))).toEqual(["decision (decisions/decision.kind.mjs)", "notes (design/notes/note.kind.mjs)"]);
   });
+
+  test("--at an unknown revision with --json prints the error document, not just text on stderr (#2860)", async () => {
+    const root = workspace();
+    expect(await run(root, "--at", "refs/heads/no-such-branch", "--json")).toBe(1);
+    expect(err).toEqual([]);
+    const printed = JSON.parse(out.join("\n"));
+    expectValid(printed);
+    expect(printed).toEqual({
+      $schema: recordsSchema.$id,
+      contract: 1,
+      error: { code: "revision-unknown", message: expect.stringContaining("refs/heads/no-such-branch") as unknown as string },
+    });
+
+    out.length = 0;
+    err.length = 0;
+    expect(await run(root, "--at", "refs/heads/no-such-branch")).toBe(1);
+    expect(out).toEqual([]);
+    expect(err.join("\n")).toContain("revision-unknown");
+  });
+
+  test("a declaration-level code the records schema doesn't carry, such as declaration-invalid, stays text-only even with --json (#2860)", async () => {
+    const root = repo({ "chant.workspace.json": decl(members(), { records: [{ kind: "a.kind.mjs", file: "b" }] }), "app/x": "", "design/x": "" });
+    expect(await run(root, "--json")).toBe(1);
+    expect(out).toEqual([]);
+    expect(err.join("\n")).toContain("declaration-invalid");
+  });
 });
 
 describe("records new, amend and review without --kind (#2680)", () => {

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

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

package/src/workspace/intent-joins.ts

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

package/src/workspace/points-cli.ts

@@ -71,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[];
@@ -163,6 +165,7 @@ 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),

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": {

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");
@@ -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.
@@ -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

@@ -193,6 +193,14 @@ describe("every schema against the reference workspace (#2543)", () => {
       expectValid(doc);
       if ("error" in doc) throw new Error(doc.error.message);
       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

@@ -157,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) => ({
@@ -178,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

@@ -192,6 +192,9 @@ export const REASONS = {
   "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.",

package/src/workspace/records-cli.ts

@@ -510,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") {
@@ -521,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) {