@intentius/chant 0.102.0 → 0.104.1

package/src/workspace/points.ts

@@ -15,6 +15,12 @@
  *           proposal a person confirms; below it, the next decider is asked.
  *   quorum  people. Always last: the question escalates to them.
  *
+ * A point declared `adhoc` (#3403) has no candidates of its own: its
+ * question's text and candidates come with each ask, as an agent's question
+ * to the room does, and the answer record keeps them as `asked`, so people's
+ * answer is checked against the candidates the question was asked with. Only
+ * people decide it: its chain is one quorum.
+ *
  * chant never calls a model (ws-052). {@link runChain} takes the model call
  * as a function, {@link ModelAsk}, which the decide Op activity (#2740), a
  * runtime's decider or a test's stub supplies. Without one, a model decider is
@@ -51,6 +57,8 @@ export const POINT_INPUT_OUTPUTS = {
   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" },
+  node: { schema: "intent", def: "node", description: "any node of an intent graph, by its id and kind: a commit, decision, unit, artifact or the region itself, as an intent walk asks of it (#3351)" },
+  ask: { schema: "points", def: "question", description: "an ad-hoc question as its asker knows it (#3403): the asker's own id for the ask, such as hud's request id for an agent's question, and who asked" },
   member: { schema: "ls", def: "member", description: "a member, as ls lists it" },
   gate: { schema: "status", def: "gate", description: "a gate, as status lists it" },
   release: { schema: "status", def: "release", description: "a release, as status lists it; a release plan's fields until the lifecycle ledger lists plans (#2717)" },
@@ -73,7 +81,8 @@ export type QuestionType = "noul" | "choice" | "score";
 export interface Question {
   type: QuestionType;
   instructions: string;
-  criteria: Record<string, string> | string[];
+  /** The candidates and what each means. Absent only from an ad-hoc point's declaration, whose candidates come with each ask (#3403). */
+  criteria?: Record<string, string> | string[];
 }
 
 export type Scalar = string | number | boolean | null;
@@ -92,6 +101,8 @@ export type Decider =
 
 export interface Point {
   title: string;
+  /** The question's text and candidates come with each ask, not the declaration (#3403). */
+  adhoc?: boolean;
   question: Question;
   inputs: Record<string, string>;
   deciders: Decider[];
@@ -116,8 +127,8 @@ export class PointsError extends Error {
 /** A question's candidate answers: true and false, a choice's options, or a score's levels. */
 export function candidates(question: Question): (string | boolean)[] {
   if (question.type === "noul") return [true, false];
-  if (question.type === "choice") return Object.keys(question.criteria);
-  return [...(question.criteria as string[])];
+  if (question.type === "choice") return Object.keys(question.criteria ?? {});
+  return [...((question.criteria as string[] | undefined) ?? [])];
 }
 
 const ONLY: Record<Decider["kind"], string[]> = { table: ["rows"], model: ["backend", "model", "threshold", "unreachable"], quorum: ["count", "roles"] };
@@ -140,6 +151,12 @@ function pointProblems(points: Record<string, Point>): PointProblem[] {
         });
       }
     }
+    if (point.adhoc && (point.deciders.length !== 1 || point.deciders[0].kind !== "quorum")) {
+      problems.push({
+        field: at("deciders"),
+        message: "is an ad-hoc point's chain, and an ad-hoc point is decided by people alone: its chain is one quorum, since no table row or model can know candidates that come with the ask",
+      });
+    }
     const allowed = candidates(point.question);
     const last = point.deciders.length - 1;
     point.deciders.forEach((d, i) => {
@@ -210,7 +227,9 @@ export function schemaProblems(data: unknown): PointProblem[] {
           ? `is missing ${JSON.stringify(e.params.missingProperty)}`
           : e.keyword === "propertyNames"
             ? `has a name that is not allowed: ${JSON.stringify(e.params.propertyName)}`
-            : (e.message ?? "is invalid");
+            : e.keyword === "not"
+              ? "has criteria, and an ad-hoc point's candidates come with each ask (#3403): leave criteria out"
+              : (e.message ?? "is invalid");
     const key = `${field}\0${message}`;
     if (seen.has(key)) continue;
     seen.add(key);
@@ -262,8 +281,71 @@ const sha256 = (text: string): string => createHash("sha256").update(text, "utf8
 /** The version of a point: the sha256 of its declaration. Editing the question or any decider changes it. */
 export const pointVersion = (point: Point): string => sha256(canonical(point));
 
-/** What is answered once: the point, its version and the inputs. */
-export const inputsHash = (name: string, version: string, inputs: Record<string, unknown>): string => sha256(canonical({ point: name, version, inputs }));
+/**
+ * What is answered once: the point, its version and the inputs, and for an
+ * ad-hoc point the question and candidates it was asked with (#3403).
+ */
+export const inputsHash = (name: string, version: string, inputs: Record<string, unknown>, asked?: Asked): string => sha256(canonical({ point: name, version, inputs, asked }));
+
+// ── Ad-hoc questions (#3403) ─────────────────────────────────────────────────
+
+/** An ad-hoc point's question as one ask gave it: its text and its candidates, in the point's question type's shape. */
+export interface Asked {
+  question: string;
+  criteria: Record<string, string> | string[];
+}
+
+/** The question an answer asks: the point's own, or for an ad-hoc point the one the ask gave. */
+export function askedQuestion(point: Point, asked: Asked | undefined): Question {
+  return asked ? { type: point.question.type, instructions: asked.question, criteria: asked.criteria } : point.question;
+}
+
+const nonEmpty = (v: unknown): v is string => typeof v === "string" && v.trim() !== "";
+
+/**
+ * An ad-hoc ask's question and candidates (`points ask --candidates`), checked
+ * against the point's question type as a declaration's criteria are: noul
+ * describes true and false, choice gives 2 to 255 options, each with what it
+ * means, and score 2 to 10 distinct ordered levels. Returns the problems, or
+ * the question.
+ */
+export function parseAsked(point: Point, value: unknown): { asked: Asked } | { problems: string[] } {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return { problems: ["the candidates must be a JSON object with question and criteria"] };
+  const v = value as Record<string, unknown>;
+  const problems: string[] = [];
+  const extra = Object.keys(v).filter((k) => k !== "question" && k !== "criteria");
+  if (extra.length > 0) problems.push(`the candidates take question and criteria, not ${extra.join(", ")}`);
+  if (!nonEmpty(v.question)) problems.push("question must be the question's text");
+  const c = v.criteria;
+  const type = point.question.type;
+  if (type === "score") {
+    if (!Array.isArray(c) || c.length < 2 || c.length > 10 || !c.every(nonEmpty) || new Set(c).size !== c.length) problems.push("criteria must be 2 to 10 distinct levels, in order, for a score question");
+  } else if (c === null || typeof c !== "object" || Array.isArray(c)) {
+    problems.push(`criteria must be an object of ${type === "noul" ? "true and false" : "options"}, each with what it means`);
+  } else {
+    const entries = Object.entries(c as Record<string, unknown>);
+    if (!entries.every(([k, d]) => k !== "" && typeof d === "string")) problems.push("each criterion must be a non-empty name with what it means as a string");
+    if (type === "noul") {
+      const keys = entries.map(([k]) => k).sort();
+      if (keys.length !== 2 || keys[0] !== "false" || keys[1] !== "true") problems.push("criteria must describe true and false, and nothing else, for a noul question");
+    } else if (entries.length < 2 || entries.length > 255) {
+      problems.push("criteria must give 2 to 255 options for a choice question");
+    }
+  }
+  if (problems.length > 0) return { problems };
+  const criteria = Array.isArray(c) ? [...(c as string[])] : { ...(c as Record<string, string>) };
+  return { asked: { question: (v.question as string).trim(), criteria } };
+}
+
+/** An answer record's `asked`, when it has one. */
+export function askedOf(data: Record<string, unknown>): Asked | undefined {
+  const a = data.asked as Record<string, unknown> | undefined;
+  if (a === null || typeof a !== "object" || Array.isArray(a) || typeof a.question !== "string") return undefined;
+  const c = a.criteria;
+  if (Array.isArray(c)) return { question: a.question, criteria: c.filter((x): x is string => typeof x === "string") };
+  if (c !== null && typeof c === "object") return { question: a.question, criteria: Object.fromEntries(Object.entries(c as Record<string, unknown>).filter(([, d]) => typeof d === "string")) as Record<string, string> };
+  return undefined;
+}
 
 /** The id of the answer to `name` for inputs hashing to `hash`: the name and the hash's first 12 hex digits. */
 export const answerId = (name: string, hash: string): string => `${name}-${hash.slice(0, 12)}`;
@@ -311,15 +393,28 @@ export interface WireQuestion {
   criteria: Record<string, string> | string[];
 }
 
-/** One answer in the wire format's shape. */
+/**
+ * One answer in the wire format's shape. `reason` is the model's own
+ * explanation of its answer, when the backend gives one (#3345): kept in the
+ * answer record beside a proposal, or in the escalation entry of an answer
+ * below the threshold, so a person sees why the model chose.
+ */
 export type WireAnswer =
-  | { type: "noul"; noul: number }
-  | { type: "choice"; choice: string; probabilities?: Record<string, number>; confidence?: number }
-  | { type: "score"; score?: number; legend?: unknown; probabilities?: Record<string, number>; confidence?: number }
+  | { type: "noul"; noul: number; reason?: string }
+  | { type: "choice"; choice: string; probabilities?: Record<string, number>; confidence?: number; reason?: string }
+  | { type: "score"; score?: number; legend?: unknown; probabilities?: Record<string, number>; confidence?: number; reason?: string }
   | { type: "unsupported" };
 
+/** A wire answer's reason, trimmed, or undefined when it gives none (or not a string). */
+export function answerReason(answer: WireAnswer | undefined): string | undefined {
+  const raw = (answer as { reason?: unknown } | undefined)?.reason;
+  if (typeof raw !== "string") return undefined;
+  const reason = raw.trim();
+  return reason === "" ? undefined : reason;
+}
+
 export function wireQuestion(question: Question): WireQuestion {
-  return { type: question.type, instructions: question.instructions, criteria: question.criteria };
+  return { type: question.type, instructions: question.instructions, criteria: question.criteria ?? {} };
 }
 
 /** What a model decider is asked. */
@@ -388,7 +483,12 @@ export function observe(question: Question, answer: WireAnswer | undefined, thre
   return { observed: false, answer: choice, probabilities, confidence, reason: `confidence ${confidence} is below the threshold ${threshold}` };
 }
 
-/** A decider that was asked and did not answer, and why. */
+/**
+ * A decider that was asked and did not answer, and why: `reason` is chant's
+ * account of why it did not answer. `model_reason` is the model's own
+ * explanation of the answer it gave (#3345), when it gave one; it is not named
+ * `reason` because that field already says why the decider escalated.
+ */
 export interface Escalation {
   kind: "table" | "model";
   reason: string;
@@ -398,6 +498,7 @@ export interface Escalation {
   probabilities?: Record<string, number>;
   confidence?: number;
   threshold?: number;
+  model_reason?: string;
 }
 
 export type ChainResult =
@@ -409,6 +510,8 @@ export type ChainResult =
       probabilities: Record<string, number>;
       confidence: number;
       threshold: number;
+      /** The model's explanation of its answer, when the backend gave one (#3345). */
+      reason?: string;
       escalations: Escalation[];
     }
   | { status: "escalated"; decider: { kind: "quorum"; count: number; roles?: string[] }; escalations: Escalation[] };
@@ -455,6 +558,7 @@ export async function runChain(name: string, point: Point, inputs: Record<string
         continue;
       }
       const seen = observe(point.question, reply.answer, d.threshold);
+      const why = answerReason(reply.answer);
       if (seen.observed) {
         return {
           status: "proposed",
@@ -463,6 +567,7 @@ export async function runChain(name: string, point: Point, inputs: Record<string
           probabilities: seen.probabilities,
           confidence: seen.confidence,
           threshold: d.threshold,
+          ...(why !== undefined ? { reason: why } : {}),
           escalations,
         };
       }
@@ -475,6 +580,7 @@ export async function runChain(name: string, point: Point, inputs: Record<string
         ...(seen.confidence !== undefined ? { confidence: seen.confidence } : {}),
         threshold: d.threshold,
         reason: `not observed: ${seen.reason}`,
+        ...(why !== undefined ? { model_reason: why } : {}),
       });
     } else {
       return { status: "escalated", decider: { kind: "quorum", count: d.count, ...(d.roles ? { roles: d.roles } : {}) }, escalations };

package/src/workspace/pr-report.schema.json

@@ -0,0 +1,95 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://intentius.io/chant/schemas/workspace/pr-report/v1/pr-report.schema.json",
+  "title": "pull-request report",
+  "description": "What one stage of the pull-request loop (#3183) planned or applied: the members a change reaches, the digest the gate binds, where the approval stands and how the stage ended. Written by `chant components pr-plan` (pr-plan.json) and `chant components pr-apply` (pr-apply.json), and built by prReport in @intentius/chant/components/pr-run. The pull-request note is rendered from it by renderPrNote in @intentius/chant/pr-loop. Version 1 of the workspace read contract. Readers ignore fields they do not know; a field is only ever added within a version.",
+  "type": "object",
+  "required": ["$schema", "contract", "stage", "pr", "env", "base", "head", "op", "gate", "digest", "status", "approval", "selection", "members", "changeSet"],
+  "properties": {
+    "$schema": { "const": "https://intentius.io/chant/schemas/workspace/pr-report/v1/pr-report.schema.json" },
+    "contract": { "const": 1 },
+    "stage": { "enum": ["plan", "apply"] },
+    "pr": {
+      "type": ["integer", "null"],
+      "minimum": 1,
+      "description": "The pull or merge request number. null when an apply found no pull request that merged its commit."
+    },
+    "env": { "type": "string" },
+    "base": { "type": "string", "pattern": "^[0-9a-f]{40,64}$", "description": "The commit the change is measured from: the merge base of the given base and head." },
+    "head": { "type": "string", "pattern": "^[0-9a-f]{40,64}$" },
+    "op": {
+      "type": "string",
+      "description": "The gate's op, pr-<number>. Its ledger is _gates/<op>.jsonl on chant/lifecycle. pr-unknown when no pull request was found."
+    },
+    "gate": { "type": "string", "description": "The gate the apply waits on, pr-apply unless the pipeline names another." },
+    "digest": {
+      "type": "string",
+      "pattern": "^(?:jcs1-)?sha256:[0-9a-f]{64}$",
+      "description": "The change-set digest of what this stage planned: computePlanDigest(\"change-set\", ...) over every member's { member, planDigest }. What the gate binds."
+    },
+    "status": {
+      "enum": ["planned", "plan-failed", "nothing", "applied", "failed", "refused"],
+      "description": "planned: every member planned (plan stage). plan-failed: a member failed to plan, so nothing can apply. nothing: no component deploys what the change touches. applied: every member applied. failed: a member failed to apply and its dependents did not run. refused: nothing applied, see refusal."
+    },
+    "refusal": {
+      "enum": ["not-approved", "plan-changed", "not-a-reviewer", "no-pull-request"],
+      "description": "Why an apply refused. plan-changed: an approval stands for another digest, so the plan changed after review."
+    },
+    "message": { "type": "string", "description": "The refusal or failure as printed." },
+    "approval": {
+      "type": "object",
+      "required": ["status"],
+      "properties": {
+        "status": { "enum": ["approved", "changed", "pending"], "description": "approved: an approval stands for digest. changed: one stands for another digest. pending: none stands." },
+        "approvedBy": { "type": "array", "items": { "type": "string" }, "description": "Who approved digest, as the approval names them (github:<login>, gitlab:<login>, <forge>@<host>:<login>, or a signer)." },
+        "approved": { "type": "string", "pattern": "^(?:jcs1-)?sha256:[0-9a-f]{64}$", "description": "With changed: the digest that was approved." }
+      }
+    },
+    "selection": {
+      "type": "object",
+      "required": ["changed", "dependents", "unclaimed", "indeterminate", "waves"],
+      "description": "Component names. The fan-out derivation the change gives (#2417).",
+      "properties": {
+        "changed": { "type": "array", "items": { "type": "string" }, "description": "Components deploying a unit the change touched, in dependency order." },
+        "dependents": { "type": "array", "items": { "type": "string" }, "description": "Components selected because they depend on a changed one, in dependency order." },
+        "unclaimed": { "type": "array", "items": { "type": "string" }, "description": "Units the change touched that no component deploys." },
+        "indeterminate": { "type": "array", "items": { "type": "string" }, "description": "Components a source diff cannot judge that the walk did not reach." },
+        "waves": { "type": "array", "items": { "type": "array", "items": { "type": "string" } }, "description": "The selected components in parallel-safe waves, in apply order." }
+      }
+    },
+    "members": {
+      "type": "array",
+      "description": "One entry per change-set member, sorted by member.",
+      "items": {
+        "type": "object",
+        "required": ["member", "component", "planDigest", "status", "counts"],
+        "properties": {
+          "member": { "type": "string", "description": "The member's name in the change set: the root, for a terraform-family step." },
+          "component": { "type": "string" },
+          "planDigest": { "type": ["string", "null"], "description": "What a gate on this member alone binds. null when it failed to plan." },
+          "status": { "enum": ["planned", "plan-failed", "applied", "failed", "blocked"] },
+          "counts": {
+            "type": "object",
+            "required": ["create", "update", "replace", "delete"],
+            "properties": {
+              "create": { "type": "integer", "minimum": 0 },
+              "update": { "type": "integer", "minimum": 0 },
+              "replace": { "type": "integer", "minimum": 0 },
+              "delete": { "type": "integer", "minimum": 0 }
+            }
+          },
+          "error": { "type": "string" },
+          "inputsMoved": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "Apply stage: components this one depends on whose outputs changed when they applied. It applied the plan it was approved with; the next run plans it against the new values."
+          }
+        }
+      }
+    },
+    "changeSet": {
+      "type": "object",
+      "description": "The change-set document over every member (change-set.schema.json). Its digest equals digest."
+    }
+  }
+}

package/src/workspace/profiles.test.ts

@@ -0,0 +1,159 @@
+/**
+ * #3174, ws-096: factory fields are opt-in, and the reference workspace ships
+ * three profiles (ideation, app, infra) that `chant workspace init --profile`
+ * copies. A records-only workspace, an infra workspace with no factory and an
+ * infra workspace whose factory has no app member and no box services all
+ * pass `chant workspace check`, and so does a copy of each profile.
+ */
+
+import { execFileSync, spawnSync } from "node:child_process";
+import { mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, relative } from "node:path";
+import { afterAll, describe, expect, test } from "vitest";
+import { REPO, repo } from "./__fixtures__/contract-repo";
+import { plantability } from "./box-factory";
+import { runDeclarationChecks } from "./checks";
+import { readDeclaration } from "./declaration";
+import { PROFILES, PROFILES_DIR, profileSource } from "./init";
+import { initFromCommand } from "./lineage-init";
+import { workingTree } from "./tree";
+
+const scratch: string[] = [];
+afterAll(() => {
+  for (const d of scratch) rmSync(d, { recursive: true, force: true });
+});
+
+const REFERENCE = join(REPO, "reference-workspace");
+const CHANT = join(REPO, "packages", "core", "bin", "chant");
+
+/** Every file under `dir`, relative to it, sorted. */
+function files(dir: string): string[] {
+  const out: string[] = [];
+  const walk = (at: string) => {
+    for (const name of readdirSync(at)) {
+      const p = join(at, name);
+      if (statSync(p).isDirectory()) walk(p);
+      else out.push(relative(dir, p));
+    }
+  };
+  walk(dir);
+  return out.sort();
+}
+
+/** The errors `chant workspace check` reports, as `<id>:<entity>: <message>`. */
+async function errors(root: string): Promise<string[]> {
+  const report = await runDeclarationChecks(root);
+  return report.diagnostics.filter((d) => d.severity === "error").map((d) => `${d.ruleId}:${d.entity ?? ""}: ${d.message}`);
+}
+
+/** A copy of a profile, made the way `chant workspace init --profile` makes it, from this checkout. */
+async function copyOf(profile: string): Promise<string> {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), `chant-3174-${profile}-`)));
+  scratch.push(dir);
+  const made = await initFromCommand({ from: `${REPO}#${PROFILES_DIR}/${profile}`, path: dir, params: profile === "infra" ? {} : { name: "Fern" } });
+  expect(made.success, made.error).toBe(true);
+  execFileSync("git", ["init", "-q"], { cwd: dir });
+  return dir;
+}
+
+describe("factory fields are opt-in (#3174)", () => {
+  test("a records-only workspace passes check, with no member, box or factory", async () => {
+    const root = repo({
+      "chant.workspace.json": JSON.stringify({ name: "notes", schema: 1, members: [], records: [{ kind: "decisions/decision.kind.mjs" }] }, null, 2),
+      "decisions/decision.kind.mjs": readFileSync(join(REFERENCE, "decisions", "decision.kind.mjs"), "utf-8"),
+      "decisions/decision.schema.json": readFileSync(join(REFERENCE, "decisions", "decision.schema.json"), "utf-8"),
+    });
+    expect(await errors(root)).toEqual([]);
+  });
+
+  test("an infra workspace with no factory passes check", async () => {
+    const root = repo({
+      "chant.workspace.json": JSON.stringify({ name: "estate", schema: 1, members: [{ name: "network", dir: "network", kind: "chant" }] }, null, 2),
+      "network/chant.config.json": '{ "lexicons": ["terraform"] }\n',
+    });
+    expect(await errors(root)).toEqual([]);
+  });
+
+  test("an infra workspace whose factory builds an estate member, with no app member and no box services, passes check and isn't plantable", async () => {
+    const declaration = {
+      name: "estate",
+      schema: 1,
+      members: [{ name: "network", dir: "network", kind: "chant", box: { factory: { builds: ["network"], check: { run: "chant lint", kind: "lint" } } } }],
+    };
+    const root = repo({ "chant.workspace.json": JSON.stringify(declaration, null, 2), "network/chant.config.json": '{ "lexicons": ["terraform"] }\n' });
+    expect(await errors(root)).toEqual([]);
+    expect(plantability(readDeclaration(workingTree(root), "")).reason?.code).toBe("box-none");
+  });
+});
+
+describe("the reference workspace's profiles (#3174)", () => {
+  test("are ideation, app and infra, each a template directory with a declaration", () => {
+    expect(readdirSync(join(REPO, PROFILES_DIR)).sort()).toEqual([...PROFILES].sort());
+  });
+
+  test("carry the reference workspace's own record kinds and app kind, byte for byte", () => {
+    for (const profile of PROFILES) {
+      const dir = join(REPO, PROFILES_DIR, profile);
+      for (const f of files(dir).filter((p) => /^(decisions|work|answers|kinds)\//.test(p))) {
+        expect(readFileSync(join(dir, f), "utf-8"), `${profile}/${f}`).toBe(readFileSync(join(REFERENCE, f), "utf-8"));
+      }
+    }
+  });
+
+  test("ideation: records and a stub app of the app kind, no box and no factory, and check passes", async () => {
+    const root = await copyOf("ideation");
+    expect(await errors(root)).toEqual([]);
+    const d = readDeclaration(workingTree(root), "");
+    expect(d.members.map((m) => `${m.name}:${m.kind}`)).toEqual(["app:app"]);
+    expect(d.members.every((m) => m.box === null)).toBe(true);
+    expect(d.records.map((r) => r.kind)).toEqual(["decisions/decision.kind.mjs", "work/work.kind.mjs", "answers/answer.kind.mjs"]);
+    expect(readFileSync(join(root, "app", "server.mjs"), "utf-8")).toContain('NAME = "Fern"');
+  });
+
+  test("app: the app member runs as the box's service and the factory builds it, and check passes", async () => {
+    const root = await copyOf("app");
+    expect(await errors(root)).toEqual([]);
+    const d = readDeclaration(workingTree(root), "");
+    expect(plantability(d)).toMatchObject({ plantable: true, box: "app" });
+    expect(d.members[0].box?.factory?.builds).toEqual(["app"]);
+  });
+
+  test("infra: an estate member and a factory, no app member and no box services, and check passes", async () => {
+    const root = await copyOf("infra");
+    expect(await errors(root)).toEqual([]);
+    const d = readDeclaration(workingTree(root), "");
+    expect(d.members.map((m) => `${m.name}:${m.kind}`)).toEqual(["network:chant"]);
+    expect(d.members[0].box?.factory?.check).toEqual({ run: "cd network && npx chant lint && npx chant build", kind: "lint" });
+    expect(d.members[0].box?.services).toEqual([]);
+    expect(d.pins).toEqual([]);
+  });
+});
+
+describe("chant workspace init --profile (#3174)", () => {
+  test("reads the profile from the chant repository at this chant's tag, or from --from", () => {
+    expect(profileSource("app", undefined, "0.103.0")).toBe("https://github.com/INTENTIUS/chant@chant-v0.103.0#reference-workspace/profiles/app");
+    expect(profileSource("infra", "/src/chant", "0.103.0")).toBe("/src/chant#reference-workspace/profiles/infra");
+  });
+
+  test("copies the profile with a lineage lock and names the workspace", () => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), "chant-3174-cli-")));
+    scratch.push(dir);
+    const run = spawnSync(CHANT, ["workspace", "init", dir, "--profile", "ideation", "--from", REPO, "--name", "fern", "--param", "name=Fern", "--yes"], { encoding: "utf-8" });
+    expect(run.status, run.stderr).toBe(0);
+    expect(JSON.parse(readFileSync(join(dir, "chant.workspace.json"), "utf-8")).name).toBe("fern");
+    expect(readdirSync(join(dir, ".chant"))).toContain("workspace.lock.json");
+  });
+
+  test("names the profiles when given another, and writes nothing without --yes", () => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), "chant-3174-cli-")));
+    scratch.push(dir);
+    const bad = spawnSync(CHANT, ["workspace", "init", dir, "--profile", "web"], { encoding: "utf-8" });
+    expect(bad.status).toBe(1);
+    expect(bad.stderr).toMatch(/the profiles are ideation, app, infra/);
+    const dry = spawnSync(CHANT, ["workspace", "init", dir, "--profile", "infra", "--from", REPO], { encoding: "utf-8", input: "" });
+    expect(dry.status).toBe(0);
+    expect(dry.stdout).toMatch(/Nothing written/);
+    expect(readdirSync(dir)).toEqual([]);
+  });
+});

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

@@ -215,7 +215,7 @@ describe("every schema against the reference workspace (#2543)", () => {
         expect(doc.components[0].runtimes).toEqual([{ name: "local", lexicon: null, default: true, command: "chant run --components app" }]);
         expect(doc.members.find((m) => m.name === "delivery")!.runtimeReasons).toEqual([]);
         // #2695: the reference config declares no environments, so the app deploys to local only.
-        expect(doc.components[0].environments).toEqual([{ name: "local", default: true, source: "builtin", command: "chant run --components app" }]);
+        expect(doc.components[0].environments).toEqual([{ name: "local", default: true, source: "builtin", site: null, command: "chant run --components app" }]);
         expect(doc.members.find((m) => m.name === "delivery")!.environmentReasons.map((r) => r.code)).toEqual(["environments-none-declared"]);
         expect(doc.reasons).toEqual([]);
       }
@@ -244,7 +244,7 @@ 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", "finding-triage", "needs-a-decision"]);
+      expect(doc.points.map((p) => p.name)).toEqual(["slice-tier", "understand", "ship-skip", "finding-triage", "needs-a-decision", "intent-origin", "intent-judgment", "intent-disposition", "agent-question"]);
       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.",

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

@@ -29,7 +29,8 @@ import { WORK_WARNING_CODES } from "./work";
 import { BOX_FINDING_CODES } from "./checks/boxes";
 import { DIAGRAM_FINDING_CODES } from "./checks/diagrams";
 import { WORK_ERROR_CODES, WORK_HISTORY_ERROR_CODES, WORK_LEASE_REFUSALS } from "./work-cli";
-import { RUNS_ERROR_CODES, RUNS_REASON_CODES, RUNS_WRITE_ERROR_CODES } from "./runs-cli";
+import { RUN_STATEMENT_ERROR_CODES, RUNS_ERROR_CODES, RUNS_REASON_CODES, RUNS_WRITE_ERROR_CODES } from "./runs-cli";
+import { RUN_STATEMENT_FAILURE_CODES } from "./trust/run-statement";
 import { WORK_EVIDENCE_ERROR_CODES } from "./work-evidence";
 import { RECORD_FINDING_CODES } from "./checks/records";
 import { ANSWER_WARNING_CODES } from "./points";
@@ -39,6 +40,10 @@ import { PATCH_ERROR_CODES } from "./patch";
 import { AGENT_ERROR_CODES } from "./agent-cli";
 import { SCOPE_FINDING_CODES, WRITE_SCOPE_CODES } from "./write-scope";
 import { PLANTABLE_REASON_CODES } from "./box-factory";
+import { BOX_LISTING_ERROR_CODES } from "./box-listing";
+import { BOX_PUBLISH_ERROR_CODES } from "./box-publish";
+import { WRITE_LOCK_ERROR_CODES } from "./write-lock-cli";
+import { WIP_ERROR_CODES, WIP_WRITE_ERROR_CODES } from "./wip";
 import { ROTATION_REFUSAL_CODES } from "./trust/rotation";
 import { SIGNERS_ERROR_CODES } from "./trust/signers-cli";
 import { EVIDENCE_ERROR_CODES } from "./trust/evidence";
@@ -88,6 +93,8 @@ const PER_COMMAND: Record<string, readonly string[]> = {
   RUNS_ERROR_CODES,
   RUNS_REASON_CODES,
   RUNS_WRITE_ERROR_CODES,
+  RUN_STATEMENT_ERROR_CODES,
+  RUN_STATEMENT_FAILURE_CODES,
   WORK_EVIDENCE_ERROR_CODES,
   RECORD_FINDING_CODES,
   ANSWER_WARNING_CODES,
@@ -99,6 +106,11 @@ const PER_COMMAND: Record<string, readonly string[]> = {
   WRITE_SCOPE_CODES,
   SCOPE_FINDING_CODES,
   PLANTABLE_REASON_CODES,
+  BOX_LISTING_ERROR_CODES,
+  BOX_PUBLISH_ERROR_CODES,
+  WRITE_LOCK_ERROR_CODES,
+  WIP_ERROR_CODES,
+  WIP_WRITE_ERROR_CODES,
   ROTATION_REFUSAL_CODES,
   SIGNERS_ERROR_CODES,
   EVIDENCE_ERROR_CODES,