@intentius/chant 0.124.13 → 0.124.14

package/dist/workspace/conformance/__fixture__/delivery/src/app.component.ts

@@ -0,0 +1,14 @@
+/**
+ * The component that deploys the app. Its contract names the composite kind
+ * it deploys, so `chant workspace graph --composites` joins it to the `app`
+ * instance in app.ts.
+ */
+import type { Component } from "@intentius/chant/components/component";
+
+export const appComponent: Component = {
+  name: "app",
+  archetype: "service",
+  composites: ["WebService"],
+  dependsOn: [],
+  deploy: [],
+};

package/dist/workspace/conformance/__fixture__/delivery/src/app.ts

@@ -0,0 +1,4 @@
+import { WebService } from "../lexicon/index";
+
+/** The app, as one WebService composite instance. */
+export const app = WebService({ port: 8080 });

package/dist/workspace/conformance/__fixtures__/reference-broker.js

@@ -0,0 +1,205 @@
+/**
+ * The reference broker (#3164, ws-097): the smallest broker of the broker
+ * protocol (`../broker-protocol.ts`) that passes the conformance suite
+ * (`./broker.ts`), serving all four standard capabilities. It keeps every
+ * report in memory and buffers each request, which a real broker should not;
+ * it exists to show the suite can be passed and what passing takes, and for
+ * a test to run a box against without studio's lobby.
+ *
+ * It is a test fixture and the package does not export it: chant never runs
+ * a broker or listens on a port (ws-052, ws-086), so it lives under
+ * `__fixtures__`, which test/no-listener.e2e.test.ts leaves out like a test file.
+ * `startReferenceBroker(env)` has the shape of the suite's `start`.
+ */
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { BROKER_ROUTES, DECLARATION_LIMITS, declaredRefusal, EGRESS_CAPABILITY, FEEDBACK_CAPABILITY, FOUNTAIN_CAPABILITY, INFERENCE_CAPABILITY, parseDeclarationReport, formatPayerHeader, PAYER_HEADER, } from "../../broker-protocol.js";
+const MAX_BODY = 1024 * 1024;
+/** Request headers that describe the hop or carry the caller's credential. */
+const DROP = new Set(["host", "connection", "keep-alive", "content-length", "transfer-encoding", "authorization", "x-api-key", "cookie", "proxy-authorization", "te", "upgrade", "forwarded", "x-forwarded-for", "x-forwarded-host", "x-forwarded-proto", "x-real-ip"]);
+/** Response headers fetch has already undone. */
+const HOP = new Set(["connection", "keep-alive", "content-length", "content-encoding", "transfer-encoding"]);
+function send(res, status, value, extra = {}) {
+    res.writeHead(status, { "content-type": "application/json", "cache-control": "no-store", ...extra });
+    res.end(JSON.stringify(value));
+}
+const refuse = (res, status, message) => send(res, status, { error: { type: status === 403 ? "permission_error" : "invalid_request", message } });
+async function readBody(req) {
+    let raw = "";
+    for await (const chunk of req) {
+        raw += chunk;
+        if (raw.length > MAX_BODY)
+            return null;
+    }
+    return raw;
+}
+/** The headers to forward, without the box's credential, plus `extra`. */
+function forwarded(req, extra) {
+    const headers = {};
+    for (const [k, v] of Object.entries(req.headers))
+        if (!DROP.has(k) && v !== undefined)
+            headers[k] = [v].flat().join(", ");
+    return { ...headers, ...extra };
+}
+async function relay(res, answer, swap, extra = {}) {
+    const headers = {};
+    answer.headers.forEach((v, k) => {
+        if (!HOP.has(k))
+            headers[k] = swap ? v.split(swap[0]).join(swap[1]) : v;
+    });
+    Object.assign(headers, extra);
+    res.writeHead(answer.status, headers);
+    res.end(Buffer.from(await answer.arrayBuffer()));
+}
+/** Start the reference broker for `env`, with a fresh token per box. */
+export async function startReferenceBroker(env) {
+    const tokens = Object.fromEntries(env.boxes.map((b) => [b, `box_${randomBytes(32).toString("hex")}`]));
+    const boxOf = new Map(Object.entries(tokens).map(([box, token]) => [token, box]));
+    const reports = new Map();
+    const anthropic = new URL(env.anthropic.url);
+    // It spends the operator's one credential for every box, so the payer is shared (#3474), said on the report's answer and on each inference and decide answer.
+    const payer = { kind: "shared", principal: null };
+    const paid = { [PAYER_HEADER]: formatPayerHeader(payer) };
+    const fountain = new URL(env.fountain.url);
+    const tokenOf = (req) => {
+        const bearer = /^Bearer\s+(\S+)$/i.exec(String(req.headers.authorization ?? ""))?.[1];
+        return bearer ?? (typeof req.headers["x-api-key"] === "string" ? req.headers["x-api-key"] : undefined);
+    };
+    const server = createServer(async (req, res) => {
+        try {
+            const url = new URL(req.url ?? "/", "http://broker");
+            const path = url.pathname;
+            const method = req.method ?? "GET";
+            const token = tokenOf(req);
+            const box = token ? boxOf.get(token) : undefined;
+            const raw = await readBody(req);
+            if (raw === null)
+                return refuse(res, 413, "The request is larger than 1 MB.");
+            if (path === BROKER_ROUTES.declaration) {
+                if (method !== "POST")
+                    return refuse(res, 405, `POST ${BROKER_ROUTES.declaration}`);
+                if (!box)
+                    return refuse(res, 403, "This token is no box this broker knows.");
+                if (raw.length > DECLARATION_LIMITS.bytes)
+                    return refuse(res, 413, "The declaration is larger than 32 KB.");
+                let body;
+                try {
+                    body = JSON.parse(raw);
+                }
+                catch {
+                    return refuse(res, 400, "The body is not JSON.");
+                }
+                const parsed = parseDeclarationReport(body, env.broker);
+                if ("error" in parsed)
+                    return refuse(res, 400, parsed.error);
+                // It keeps the listing and spend a report carries (#3508) and answers with them, as studio's lobby does.
+                const { capabilities, listing, spend } = parsed;
+                const kept = { capabilities, at: new Date().toISOString(), ...(listing ? { listing } : {}), ...(spend ? { spend } : {}) };
+                reports.set(box, kept);
+                return send(res, 200, { ...kept, payer });
+            }
+            let body;
+            try {
+                body = raw ? JSON.parse(raw) : undefined;
+            }
+            catch {
+                body = undefined;
+            }
+            const request = { method, path, body };
+            for (const spec of [INFERENCE_CAPABILITY, EGRESS_CAPABILITY, FEEDBACK_CAPABILITY, FOUNTAIN_CAPABILITY]) {
+                if (!spec.routes.some((r) => path === r || path.startsWith(`${r}/`)))
+                    continue;
+                const words = spec.scopes(request);
+                if (words === null)
+                    return refuse(res, 404, `This broker does not serve ${method} ${path}.`);
+                if (words.length === 0 && spec !== FEEDBACK_CAPABILITY)
+                    return send(res, 200, {});
+                if (!box)
+                    return refuse(res, spec === INFERENCE_CAPABILITY && path === BROKER_ROUTES.decide ? 401 : 403, "This request carried no token of a box this broker knows.");
+                if (words.length === 0)
+                    return refuse(res, 400, "A batch carries entries (scope agent), counts (scope passive), or both.");
+                for (const word of words) {
+                    const refused = declaredRefusal(reports.get(box), env.broker, spec.name, word);
+                    if (refused)
+                        return refuse(res, 403, refused);
+                }
+                if (spec === INFERENCE_CAPABILITY && path === BROKER_ROUTES.decide)
+                    return decide(res, body);
+                if (spec === INFERENCE_CAPABILITY) {
+                    const rest = path.slice(BROKER_ROUTES.inference.length);
+                    const answer = await fetch(new URL(`${rest}${url.search}`, anthropic), { method, headers: forwarded(req, { "x-api-key": env.anthropic.credential }), body: raw || undefined });
+                    return relay(res, answer, undefined, paid);
+                }
+                if (spec === EGRESS_CAPABILITY) {
+                    const [name] = words;
+                    const secret = env.secrets.find((s) => s.box === box && s.name === name);
+                    if (!secret)
+                        return refuse(res, 403, `This broker holds no value for ${name}.`);
+                    const rest = path.slice(BROKER_ROUTES.egress.length + 1 + name.length) || "/";
+                    // The box's token stands in for the value wherever the API expects its key, so it is swapped in every header.
+                    const headers = {};
+                    for (const [k, v] of Object.entries(req.headers))
+                        if (v !== undefined && !HOP.has(k) && k !== "host")
+                            headers[k] = [v].flat().join(", ").split(token).join(secret.value);
+                    const search = url.search.split(token).join(secret.value);
+                    const answer = await fetch(new URL(`${rest}${search}`, secret.host), { method, headers, body: raw || undefined });
+                    return relay(res, answer, [secret.value, token]);
+                }
+                if (spec === FEEDBACK_CAPABILITY)
+                    return send(res, 202, { taken: true });
+                if (spec === FOUNTAIN_CAPABILITY) {
+                    const rest = path.slice(BROKER_ROUTES.fountain.length);
+                    const answer = await fetch(new URL(`${rest}${url.search}`, fountain), { method, headers: forwarded(req, { authorization: `Bearer ${env.fountain.credential}` }), body: raw || undefined });
+                    return relay(res, answer);
+                }
+            }
+            if (path === BROKER_ROUTES.feedback)
+                return refuse(res, 400, "A batch carries entries (scope agent), counts (scope passive), or both.");
+            return refuse(res, 404, "not found");
+        }
+        catch (err) {
+            if (!res.headersSent)
+                refuse(res, 502, `The broker could not answer: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    /** One Messages call per question, asking for JSON in a schema made from it, as studio's lobby does. */
+    async function decide(res, body) {
+        const b = body;
+        if (!b || typeof b.model !== "string" || b.state === undefined || !b.questions || typeof b.questions !== "object" || Object.keys(b.questions).length === 0) {
+            return refuse(res, 422, "The body is { model, state, questions } with at least one question.");
+        }
+        const answers = {};
+        for (const [name, q] of Object.entries(b.questions)) {
+            if (q.type !== "choice" && q.type !== "noul") {
+                answers[name] = { type: "unsupported" };
+                continue;
+            }
+            const options = q.type === "noul" ? ["true", "false"] : Object.keys(q.criteria ?? {});
+            const schema = {
+                type: "object",
+                properties: { reason: { type: "string" }, choice: { type: "string", enum: options }, probabilities: { type: "object", properties: Object.fromEntries(options.map((o) => [o, { type: "number" }])) } },
+                required: ["reason", "choice", "probabilities"],
+            };
+            const asked = await fetch(new URL("/v1/messages", anthropic), {
+                method: "POST",
+                headers: { "content-type": "application/json", "anthropic-version": "2023-06-01", "x-api-key": env.anthropic.credential },
+                body: JSON.stringify({ model: b.model, max_tokens: 1024, messages: [{ role: "user", content: `${name}: ${q.instructions}\n${JSON.stringify(b.state)}` }], output_config: { format: { type: "json_schema", schema } } }),
+            });
+            if (!asked.ok)
+                return refuse(res, 502, `The model answered ${asked.status}.`);
+            const message = (await asked.json());
+            const out = JSON.parse(message.content?.find((c) => c.type === "text")?.text ?? "{}");
+            const total = options.reduce((t, o) => t + Number(out.probabilities?.[o] ?? 0), 0) || 1;
+            const p = Object.fromEntries(options.map((o) => [o, Number(out.probabilities?.[o] ?? 0) / total]));
+            const reason = typeof out.reason === "string" ? { reason: out.reason } : {};
+            answers[name] = q.type === "noul" ? { type: "noul", noul: p.true, ...reason } : { type: "choice", choice: out.choice, probabilities: p, confidence: p[out.choice ?? ""] ?? 0, ...reason };
+        }
+        send(res, 200, { model: b.model, answers }, paid);
+    }
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve()));
+    return {
+        url: `http://127.0.0.1:${server.address().port}`,
+        tokens,
+        close: () => new Promise((resolve) => server.close(() => resolve())),
+    };
+}

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

@@ -0,0 +1,32 @@
+// 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> --note <text>
+// chant workspace points retract <id> --by <name> --note <why>
+// chant workspace points ask agent-question --inputs '{"ask.id":"req-1"}' --candidates question.json
+//
+// 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. An answer never changes in place:
+// retracting it escalates the question again and keeps the answer in the
+// record's retractions (#3351). An ad-hoc point's question and candidates
+// come with each ask and stay in the record as asked (#3403). 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/dist/workspace/conformance/__writer_fixture__/answers/answer.schema.json

@@ -0,0 +1,135 @@
+{
+  "$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. An answer never changes in place: `points retract` escalates the question to people again and moves the answer into `retractions` (#3351, ws-084). An ad-hoc point's answer keeps the question and candidates its ask gave as `asked`, and they are part of the inputs hash (#3403). 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." },
+    "asked": {
+      "type": "object",
+      "description": "An ad-hoc point's question as its ask gave it (`points ask --candidates`, #3403): its text, and its criteria in the point's question type's shape, from which candidates come. People's answer is one of them.",
+      "required": ["question", "criteria"],
+      "properties": {
+        "question": { "type": "string", "minLength": 1 },
+        "criteria": {
+          "oneOf": [
+            { "type": "object", "minProperties": 2, "maxProperties": 255, "additionalProperties": { "type": "string" } },
+            { "type": "array", "minItems": 2, "maxItems": 10, "uniqueItems": true, "items": { "type": "string", "minLength": 1 } }
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "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" },
+    "reason": { "type": "string", "minLength": 1, "description": "model: the model's own explanation of its answer, when the backend gave one (#3345). Kept when a person confirms the proposal; moved into the escalations as model_reason when people answer otherwise." },
+    "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." },
+    "note": { "type": "string", "minLength": 1, "description": "What the people who answered wrote with their answer (`points answer --note`, #3351). Moved into the retraction when the answer is retracted." },
+    "relayed_by": { "type": "string", "minLength": 1, "description": "Who carried the answer to chant for the people in answered_by (`points answer --relayed-by`, #3402), such as a follower relaying a person's answer through hud. It does not count toward the quorum. Moved into the retraction as answer_relayed_by when the answer is retracted." },
+    "retractions": {
+      "type": "array",
+      "description": "Answers people took back, oldest first (`points retract`, #3351): each answer as it was, and who retracted it, when and why. A retracted question is escalated to people again.",
+      "items": { "$ref": "#/definitions/retraction" }
+    },
+    "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" } },
+    "retraction": {
+      "type": "object",
+      "required": ["answer", "decider", "by", "on"],
+      "properties": {
+        "answer": { "type": ["string", "boolean"], "description": "The answer retracted." },
+        "decider": { "type": "object", "required": ["kind"], "properties": { "kind": { "enum": ["table", "model", "quorum"] } }, "description": "Who gave it: the record's decider as it was." },
+        "answered_by": { "type": "array", "items": { "type": "string", "minLength": 1 } },
+        "answered_on": { "$ref": "#/definitions/date" },
+        "answer_note": { "type": "string", "minLength": 1, "description": "The note the answer carried." },
+        "answer_relayed_by": { "type": "string", "minLength": 1, "description": "Who relayed the answer (#3402)." },
+        "by": { "type": "array", "minItems": 1, "items": { "type": "string", "minLength": 1 }, "description": "Who retracted it." },
+        "on": { "$ref": "#/definitions/date" },
+        "note": { "type": "string", "minLength": 1, "description": "Why it was retracted (`points retract --note`)." }
+      },
+      "additionalProperties": false
+    },
+    "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" },
+        "model_reason": { "type": "string", "minLength": 1, "description": "model: the model's own explanation of the answer it gave, when the backend gave one (#3345). reason is why the decider did not answer." }
+      },
+      "additionalProperties": false
+    }
+  }
+}

package/dist/workspace/conformance/__writer_fixture__/contracts/contract.kind.mjs

@@ -0,0 +1,37 @@
+// The contract record kind (#3148, ws-082), data only: no imports, no code.
+//
+// chant workspace records --kind design/contracts/contract.kind.mjs --current --json
+//
+// A contract is an acceptance criterion made formal: what a person can do,
+// the criteria a check proves, and the check itself, a file pinned by hash.
+// It is drafted, approved once its reviewers agree, and retired when nothing
+// should be built against it any more. Studio's factory builds work items
+// against approved contracts; a work kind links an item to its contract with
+// work.contract (#3147). Each check run's result is an evidence record
+// (../evidence/evidence.kind.mjs) that names the contract and its criteria.
+export const recordKind = {
+  name: "contract",
+  location: { dir: ".", match: "^C-[0-9]{3,}-.+\\.md$" },
+  format: "markdown-front-matter",
+  schema: { id: "urn:intentius:chant:contract:1", path: "contract.schema.json" },
+  idField: "id",
+  stateField: "state",
+  states: ["draft", "approved", "retired"],
+  // An approved contract changes only in its state, its check pins and its
+  // reviews: anything else is a new contract that supersedes it. A retired
+  // contract is final and sealed.
+  closedStates: ["retired"],
+  approval: { draft: 0, approved: 1, retired: 1 },
+  seal: { field: "closed_digest" },
+  // A bare id or a list of ids, as studio's contracts write it. A link takes
+  // effect from an approved or retired contract.
+  supersedes: { field: "supersedes" },
+  // The contract's checks, each a workspace file pinned by the hash of its
+  // bytes (#2549): records reports a check edited after it was pinned.
+  pins: { field: "checks" },
+  // Verdicts on the contract, given in a review session (whose subjects
+  // include this kind) or with records review, and who approved it.
+  reviews: { field: "reviews", decider: "approved_by" },
+  // records new --by names a draft's proposer here (#2756).
+  proposedBy: { field: "proposed_by" },
+};