@intentius/chant 0.100.0 → 0.102.0

package/src/workspace/checks.ts

@@ -24,7 +24,7 @@
  * | WSP001 to WSP011 | the declaration and member kinds (this file) |
  * | WSP071, WSP072 | member ledgers |
  * | WSP081 to WSP083 | recorded pipelines |
- * | WSP091 to WSP097 | member links (#2539) |
+ * | WSP091 to WSP098 | member links (#2539, #2558) |
  * | WSP101 to WSP106 | generated files |
  * | WSP111 to WSP114 | records read with `--kind` (#2549) |
  * | WSP115 | the record kinds the declaration names (#2680) |
@@ -34,6 +34,7 @@
  * | 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) |
+ * | WSP141, WSP142 | member links resolved against a live read, with `--live` (#2549) |
  * | WSP131 to WSP133 | diagram artifacts: source and render exist, a recorded source hash still matches (#2764) |
  */
 
@@ -45,12 +46,14 @@ import { readDeclaration, resolveGroups, WorkspaceReadError, type Declaration, t
 import type { ReasonCode } from "./reason-codes";
 import { parseJsonText, pointerToken, type TextLocation } from "./jsonc";
 import { loadKindRegistry, probeKind, resolveKind, type KindLoadProblem, type KindRegistry } from "./kinds";
+import { coreClassRegistry, loadClassRegistry, unknownScopeClasses, type ClassRegistry } from "./principal-classes";
 import { gitTop, workingTree, type WorkspaceTree } from "./tree";
 import { LINK_CHECKS, linkTable } from "./checks/links";
-import type { LinkTableRow } from "./links";
+import type { LinkRow, LinkTableRow } from "./links";
 import { gatherGeneratedFacts, GENERATED_CHECKS, type GeneratedFileFacts } from "./checks/generated";
 import { gatherLedgerFacts, LEDGER_CHECKS, type MemberLedgerFacts } from "./checks/ledgers";
 import { gatherPipelineFacts, PIPELINE_CHECKS, type MemberPipelineFacts } from "./checks/pipelines";
+import { gatherLiveLinkFacts, LIVE_CHECKS, type LiveLinkFacts } from "./checks/live";
 import { RECORD_CHECKS, type RecordFacts } from "./checks/records";
 import { BOX_CHECKS } from "./checks/boxes";
 import { DIAGRAM_CHECKS } from "./checks/diagrams";
@@ -73,6 +76,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 declared links resolved against a live read, with `--live` (#2549). */
+  live?: LiveLinkFacts;
   /** The decision record each box's intent names, read from the working tree (#2850). */
   boxIntents?: readonly ResolvedBoxIntent[];
 }
@@ -85,6 +90,10 @@ export interface WorkspaceCheckContext {
   kinds: KindRegistry;
   /** Why some pinned kinds could not be read. */
   kindProblems: KindLoadProblem[];
+  /** The principal classes: the core four and those the pins supply (#3080). Without it, the core four. */
+  classes?: ClassRegistry;
+  /** Why some pinned principal classes could not be read (#3080). */
+  classProblems?: KindLoadProblem[];
   /** The facts gathered before the checks ran. */
   facts?: WorkspaceFacts;
 }
@@ -137,6 +146,8 @@ export interface DeclarationCheckReport {
   suppressed: SuppressedFinding[];
   /** The member links, declared and inferred, as resolved in source (#2539). */
   links: LinkTableRow[];
+  /** With `--live`, the declared links as resolved against a live read of `env` (#2549). */
+  live?: { env: string; links: LinkRow[] };
   /** Whether an error-severity finding is active. */
   ok: boolean;
 }
@@ -176,23 +187,41 @@ export const WORKSPACE_CHECKS: readonly WorkspaceCheck[] = [
   {
     id: "WSP002",
     name: "kinds-unreadable",
-    description: "Every pinned package's kinds can be read: it is installed at the pinned version, and its ./workspace-kinds file is valid kind data.",
+    description: "Every pinned package's kinds and principal classes can be read: it is installed at the pinned version, its ./workspace-kinds file is valid kind data, and its ./workspace-principals file is valid class data.",
     severity: "error",
     configurable: false,
     check(ctx) {
-      return ctx.kindProblems.map((p) => ({ checkId: this.id, severity: this.severity, message: p.message, pointer: `/pins/${p.pin}` }));
+      // A pin that can't be read is a problem for both loaders; report it once.
+      const seen = new Set<string>();
+      return [...ctx.kindProblems, ...(ctx.classProblems ?? [])]
+        .filter((p) => {
+          const key = `${p.pin}\0${p.message}`;
+          if (seen.has(key)) return false;
+          seen.add(key);
+          return true;
+        })
+        .map((p) => ({ checkId: this.id, severity: this.severity, message: p.message, pointer: `/pins/${p.pin}` }));
     },
   },
   {
     id: "WSP003",
     name: "kind-unknown",
-    description: "Every member's kind is built in or supplied by a pinned package. Unknown kinds fail closed.",
+    description: "Every member's kind is built in or supplied by a pinned package, and so is every principal class writeScope names (#3080). Unknown kinds and classes fail closed.",
     severity: "error",
     configurable: false,
     check(ctx) {
-      return ctx.declaration.members
+      const members = ctx.declaration.members
         .filter((m) => ctx.kinds.get(m.kind) === undefined)
         .map((m) => entryFinding(this, m, "kind", `member ${m.name} has kind ${m.kind}, which no built-in kind or pinned package supplies; known kinds: ${ctx.kinds.names().join(", ")}`));
+      const classes = ctx.classes ?? coreClassRegistry();
+      const scope = unknownScopeClasses(ctx.declaration.writeScope, classes).map((c) => ({
+        checkId: this.id,
+        severity: this.severity,
+        message: `writeScope names the principal class ${c}, which no core class or pinned package supplies, so a writer judged human is refused with write-scope-class-unknown; known classes: ${classes.names().join(", ")}`,
+        entity: c,
+        pointer: `/writeScope/${pointerToken(c)}`,
+      }));
+      return [...members, ...scope];
     },
   },
   {
@@ -319,7 +348,7 @@ export const WORKSPACE_CHECKS: readonly WorkspaceCheck[] = [
   ...LEDGER_CHECKS,
   // Recorded pipelines (#2542).
   ...PIPELINE_CHECKS,
-  // Member links (#2539), WSP091 to WSP097.
+  // Member links (#2539, #2558), WSP091 to WSP098.
   ...LINK_CHECKS,
   // Generated files (#2541).
   ...GENERATED_CHECKS,
@@ -329,6 +358,8 @@ export const WORKSPACE_CHECKS: readonly WorkspaceCheck[] = [
   ...BOX_CHECKS,
   // Diagram artifacts (#2764).
   ...DIAGRAM_CHECKS,
+  // Links resolved against a live read, with --live (#2549), WSP141 and WSP142.
+  ...LIVE_CHECKS,
 ];
 
 const BY_ID = new Map(WORKSPACE_CHECKS.map((c) => [c.id, c]));
@@ -406,6 +437,13 @@ export interface DeclarationCheckOptions {
   tree?: WorkspaceTree;
   /** The records read with `--kind`, in the same tree (#2549). Given with or without `tree`. */
   records?: RecordFacts;
+  /**
+   * Resolve the declared links against a live read of this environment
+   * (`--live --env`, #2549). Each `chant` member runs `chant graph --live`, so
+   * this reaches whatever those reach. Not with `tree`: a live read is of the
+   * account now. `onStderr` gets each member's stderr.
+   */
+  live?: { env: string; onStderr?: (text: string) => void };
 }
 
 /**
@@ -469,6 +507,7 @@ export async function runDeclarationChecks(
     return { file: display(location.file), diagnostics: [diagnostic], suppressed: [], links: [], ok: false };
   }
   const { registry, problems } = loadKindRegistry(declaration.pins, root);
+  const classes = loadClassRegistry(declaration.pins, root, { tree });
   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).
   // A declared work kind's acceptance criteria are counted in the working tree too (#2772).
@@ -480,8 +519,9 @@ export async function runDeclarationChecks(
     ...(options.records ? { records: options.records } : {}),
     ...(declaredKinds ? { declaredKinds } : {}),
     ...(boxIntents ? { boxIntents } : {}),
+    ...(options.live && !options.tree ? { live: await gatherLiveLinkFacts(root, declaration, registry, options.live.env, options.live.onStderr) } : {}),
   };
-  const ctx: WorkspaceCheckContext = { declaration, tree, groups, kinds: registry, kindProblems: problems, facts };
+  const ctx: WorkspaceCheckContext = { declaration, tree, groups, kinds: registry, kindProblems: problems, classes: classes.registry, classProblems: classes.problems, facts };
   const findings = runWorkspaceChecks(ctx);
   const { active, suppressed } = applyCheckSettings(declaration, findings);
 
@@ -507,6 +547,7 @@ export async function runDeclarationChecks(
     diagnostics,
     suppressed: suppressed.map((s) => ({ ...toFinding(s), reason: s.reason })).sort(order),
     links: linkTable(ctx),
+    ...(facts.live ? { live: { env: facts.live.env, links: facts.live.rows } } : {}),
     ok: !diagnostics.some((d) => d.severity === "error"),
   };
 }

package/src/workspace/compose-graph.test.ts

@@ -146,3 +146,50 @@ describe("the links section (#2539)", () => {
     ]);
   });
 });
+
+describe("collectors (#2559)", () => {
+  const topology = {
+    pipelines: [{ id: "traces", signal: "traces", receivers: ["otlp"], processors: ["batch"], exporters: ["otlphttp/honeycomb"] }],
+    components: [
+      { id: "otlp", kind: "receiver", type: "otlp", builtin: true, endpoints: ["0.0.0.0:4317"], protocols: ["grpc"], pipelines: ["traces"] },
+      { id: "otlphttp/honeycomb", kind: "exporter", type: "otlphttp", builtin: true, endpoints: ["https://api.honeycomb.io"], protocols: ["http/protobuf"], pipelines: ["traces"] },
+    ],
+    exporters: [{ id: "otlphttp/honeycomb", type: "otlphttp", endpoints: ["https://api.honeycomb.io"], pipelines: ["traces"], signals: ["traces"] }],
+    edges: [],
+    semconv: [],
+  };
+  const withMeta = (meta: Record<string, unknown>): GraphIR => ({ ...structuredClone(db), meta });
+
+  test("lifts a member's meta.collector into a section and keeps the rest of its meta", () => {
+    const inputs = [
+      { member: member("web", "web"), ir: structuredClone(web) },
+      { member: member("ops", "ops"), ir: withMeta({ collector: topology, other: 1 }) },
+    ];
+    const doc = composeWorkspaceGraph({ name: "acme", root: "/w" }, inputs);
+    expect(doc.collectors).toEqual([
+      {
+        member: "ops",
+        pipelines: topology.pipelines,
+        components: topology.components.map(({ builtin: _b, ...c }) => c),
+        exporters: topology.exporters,
+      },
+    ]);
+    expect(doc.members.find((m) => m.name === "ops")!.meta).toEqual({ other: 1 });
+  });
+
+  test("is empty when no member reports a collector, and leaves meta alone", () => {
+    const doc = composeWorkspaceGraph({ name: "acme", root: "/w" }, [
+      { member: member("web", "web"), ir: structuredClone(web) },
+      { member: member("ops", "ops"), ir: withMeta({ _behaviour: { engine: "x" } }) },
+    ]);
+    expect(doc.collectors).toEqual([]);
+    expect(doc.members.find((m) => m.name === "ops")!.meta).toEqual({ _behaviour: { engine: "x" } });
+  });
+
+  test("ignores a meta.collector that is not a topology", () => {
+    for (const bad of ["x", 1, null, {}, { pipelines: "no" }]) {
+      const doc = composeWorkspaceGraph({ name: "acme", root: "/w" }, [{ member: member("ops", "ops"), ir: withMeta({ collector: bad }) }]);
+      expect(doc.collectors, JSON.stringify(bad)).toEqual([]);
+    }
+  });
+});

package/src/workspace/compose-graph.ts

@@ -29,6 +29,7 @@
  * `chant graph` itself is untouched: this is the only place members compose.
  */
 
+import type { FactoryView, ListingView } from "./box-factory";
 import type { Declaration } from "./declaration";
 import type { KindRegistry } from "./kinds";
 import { graphLinks, type LinkTableRow } from "./links";
@@ -87,12 +88,81 @@ export interface ComposedMember {
   cached?: boolean;
   /** The member's stamp (#2876): what the cache keys the read on, or null when none could be taken. */
   stamp?: string | null;
+  /**
+   * For a member of kind `workspace` (#2551, ws-071): the nested workspace's
+   * own view, read through its own `chant workspace graph`. Its nodes are in
+   * the outer `nodes` with `outer/inner/id` ids.
+   */
+  nested?: NestedWorkspace;
+  /**
+   * The factory and listing the member's box block declares (#3146, ws-077),
+   * read from the declaration at the revision read. Set by
+   * `chant workspace graph` on every member; null when the box declares neither.
+   */
+  box?: { factory: FactoryView | null; listing: ListingView | null } | null;
   /** Whole-read facts the member's IR carried (`meta`, `pipeline`), kept apart from the composed sections. */
   meta?: Record<string, unknown>;
   pipeline?: unknown;
 }
 
-export type ComposedNode = IRNode & { member: string };
+/** A nested workspace as the outer graph shows it (#2551, ./nested-graph.ts). */
+export interface NestedWorkspace {
+  /** The nested declaration's name. */
+  name: string;
+  /** The contract version of the document the nested read printed. */
+  contract: number;
+  /** The nested workspace's members, as its own graph lists them. */
+  members: ComposedMember[];
+  /** The nested workspace's links, with member names as the nested side writes them. */
+  links: (LinkTableRow | RecordLinkRow)[];
+}
+
+/**
+ * A collector pipeline as a member's IR reports it (#2559). Plain data, so
+ * core never imports the lexicon that computes it.
+ */
+export interface CollectorPipeline {
+  /** The id under `service.pipelines`, such as `traces` or `traces/backend`. */
+  id: string;
+  signal: string;
+  receivers: string[];
+  processors: string[];
+  exporters: string[];
+}
+
+/** One collector component with the addresses its config states. */
+export interface CollectorComponent {
+  id: string;
+  kind: string;
+  type: string;
+  endpoints: string[];
+  /** The wire protocols it speaks (`grpc`, `http/protobuf`, `http/json`); empty when unknown (#2558). */
+  protocols: string[];
+  pipelines: string[];
+}
+
+/** An exporter and the signals that reach it: where a member's telemetry goes. */
+export interface CollectorExporter {
+  id: string;
+  type: string;
+  endpoints: string[];
+  pipelines: string[];
+  signals: string[];
+}
+
+/** The topology of one member's collector config, from the lexicon that types it. */
+export interface MemberCollector {
+  member: string;
+  pipelines: CollectorPipeline[];
+  components: CollectorComponent[];
+  exporters: CollectorExporter[];
+}
+
+/** The meta key a lexicon's `graphMeta` hook answers the collector under. */
+export const COLLECTOR_META_KEY = "collector";
+
+/** `nested` names the nested workspace's member a node was read through (#2551); absent for the outer workspace's own nodes. */
+export type ComposedNode = IRNode & { member: string; nested?: string };
 export type ComposedEdge = IREdge & { member: string };
 
 export interface WorkspaceGraph {
@@ -110,6 +180,11 @@ export interface WorkspaceGraph {
    * the records read with `--kind` (#2549). Empty when no declaration is given.
    */
   links: (LinkTableRow | RecordLinkRow)[];
+  /**
+   * The collector pipelines and exporters of each member that declares a
+   * collector, in declaration order (#2559). Empty when none does.
+   */
+  collectors: MemberCollector[];
   /** The records read with `--kind` (#2524 D4, #2549). Empty without it. */
   records: GraphRecord[];
 }
@@ -163,6 +238,46 @@ export interface ComposeInput {
 
 const prefix = (member: string, id: string): string => `${member}/${id}`;
 
+const strings = (v: unknown): string[] => (Array.isArray(v) ? v.filter((x): x is string => typeof x === "string") : []);
+const records = (v: unknown): Record<string, unknown>[] =>
+  Array.isArray(v) ? v.filter((x): x is Record<string, unknown> => typeof x === "object" && x !== null) : [];
+
+/**
+ * A member's collector topology from its IR meta, or null when the meta holds
+ * none or something that isn't one. Read defensively: the topology comes from
+ * a lexicon the member's own toolchain loaded, which may be newer or older
+ * than this chant.
+ */
+function readCollector(member: string, value: unknown): MemberCollector | null {
+  if (typeof value !== "object" || value === null || !Array.isArray((value as { pipelines?: unknown }).pipelines)) return null;
+  const v = value as Record<string, unknown>;
+  return {
+    member,
+    pipelines: records(v.pipelines).map((p) => ({
+      id: String(p.id),
+      signal: String(p.signal),
+      receivers: strings(p.receivers),
+      processors: strings(p.processors),
+      exporters: strings(p.exporters),
+    })),
+    components: records(v.components).map((c) => ({
+      id: String(c.id),
+      kind: String(c.kind),
+      type: String(c.type),
+      endpoints: strings(c.endpoints),
+      protocols: strings(c.protocols),
+      pipelines: strings(c.pipelines),
+    })),
+    exporters: records(v.exporters).map((e) => ({
+      id: String(e.id),
+      type: String(e.type),
+      endpoints: strings(e.endpoints),
+      pipelines: strings(e.pipelines),
+      signals: strings(e.signals),
+    })),
+  };
+}
+
 function prefixRefs(value: unknown, member: string): unknown {
   if (Array.isArray(value)) return value.map((v) => prefixRefs(v, member));
   if (value === null || typeof value !== "object") return value;
@@ -202,6 +317,7 @@ export function composeWorkspaceGraph(
   const shared: Record<"byLexicon" | "byComposite", Record<string, string[]>> = { byLexicon: {}, byComposite: {} };
   const scoped: Record<"byStack" | "byContainer" | "byWave", Record<string, string[]>> = { byStack: {}, byContainer: {}, byWave: {} };
   const derivedAttrs: Record<string, Set<string>> = {};
+  const collectors: MemberCollector[] = [];
 
   for (const { member, ir } of inputs) {
     if (!ir) continue;
@@ -225,7 +341,14 @@ export function composeWorkspaceGraph(
     for (const e of ir.exports ?? []) exports.push({ ...e, ...(e.node ? { node: prefix(m, e.node) } : {}), member: m });
     for (const i of ir.imports ?? []) imports.push({ ...i, node: prefix(m, i.node), member: m });
     for (const [kind, attrs] of Object.entries(ir.derivedAttrs ?? {})) for (const a of attrs) (derivedAttrs[kind] ??= new Set()).add(a);
-    if (ir.meta) member.meta = ir.meta;
+    if (ir.meta) {
+      // The collector topology has a section of its own; the rest of the meta stays on the member.
+      const { [COLLECTOR_META_KEY]: collector, ...rest } = ir.meta;
+      const read = readCollector(m, collector);
+      if (read) collectors.push(read);
+      if (!read) member.meta = ir.meta;
+      else if (Object.keys(rest).length > 0) member.meta = rest;
+    }
     if (ir.pipeline) member.pipeline = ir.pipeline;
   }
 
@@ -247,8 +370,9 @@ export function composeWorkspaceGraph(
     exports,
     imports,
     links: links
-      ? graphLinks(links.declaration, { composed: inputs.filter((i) => i.ir).map((i) => i.member.name), exports, imports }, links.kinds)
+      ? graphLinks(links.declaration, { composed: inputs.filter((i) => i.ir).map((i) => i.member.name), collectors, exports, imports }, links.kinds)
       : [],
+    collectors,
     records: [],
   };
   if (Object.keys(derivedAttrs).length) {

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

@@ -14,8 +14,14 @@ export const recordKind = {
   idField: "id",
   stateField: "state",
   states: ["proposed", "decided", "ratified", "superseded", "withdrawn"],
-  // Sealed once reached (#2555).
+  // Sealed once reached (#2555): records amend and new write the whole-file
+  // seal into closed_digest when a decision enters one, and records checks it
+  // on every read (#2546, ws-063).
   closedStates: ["ratified", "superseded"],
+  seal: { field: "closed_digest" },
+  // The current decisions, with the files they pin, are the workspace's spec:
+  // records --current --json lists them under spec (#2524 D20, #2546).
+  spec: true,
   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).

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

@@ -227,6 +227,11 @@
         "signature": { "description": "The armored ssh signature, as ssh-keygen -Y sign prints it.", "type": "string", "pattern": "^-----BEGIN SSH SIGNATURE-----\\n" }
       }
     },
+    "closed_digest": {
+      "description": "The decision's whole-file seal (#2546, ws-063): sha256: and the lowercase hex SHA-256 of the JCS form of {body, core}, where core is this front matter without closed_digest and body is the text below it, line endings LF. chant workspace records amend and new write it when the decision enters a closed state (ratified or superseded), and records reports record-seal-mismatch if the file changes afterwards. It covers the reviews, the author seal and the state, which the review digest leaves out, and the digest leaves this field out.",
+      "type": "string",
+      "pattern": "^sha256:[0-9a-f]{64}$"
+    },
     "constrains": {
       "description": "What this decision governs: issues (owner/repo#n), other decisions (their ids), workspace members (member:<name>) or files and directories in the workspace (path:<path>, the grammar of an evidence path, #2549). At least one entry: a decision that governs nothing is refused.",
       "type": "array",

package/src/workspace/conformance/__writer_fixture__/answers/answer.kind.mjs

@@ -0,0 +1,27 @@
+// The answers to the workspace's decision points (ws-058, #2739), data only:
+// no imports, no code.
+//
+// chant workspace points --open --json
+// chant workspace points ask slice-tier --inputs inputs.json --subject W-002
+// chant workspace points answer <id> --answer medium --by <name>
+//
+// The points are declared in ../decisions/points.json: typed questions, the
+// read-contract outputs they read, and a table, model and quorum chain. Each
+// answer is one record here, named for the point and its inputs' hash, so the
+// same question is answered once. A table's answer is answered, a model's is
+// proposed until a person confirms it, and a question nobody before the
+// quorum answered is escalated to people. answer.schema.json is a copy of the
+// one @intentius/chant ships as workspace/point-answer.schema.json.
+export const recordKind = {
+  name: "answer",
+  location: { dir: ".", match: "^[a-z][a-z0-9-]*-[0-9a-f]{12}\\.md$" },
+  format: "markdown-front-matter",
+  schema: { id: "urn:intentius:chant:point-answer:1", path: "answer.schema.json" },
+  idField: "id",
+  stateField: "state",
+  states: ["escalated", "proposed", "answered"],
+  closedStates: ["answered"],
+  constrains: { field: "constrains" },
+  source: { field: "source" },
+  answers: { points: "../decisions/points.json" },
+};

package/src/workspace/conformance/__writer_fixture__/answers/answer.schema.json

@@ -0,0 +1,95 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "urn:intentius:chant:point-answer:1",
+  "title": "Decision point answer front matter",
+  "description": "The front matter of one answer to a decision point (ws-058, #2739), as `chant workspace points ask` and `points answer` write it into the records directory of a record kind with an `answers` block. One record per point, declaration and inputs: its id is the point's name and the first 12 hex digits of the inputs hash, so the same question is answered once. A table's answer is `answered`; a model's answer at or above its threshold is `proposed` until a person confirms it; a question no decider before the quorum answered is `escalated`, open for people. A workspace copies this file next to its answer kind, as reference-workspace/answers/ does. Values stay within what YAML and JSON share. Fields other than these must start with x-.",
+  "type": "object",
+  "additionalProperties": false,
+  "patternProperties": { "^x-": {} },
+  "required": ["id", "title", "point", "point_version", "question_type", "candidates", "inputs", "inputs_hash", "state", "decider", "asked_on"],
+  "properties": {
+    "id": { "type": "string", "pattern": "^[a-z][a-z0-9-]*-[0-9a-f]{12}$", "description": "The point's name, a hyphen, and the first 12 hex digits of inputs_hash." },
+    "title": { "type": "string", "minLength": 1 },
+    "point": { "type": "string", "pattern": "^[a-z][a-z0-9-]*$", "description": "The point in the points file this answers." },
+    "point_version": { "$ref": "#/definitions/sha256", "description": "sha256 of the point's declaration when it was asked. Editing the question or any decider changes it." },
+    "question_type": { "enum": ["noul", "choice", "score"] },
+    "candidates": { "type": "array", "minItems": 2, "items": { "type": ["string", "boolean"] }, "description": "The answers the question allowed: true and false, a choice's options, or a score's levels." },
+    "inputs": { "type": "object", "description": "The state the deciders saw, input name to value." },
+    "inputs_hash": { "$ref": "#/definitions/sha256", "description": "sha256 of the point, its version and its inputs. The same hash is answered once." },
+    "constrains": { "type": "array", "items": { "type": "string", "minLength": 1 }, "description": "What the question is about, such as a work item's id." },
+    "state": { "enum": ["escalated", "proposed", "answered"] },
+    "answer": { "type": ["string", "boolean"] },
+    "decider": {
+      "type": "object",
+      "required": ["kind"],
+      "properties": {
+        "kind": { "enum": ["table", "model", "quorum"] },
+        "row": { "type": "integer", "minimum": 0, "description": "table: the row that matched." },
+        "backend": { "type": "string", "minLength": 1 },
+        "model": { "type": "string", "minLength": 1, "description": "model: the model id that answered, as the backend reported it." },
+        "count": { "type": "integer", "minimum": 1 },
+        "roles": { "type": "array", "items": { "type": "string" } },
+        "by": { "type": "array", "items": { "type": "string" }, "description": "quorum: who answered." }
+      },
+      "additionalProperties": false
+    },
+    "probabilities": { "$ref": "#/definitions/probabilities" },
+    "confidence": { "$ref": "#/definitions/unit" },
+    "threshold": { "$ref": "#/definitions/unit" },
+    "escalations": {
+      "type": "array",
+      "description": "The deciders asked before the one that answered, or before the quorum, and why each did not answer.",
+      "items": { "$ref": "#/definitions/escalation" }
+    },
+    "answered_by": { "type": "array", "minItems": 1, "items": { "type": "string", "minLength": 1 }, "description": "The people who answered or confirmed it." },
+    "asked_on": { "$ref": "#/definitions/date" },
+    "answered_on": { "$ref": "#/definitions/date" },
+    "source": {
+      "type": "object",
+      "description": "Where the answer came from (#2708): via, client and model, the model id that answered when a model decider did."
+    }
+  },
+  "allOf": [
+    {
+      "if": { "properties": { "state": { "const": "proposed" } }, "required": ["state"] },
+      "then": { "required": ["answer"], "properties": { "decider": { "properties": { "kind": { "const": "model" } } } } }
+    },
+    {
+      "if": { "properties": { "state": { "const": "answered" } }, "required": ["state"] },
+      "then": { "required": ["answer", "answered_on"] }
+    },
+    {
+      "if": { "properties": { "state": { "const": "escalated" } }, "required": ["state"] },
+      "then": { "not": { "required": ["answer"] }, "properties": { "decider": { "properties": { "kind": { "const": "quorum" } } } } }
+    },
+    {
+      "if": { "properties": { "decider": { "properties": { "kind": { "const": "model" } }, "required": ["kind"] } }, "required": ["decider"] },
+      "then": { "required": ["probabilities", "confidence", "threshold"], "properties": { "decider": { "required": ["backend", "model"] } } }
+    },
+    {
+      "if": { "properties": { "state": { "const": "answered" }, "decider": { "properties": { "kind": { "const": "quorum" } }, "required": ["kind"] } }, "required": ["state", "decider"] },
+      "then": { "required": ["answered_by"], "properties": { "decider": { "required": ["by"] } } }
+    }
+  ],
+  "definitions": {
+    "sha256": { "type": "string", "pattern": "^[0-9a-f]{64}$" },
+    "unit": { "type": "number", "minimum": 0, "maximum": 1 },
+    "date": { "type": "string", "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$" },
+    "probabilities": { "type": "object", "additionalProperties": { "$ref": "#/definitions/unit" } },
+    "escalation": {
+      "type": "object",
+      "required": ["kind", "reason"],
+      "properties": {
+        "kind": { "enum": ["table", "model"] },
+        "reason": { "type": "string", "minLength": 1 },
+        "backend": { "type": "string" },
+        "model": { "type": "string" },
+        "answer": { "type": ["string", "boolean", "null"] },
+        "probabilities": { "$ref": "#/definitions/probabilities" },
+        "confidence": { "$ref": "#/definitions/unit" },
+        "threshold": { "$ref": "#/definitions/unit" }
+      },
+      "additionalProperties": false
+    }
+  }
+}