@intentius/chant 0.91.0 → 0.94.0

package/src/workspace/checks/diagrams.test.ts

@@ -0,0 +1,134 @@
+/**
+ * The diagram checks, WSP131 to WSP133 (#2764).
+ */
+
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterAll, describe, expect, test } from "vitest";
+import { runDeclarationChecks } from "../checks";
+import { sha256Hex } from "../../content-digest";
+
+const scratch: string[] = [];
+afterAll(() => {
+  for (const d of scratch) rmSync(d, { recursive: true, force: true });
+});
+function repo(files: Record<string, string>): string {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "chant-diagrams-")));
+  scratch.push(root);
+  execFileSync("git", ["init", "-q"], { cwd: root });
+  for (const [path, text] of Object.entries(files)) {
+    mkdirSync(dirname(join(root, path)), { recursive: true });
+    writeFileSync(join(root, path), text);
+  }
+  return root;
+}
+
+const renderer = { tool: "d2", version: "0.9.0", args: ["--layout=elk", "--theme=0", "--pad=40", "--omit-version"] };
+const diagram = (extra: Record<string, unknown> = {}) => ({
+  name: "architecture",
+  title: "Studio architecture",
+  source: "docs/diagrams/architecture.d2",
+  render: "docs/diagrams/architecture.svg",
+  renderer,
+  ...extra,
+});
+
+const declaration = (diagrams: unknown[], extra: Record<string, unknown> = {}) =>
+  JSON.stringify({ name: "acme", schema: 1, members: [{ name: "docs", dir: "docs", kind: "other", because: "the docs site", diagrams }], ...extra }, null, 2);
+
+/** The findings, less WSP009, which every member of kind other gets. */
+const found = async (root: string) => (await runDeclarationChecks(root, (f) => f, { gather: false })).diagnostics.filter((d) => d.ruleId !== "WSP009");
+
+describe("diagram-source-missing (WSP131) and diagram-render-missing (WSP132)", () => {
+  test("both files present passes", async () => {
+    const root = repo({
+      "chant.workspace.json": declaration([diagram()]),
+      "docs/diagrams/architecture.d2": "x -> y",
+      "docs/diagrams/architecture.svg": "<svg></svg>",
+    });
+    expect(await found(root)).toEqual([]);
+  });
+
+  test("a missing source fails WSP131, and a missing render fails WSP132, each once", async () => {
+    const root = repo({
+      "chant.workspace.json": declaration([diagram()]),
+      "docs/diagrams/architecture.svg": "<svg></svg>",
+    });
+    const d = await found(root);
+    expect(d.map((x) => [x.ruleId, x.code, x.entity])).toEqual([["WSP131", "diagram-source-missing", "docs"]]);
+    expect(d[0].message).toContain("member docs's diagram architecture names the source docs/diagrams/architecture.d2, which does not exist");
+  });
+
+  test("no source (an SVG with none) is never checked for a source", async () => {
+    const root = repo({
+      "chant.workspace.json": declaration([diagram({ source: null })]),
+      "docs/diagrams/architecture.svg": "<svg></svg>",
+    });
+    expect(await found(root)).toEqual([]);
+  });
+
+  test("a missing render fails WSP132", async () => {
+    const root = repo({
+      "chant.workspace.json": declaration([diagram()]),
+      "docs/diagrams/architecture.d2": "x -> y",
+    });
+    const d = await found(root);
+    expect(d.map((x) => [x.ruleId, x.code])).toEqual([["WSP132", "diagram-render-missing"]]);
+  });
+
+  test("the top-level (workspace's own) diagrams are checked too, reported with no entity", async () => {
+    const root = repo({ "chant.workspace.json": declaration([], { diagrams: [diagram({ name: "boundary" })] }), "docs/README.md": "" });
+    const d = await found(root);
+    expect(d.map((x) => [x.ruleId, x.entity])).toEqual([
+      ["WSP131", undefined],
+      ["WSP132", undefined],
+    ]);
+    expect(d[0].message).toContain("the workspace's own diagram boundary names the source");
+  });
+});
+
+describe("diagram-render-drift (WSP133)", () => {
+  const SOURCE = "x -> y\n";
+  const HASH = sha256Hex(Buffer.from(SOURCE, "utf-8"));
+
+  test("no recorded sourceHash: never checked for drift, even when the source changed", async () => {
+    const root = repo({
+      "chant.workspace.json": declaration([diagram()]),
+      "docs/diagrams/architecture.d2": "something else entirely",
+      "docs/diagrams/architecture.svg": "<svg></svg>",
+    });
+    expect(await found(root)).toEqual([]);
+  });
+
+  test("a recorded sourceHash that matches the source passes", async () => {
+    const root = repo({
+      "chant.workspace.json": declaration([diagram({ sourceHash: HASH })]),
+      "docs/diagrams/architecture.d2": SOURCE,
+      "docs/diagrams/architecture.svg": "<svg></svg>",
+    });
+    expect(await found(root)).toEqual([]);
+  });
+
+  test("a source that changed since the recorded hash fails WSP133, without running any renderer", async () => {
+    const root = repo({
+      "chant.workspace.json": declaration([diagram({ sourceHash: HASH })]),
+      "docs/diagrams/architecture.d2": "x -> y -> z\n",
+      "docs/diagrams/architecture.svg": "<svg></svg>",
+    });
+    const d = await found(root);
+    expect(d.map((x) => [x.ruleId, x.code])).toEqual([["WSP133", "diagram-render-drift"]]);
+    expect(d[0].message).toContain("source docs/diagrams/architecture.d2 changed since docs/diagrams/architecture.svg was rendered from it");
+    expect(d[0].message).toContain(`recorded sourceHash ${HASH.slice(0, 12)}`);
+  });
+
+  test("a missing source is left to WSP131; WSP133 finds nothing to compare", async () => {
+    const root = repo({
+      "chant.workspace.json": declaration([diagram({ sourceHash: HASH })]),
+      "docs/diagrams/architecture.svg": "<svg></svg>",
+    });
+    const d = await found(root);
+    expect(d.map((x) => x.ruleId)).toEqual(["WSP131"]);
+  });
+});

package/src/workspace/checks/diagrams.ts

@@ -0,0 +1,108 @@
+/**
+ * The diagram checks, WSP131 to WSP133 (#2764).
+ *
+ * A declared diagram names a source and a render, pinned to the renderer
+ * its render was made with. chant never runs a renderer (ws-052), on a read
+ * path or here: these checks read the declaration and the tree checked
+ * only, and a render's drift is caught by comparing a recorded content hash,
+ * never by re-rendering the source.
+ *
+ * | Id | Code | Fails when |
+ * |---|---|---|
+ * | WSP131 | `diagram-source-missing` | a diagram names a source, and it does not exist in the tree read |
+ * | WSP132 | `diagram-render-missing` | a diagram's render does not exist in the tree read |
+ * | WSP133 | `diagram-render-drift` | a diagram records a `sourceHash`, and the source's bytes now hash to something else |
+ *
+ * WSP133 is opt-in per diagram: without a recorded `sourceHash` there is
+ * nothing to compare, so the entry is silently not checked for drift. A
+ * declaration records one by hashing the source when it commits a fresh
+ * render, the way a decision's evidence pins a file by hash
+ * (`../record-assets.ts`). Comparing that one recorded hash against the
+ * source in the tree read is cheap and deterministic, unlike shelling out to
+ * the pinned renderer and diffing its output, which chant does nowhere.
+ */
+
+import { sha256Hex } from "../../content-digest";
+import type { WorkspaceCheck, WorkspaceCheckContext, WorkspaceDiagnostic } from "../checks";
+import { declaredDiagrams, type DiagramDeclaration } from "../declaration";
+import type { ReasonCode } from "../reason-codes";
+
+/** The read contract's codes for the diagram findings, carried as `code` on each. */
+export const DIAGRAM_FINDING_CODES = ["diagram-source-missing", "diagram-render-missing", "diagram-render-drift"] as const satisfies readonly ReasonCode[];
+
+export const WSP_DIAGRAM_SOURCE_MISSING = "WSP131";
+export const WSP_DIAGRAM_RENDER_MISSING = "WSP132";
+export const WSP_DIAGRAM_RENDER_DRIFT = "WSP133";
+
+const where = (d: DiagramDeclaration) => (d.member === null ? "the workspace's own" : `member ${d.member}'s`);
+
+function diagramFinding(check: WorkspaceCheck, d: DiagramDeclaration, field: "source" | "render" | "sourceHash", code: (typeof DIAGRAM_FINDING_CODES)[number], message: string): WorkspaceDiagnostic {
+  return {
+    checkId: check.id,
+    severity: check.severity,
+    code,
+    message: `${code}: ${message}`,
+    entity: d.member ?? undefined,
+    pointer: `${d.pointer}/${field}`,
+  };
+}
+
+export const DIAGRAM_CHECKS: readonly WorkspaceCheck[] = [
+  {
+    id: WSP_DIAGRAM_SOURCE_MISSING,
+    name: "diagram-source-missing",
+    description: "A diagram's source file, when it names one, exists in the tree read.",
+    severity: "error",
+    configurable: true,
+    check(ctx: WorkspaceCheckContext) {
+      const out: WorkspaceDiagnostic[] = [];
+      for (const d of declaredDiagrams(ctx.declaration)) {
+        if (d.source === null || ctx.tree.stat(d.source) === "file") continue;
+        out.push(diagramFinding(this, d, "source", "diagram-source-missing", `${where(d)} diagram ${d.name} names the source ${d.source}, which does not exist${ctx.tree.label}`));
+      }
+      return out;
+    },
+  },
+  {
+    id: WSP_DIAGRAM_RENDER_MISSING,
+    name: "diagram-render-missing",
+    description: "A diagram's render exists in the tree read.",
+    severity: "error",
+    configurable: true,
+    check(ctx: WorkspaceCheckContext) {
+      const out: WorkspaceDiagnostic[] = [];
+      for (const d of declaredDiagrams(ctx.declaration)) {
+        if (ctx.tree.stat(d.render) === "file") continue;
+        out.push(diagramFinding(this, d, "render", "diagram-render-missing", `${where(d)} diagram ${d.name} names the render ${d.render}, which does not exist${ctx.tree.label}`));
+      }
+      return out;
+    },
+  },
+  {
+    id: WSP_DIAGRAM_RENDER_DRIFT,
+    name: "diagram-render-drift",
+    description: "A diagram that records a sourceHash is unchanged since its render was made: the source's bytes still hash to it. Runs no renderer.",
+    severity: "error",
+    configurable: true,
+    check(ctx: WorkspaceCheckContext) {
+      const out: WorkspaceDiagnostic[] = [];
+      for (const d of declaredDiagrams(ctx.declaration)) {
+        if (d.sourceHash === null || d.source === null) continue;
+        if (ctx.tree.stat(d.source) !== "file") continue; // diagram-source-missing already reports it
+        const bytes = ctx.tree.bytes ? ctx.tree.bytes(d.source) : Buffer.from(ctx.tree.read(d.source), "utf-8");
+        const actual = sha256Hex(bytes);
+        if (actual === d.sourceHash) continue;
+        out.push(
+          diagramFinding(
+            this,
+            d,
+            "sourceHash",
+            "diagram-render-drift",
+            `${where(d)} diagram ${d.name}'s source ${d.source} changed since ${d.render} was rendered from it: recorded sourceHash ${d.sourceHash.slice(0, 12)} does not match the source's current hash ${actual.slice(0, 12)}${ctx.tree.label}; rerun the renderer and commit the result, or update sourceHash`,
+          ),
+        );
+      }
+      return out;
+    },
+  },
+];

package/src/workspace/checks/records.ts

@@ -15,11 +15,20 @@
  * | WSP114 | the records of `--kind` can't be read (fixed) |
  * | WSP115 | a record kind the declaration names is missing or does not load as one (fixed, #2680) |
  * | WSP116 | an answer kind's decision points file is missing or not valid (fixed, ws-058, #2738) |
+ * | WSP117 | a done work item has an acceptance criterion no passing evidence meets (#2772) |
+ *
+ * WSP117 reads the records of every declared work kind with acceptance
+ * criteria, in the working tree, and the records of `--kind`. It carries the
+ * reason code `work-acceptance-unmet`.
  */
 
 import type { WorkspaceCheck, WorkspaceDiagnostic } from "../checks";
+import type { ReasonCode } from "../reason-codes";
 import type { ReadErrorCode, RecordEntry } from "../records";
 
+/** The read contract's codes the record checks carry as `code`: WSP117's (#2772). */
+export const RECORD_FINDING_CODES = ["work-acceptance-unmet"] as const satisfies readonly ReasonCode[];
+
 /** The records `check --kind` read, or why they could not be read. */
 export type RecordFacts =
   | { kind: string; records: readonly (RecordEntry & { file: string })[] }
@@ -124,4 +133,42 @@ export const RECORD_CHECKS: readonly WorkspaceCheck[] = [
       return out;
     },
   },
+  {
+    id: "WSP117",
+    name: "work-acceptance-unmet",
+    description:
+      "Every done work item meets its acceptance criteria: each has evidence that names it, passed, and has the verification the criterion expects, and a manual verdict is from someone other than the implementer (#2772).",
+    severity: "error",
+    configurable: true,
+    check(ctx) {
+      const out: WorkspaceDiagnostic[] = [];
+      const seen = new Set<string>();
+      const facts = ctx.facts?.records;
+      if (facts && !("error" in facts)) {
+        for (const r of facts.records) {
+          if (r.supersededBy !== null) continue;
+          const w = r.warnings.find((x) => x.code === "work-acceptance-unmet");
+          if (!w || seen.has(r.file)) continue;
+          seen.add(r.file);
+          out.push({ checkId: this.id, severity: this.severity, message: w.message, pointer: "", file: r.file, code: "work-acceptance-unmet" });
+        }
+      }
+      for (const k of ctx.facts?.declaredKinds ?? []) {
+        for (const a of k.acceptance ?? []) {
+          if (a.unmet === null || seen.has(a.file)) continue;
+          seen.add(a.file);
+          out.push({
+            checkId: this.id,
+            severity: this.severity,
+            message: a.unmet,
+            ...(k.declared.member !== null ? { entity: k.declared.member } : {}),
+            pointer: "",
+            file: a.file,
+            code: "work-acceptance-unmet",
+          });
+        }
+      }
+      return out;
+    },
+  },
 ];

package/src/workspace/checks.ts

@@ -29,8 +29,12 @@
  * | WSP111 to WSP114 | records read with `--kind` (#2549) |
  * | WSP115 | the record kinds the declaration names (#2680) |
  * | WSP116 | the decision points file of each declared answer kind (ws-058) |
+ * | WSP117 | a done work item's acceptance criteria all met (#2772) |
  * | 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) |
  */
 
 import { realpathSync } from "node:fs";
@@ -49,7 +53,9 @@ import { gatherLedgerFacts, LEDGER_CHECKS, type MemberLedgerFacts } from "./chec
 import { gatherPipelineFacts, PIPELINE_CHECKS, type MemberPipelineFacts } from "./checks/pipelines";
 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
@@ -67,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. */
@@ -319,6 +327,8 @@ export const WORKSPACE_CHECKS: readonly WorkspaceCheck[] = [
   ...RECORD_CHECKS,
   // Boxes and their brokered capabilities (#2726).
   ...BOX_CHECKS,
+  // Diagram artifacts (#2764).
+  ...DIAGRAM_CHECKS,
 ];
 
 const BY_ID = new Map(WORKSPACE_CHECKS.map((c) => [c.id, c]));
@@ -461,8 +471,16 @@ export async function runDeclarationChecks(
   const { registry, problems } = loadKindRegistry(declaration.pins, root);
   const gathered = options.gather === false || options.tree ? {} : await gatherWorkspaceFacts(root, declaration, options);
   // The declared record kinds load from the working tree; under --at only whether each exists at the revision is checked (#2680).
-  const declaredKinds = options.gather === false ? undefined : await loadDeclaredKinds(declaration, tree, root, { load: !options.tree });
-  const facts: WorkspaceFacts = { ...gathered, ...(options.records ? { records: options.records } : {}), ...(declaredKinds ? { declaredKinds } : {}) };
+  // 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 });
+  // 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/compose-graph.ts

@@ -113,6 +113,8 @@ export interface GraphRecord {
   state: string | null;
   valid: boolean;
   supersededBy: string | null;
+  /** The ids of records whose remediates link names this one (#2774). */
+  remediatedBy: string[];
 }
 
 /** Read one member's `chant graph --format ir` output, upgrading an unversioned (v1) IR in place. */

package/src/workspace/conformance/__fixture__/decisions/decision.kind.mjs

@@ -17,6 +17,9 @@ export const recordKind = {
   // Sealed once reached (#2555).
   closedStates: ["ratified", "superseded"],
   supersedes: { field: "supersedes", key: "decision" },
+  // A remediates link names a closed decision this one fixes the consequence
+  // of, without replacing it: the target's state never changes (#2774).
+  remediates: { field: "remediates", key: "decision" },
   // A supersedes link takes effect under an equal or stricter approval rule
   // (#2524 D4): from a record ranked above 0 and at least as high as the one it
   // names. A decided record supersedes a decided or proposed one, a ratified
@@ -26,9 +29,16 @@ export const recordKind = {
   pins: { field: "evidence" },
   // member:<name> and path:<path> entries are the record's links in workspace graph (#2549).
   constrains: { field: "constrains" },
+  // Workspace paths a change carrying the decision out must not touch
+  // (#2773): chant workspace check --changes reports change-out-of-scope.
+  outOfScope: { field: "out_of_scope" },
   // Verdicts, and the field naming the decider, for each record's digest and
   // quorum (#2671, #2672).
   reviews: { field: "reviews", decider: "decided_by" },
+  // records new --by and the MCP records-new tool's by name a proposal's
+  // proposer here, apart from decided_by, which stays null until the
+  // decision is decided (#2756).
+  proposedBy: { field: "proposed_by" },
   // source is where a decision came from, and says where its proposal came
   // from too: via, client, harness, model, session, turns and a transcript
   // pinned by hash (#2708).

package/src/workspace/conformance/__fixture__/decisions/decision.schema.json

@@ -116,6 +116,19 @@
         ]
       }
     },
+    "remediates": {
+      "description": "Closed decisions this one fixes the consequence of, without replacing them: each names the decision by id and may say why (#2774). The named decision's status never changes because of a remediates link; a decision still open is amended instead, never remediated. Optional: most decisions remediate nothing.",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["decision"],
+        "properties": {
+          "decision": { "$ref": "#/definitions/decisionId" },
+          "reason": { "type": ["string", "null"] }
+        }
+      }
+    },
     "evidence": {
       "description": "The research, audits, design sections and workspace files behind the decision. A public link carries a url; a file in the workspace carries a path and the hash of its bytes (#2549). May be empty when the decision cites nothing; chant workspace records then warns decision-no-evidence (#2654).",
       "type": "array",
@@ -127,6 +140,10 @@
       "description": "Who chose. A forge login. Null in state proposed or withdrawn.",
       "type": ["string", "null"]
     },
+    "proposed_by": {
+      "description": "Who proposed this decision: the name chant workspace records new --by or the MCP records-new tool's by wrote, for a decision that opened proposed (#2756). Null or absent when nobody named a proposer, or the decision opened straight into a later state. Never cleared by a later decide, ratify or supersede.",
+      "type": ["string", "null"]
+    },
     "decided_on": {
       "description": "When the choice was made, as YYYY-MM-DD. Quoted, so YAML reads it as a string.",
       "type": ["string", "null"],
@@ -218,6 +235,15 @@
         "type": "string",
         "pattern": "^([A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+#[0-9]+|[a-z][a-z0-9]{0,15}-[0-9]{3,}|member:[a-z0-9][a-z0-9-]{0,39}|path:(?!/)(?!(?:[^/]*/)*\\.{1,2}(?:/|$))(?!.*//)[^\\\\\\u0000-\\u001f]*[^/\\\\\\u0000-\\u001f])$"
       }
+    },
+    "out_of_scope": {
+      "description": "Workspace paths this decision puts out of scope (#2773): files or directories, from the workspace root, that a change carrying out the decision must not touch. chant workspace check --changes reports a change to one as change-out-of-scope while the decision is in hand, and the decision does not cover it even where its constrains would. Optional.",
+      "type": "array",
+      "items": {
+        "type": "string",
+        "pattern": "^(?!/)(?!(?:[^/]*/)*\\.{1,2}(?:/|$))(?!.*//)[^\\\\\\u0000-\\u001f]*[^/\\\\\\u0000-\\u001f]$"
+      },
+      "uniqueItems": true
     }
   },
   "allOf": [

package/src/workspace/conformance/index.ts

@@ -346,6 +346,9 @@ export function mcpToolCall(argv: readonly string[]): { name: string; arguments:
     else if (a === "--since") args.since = value();
     else if (a === "--compare-to") args.compareTo = value();
     else if (a === "--intent") args.intent = value();
+    else if (a === "--changes") args.range = value();
+    else if (a === "--work") args.work = value();
+    else if (a === "--severity") args.severity = value();
     else if (a === "--current") args.current = true;
     else if (a === "--composites") args.composites = true;
     else if (a.startsWith("-")) return undefined;
@@ -358,6 +361,8 @@ export function mcpToolCall(argv: readonly string[]): { name: string; arguments:
       return positional.length === 1 && kinds.length === 0 ? { name: "workspace-status", arguments: { ...args, env: positional[0] } } : undefined;
     case "records":
       return positional.length === 0 && kinds.length <= 1 ? { name: "workspace-records", arguments: { ...args, ...(kinds.length ? { kind: kinds[0] } : {}) } } : undefined;
+    case "check":
+      return positional.length === 0 && args.range !== undefined ? { name: "workspace-changes", arguments: { ...args, ...(kinds.length ? { kind: kinds } : {}) } } : undefined;
     case "graph":
       return positional.length === 0 ? { name: "workspace-graph", arguments: { ...args, ...(kinds.length ? { kind: kinds } : {}) } } : undefined;
     default:

package/src/workspace/decide.test.ts

@@ -134,7 +134,7 @@ describe("points ask (#2739)", () => {
     expect(q).toMatchObject({ state: "escalated", open: true, current: true, model: { answer: "medium", confidence: 0.175, threshold: 0.8, model: "bosun-v3.1-1.7b", observed: false } });
     expect(q.escalations.map((e) => e.reason)).toEqual(["no row matches these inputs", "not observed: confidence 0.175 is below the threshold 0.8"]);
     expect(listed.questions.every((x) => x.open)).toBe(true);
-    expect(listed.points.map((p) => p.name)).toEqual(["slice-tier", "ship-skip", "needs-decision"]);
+    expect(listed.points.map((p) => p.name)).toEqual(["slice-tier", "ship-skip", "finding-triage", "needs-a-decision", "needs-decision"]);
     expect(listed.points[0].inputs[0]).toEqual({ name: "work-item.criteria", output: "work-item", description: "acceptance criteria in the work item" });
 
     // A later ask still escalating keeps the standing record; one a model answers rewrites it, as proposed.