@intentius/chant 0.90.0 → 0.91.0

package/dist/workspace/declaration.schema.json

@@ -56,6 +56,13 @@
                 "$ref": "#/$defs/recordKind"
             }
         },
+        "hosts": {
+            "type": "array",
+            "description": "The hosts boxes run on (#2727). A host is one machine reached under one hostname: boxes on it share its ports, its state root and, in a browser, its cookie jar, so chant workspace check compares the boxes on one host and never boxes on different hosts. A member's box block names its host. Added in schema 1 by chant 0.91.0, so a declaration that uses it sets minReader to 0.91.0 or newer.",
+            "items": {
+                "$ref": "#/$defs/host"
+            }
+        },
         "checks": {
             "type": "object",
             "description": "Severity for the declaration checks that allow it, keyed by WSP id (#2535, ws-028): error, warning, info or off. chant workspace check refuses an id it does not know, and one whose severity is fixed.",
@@ -269,6 +276,9 @@
                         "$ref": "#/$defs/recordKind"
                     }
                 },
+                "box": {
+                    "$ref": "#/$defs/box"
+                },
                 "upstream": {
                     "type": "string",
                     "minLength": 1,
@@ -354,6 +364,114 @@
             "description": "A file or directory path with / separators: no leading /, no . or .. segments and no trailing /.",
             "pattern": "^(?!\\.\\.?(/|$))[^/\\\\]+(/(?!\\.\\.?(/|$))[^/\\\\]+)*$"
         },
+        "box": {
+            "type": "object",
+            "description": "The member is a box, or holds a box's declarations (#2726). A box holds no credential: each capability it needs outside itself is reached through a broker, a runtime such as a lobby or a door, which holds the credential and enforces the scope. chant workspace check fails when a file in the member's directory carries a literal secret (WSP121) and when a capability names no broker (WSP122). chant workspace status --json lists the capabilities, so a broker can read the scopes. Its host, slot, ports, state and cookies state the box's isolation (#2727): chant derives each value from the box's identity, its host, the member's name and its slot, and prints them in chant workspace status --json, so a runtime reads them instead of choosing its own. chant workspace check fails when two boxes on a host resolve to the same value (WSP123) and when a box hard-codes a machine path (WSP124). Added in schema 1 by chant 0.91.0, so a declaration that uses it sets minReader to 0.91.0 or newer.",
+            "properties": {
+                "capabilities": {
+                    "type": "array",
+                    "description": "Each capability the box reaches outside itself, named once. None when omitted.",
+                    "items": {
+                        "$ref": "#/$defs/capability"
+                    }
+                },
+                "host": {
+                    "$ref": "#/$defs/name",
+                    "description": "The host the box runs on, one of the top-level hosts (#2727). The box's name is the member's name."
+                },
+                "slot": {
+                    "type": "integer",
+                    "minimum": 0,
+                    "description": "The box's number on its host (#2727). Its ports come from the slot's block of the host's range."
+                },
+                "ports": {
+                    "type": "object",
+                    "description": "The ports the box listens on, each a name and its offset in the box's block (#2727). The port is the block's first port plus the offset.",
+                    "propertyNames": {
+                        "$ref": "#/$defs/kindName"
+                    },
+                    "additionalProperties": {
+                        "type": "integer",
+                        "minimum": 0,
+                        "maximum": 65534
+                    }
+                },
+                "state": {
+                    "type": "object",
+                    "description": "State the box keeps outside its checkout, such as hud's identity and database, each a name and a path relative to the box's state directory (#2727). The name is usually the environment variable the runtime sets, such as HUD_IDENTITY_PATH. A path that is absolute, starts with ~ or an environment reference, or has a .. segment is a WSP124 finding.",
+                    "propertyNames": {
+                        "type": "string",
+                        "pattern": "^[A-Za-z_][A-Za-z0-9_-]{0,63}$"
+                    },
+                    "additionalProperties": {
+                        "type": "string",
+                        "minLength": 1
+                    }
+                },
+                "cookies": {
+                    "type": "array",
+                    "description": "Session cookie names the box's runtimes set, such as hud_session (#2727). A browser scopes a cookie to a host, not a port, so each resolves to <cookie>_<member name>.",
+                    "uniqueItems": true,
+                    "items": {
+                        "type": "string",
+                        "pattern": "^[A-Za-z][A-Za-z0-9_-]{0,63}$"
+                    }
+                }
+            },
+            "dependentRequired": {
+                "host": [
+                    "slot"
+                ],
+                "slot": [
+                    "host"
+                ],
+                "ports": [
+                    "host"
+                ],
+                "state": [
+                    "host"
+                ],
+                "cookies": [
+                    "host"
+                ]
+            },
+            "patternProperties": {
+                "^x-": true
+            },
+            "additionalProperties": false
+        },
+        "capability": {
+            "type": "object",
+            "description": "A capability a box needs and does not hold the credential for, such as inference, fountain or a third-party API (#2726).",
+            "required": [
+                "name"
+            ],
+            "properties": {
+                "name": {
+                    "$ref": "#/$defs/kindName",
+                    "description": "The capability, such as inference or fountain. Unique within the box."
+                },
+                "broker": {
+                    "type": "string",
+                    "minLength": 1,
+                    "description": "What brokers the capability: the runtime that holds the credential and swaps the box's own token for it, such as lobby or door. It may name a member of this workspace, or a runtime outside it. Without it the capability is unbrokered, and chant workspace check fails with WSP122."
+                },
+                "scope": {
+                    "type": "array",
+                    "uniqueItems": true,
+                    "description": "What of the box's own the broker lets it reach, which the broker enforces. For Fountain: agent (start conversations with its own agent), vault (attach its own vault), conversations and sandboxes (its own). The words are the broker's; chant records them.",
+                    "items": {
+                        "type": "string",
+                        "minLength": 1,
+                        "pattern": "^[^\\u0000-\\u001f]+$"
+                    }
+                }
+            },
+            "patternProperties": {
+                "^x-": true
+            },
+            "additionalProperties": false
+        },
         "recordKind": {
             "type": "object",
             "description": "A record kind the workspace declares (#2680): a kind file that exports recordKind. chant workspace check fails (WSP115) when the file is missing or does not load as a record kind.",
@@ -469,6 +587,60 @@
                     "additionalProperties": false
                 }
             ]
+        },
+        "host": {
+            "type": "object",
+            "description": "A host boxes run on (#2727).",
+            "required": [
+                "name",
+                "ports"
+            ],
+            "properties": {
+                "name": {
+                    "$ref": "#/$defs/name",
+                    "description": "The host's name, unique among hosts. A box block names it in host."
+                },
+                "ports": {
+                    "type": "object",
+                    "description": "The TCP ports boxes on this host take theirs from. Slot n owns the block from + n * perBox to from + (n + 1) * perBox - 1, which must end at or before to.",
+                    "required": [
+                        "from",
+                        "to",
+                        "perBox"
+                    ],
+                    "properties": {
+                        "from": {
+                            "$ref": "#/$defs/port",
+                            "description": "The first port of the range."
+                        },
+                        "to": {
+                            "$ref": "#/$defs/port",
+                            "description": "The last port of the range, inclusive."
+                        },
+                        "perBox": {
+                            "type": "integer",
+                            "minimum": 1,
+                            "maximum": 65535,
+                            "description": "How many ports each box's block holds. A box's port offsets are below it."
+                        }
+                    },
+                    "additionalProperties": false
+                },
+                "stateRoot": {
+                    "type": "string",
+                    "minLength": 1,
+                    "description": "Where boxes on this host keep state, as an environment reference such as ${XDG_STATE_HOME}/chant/boxes, which the runtime expands on the machine. A box's state directory is <stateRoot>/<member name>. A literal machine path, such as /Users/... or anything under $HOME, is a WSP124 finding. Default ${XDG_STATE_HOME}/chant/boxes."
+                }
+            },
+            "patternProperties": {
+                "^x-": true
+            },
+            "additionalProperties": false
+        },
+        "port": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 65535
         }
     }
 }

package/dist/workspace/declared-kinds.d.ts

@@ -28,6 +28,18 @@ export interface DeclaredKind {
         code: DeclaredKindReasonCode;
         message: string;
     } | null;
+    /**
+     * For an answer kind (ws-058, #2738): its points file from the workspace
+     * root, and what is wrong with it, empty when nothing is. Absent for any
+     * other kind, and when the kind wasn't loaded.
+     */
+    points?: {
+        file: string;
+        problems: {
+            field: string | null;
+            message: string;
+        }[];
+    };
 }
 /** The kind file of `declared` on disk, under the workspace root `rootOnDisk`. */
 export declare function declaredKindFile(declared: RecordKindDeclaration, rootOnDisk: string): string;

package/dist/workspace/declared-kinds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"declared-kinds.d.ts","sourceRoot":"","sources":["../../src/workspace/declared-kinds.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAuB,KAAK,WAAW,EAAE,KAAK,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAElG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C,oHAAoH;AACpH,eAAO,MAAM,0BAA0B,yFAA0H,CAAC;AAClK,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjF,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,qBAAqB,CAAC;IAChC,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,wEAAwE;IACxE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,uCAAuC;IACvC,MAAM,EAAE;QAAE,IAAI,EAAE,sBAAsB,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CAClE;AAED,kFAAkF;AAClF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,qBAAqB,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAE5F;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,aAAa,EACnB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GAC/B,OAAO,CAAC,YAAY,EAAE,CAAC,CAyBzB"}
+{"version":3,"file":"declared-kinds.d.ts","sourceRoot":"","sources":["../../src/workspace/declared-kinds.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAuB,KAAK,WAAW,EAAE,KAAK,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAElG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C,oHAAoH;AACpH,eAAO,MAAM,0BAA0B,yFAA0H,CAAC;AAClK,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjF,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,qBAAqB,CAAC;IAChC,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,wEAAwE;IACxE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,uCAAuC;IACvC,MAAM,EAAE;QAAE,IAAI,EAAE,sBAAsB,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACjE;;;;OAIG;IACH,MAAM,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE;YAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAE,EAAE,CAAA;KAAE,CAAC;CAClF;AAED,kFAAkF;AAClF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,qBAAqB,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAE5F;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,aAAa,EACnB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GAC/B,OAAO,CAAC,YAAY,EAAE,CAAC,CA2BzB"}

package/dist/workspace/points-cli.d.ts

@@ -0,0 +1,113 @@
+/**
+ * `chant workspace points [--open] [--kind <kind file>] [--at <rev>] [--json]`
+ * (ws-058, #2739): the workspace's decision points and the questions asked of
+ * them, a read-contract output (`points.schema.json`).
+ *
+ * The points come from each record kind the declaration names with an
+ * `answers` block, or from `--kind`, and the questions are that kind's
+ * records. A question is open while it is escalated to people or proposed by a
+ * model and not yet confirmed, and it lists any model's answer with its
+ * confidence, so a reader such as hud can prompt a person and an MCP client
+ * can see it. With `--open`, only open questions are listed. It never writes
+ * and never calls a model.
+ *
+ * `points ask` and `points answer` are the writes, in `decide.ts`.
+ */
+import type { CommandContext } from "../cli/registry.js";
+import { type ErrorLocation, type WorkspaceErrorCode } from "./declaration.js";
+import { type QuestionView } from "./decide.js";
+import { type Decider, type ModelAsk } from "./points.js";
+export declare const POINTS_CONTRACT_VERSION = 1;
+export declare const POINTS_OUTPUT_SCHEMA_ID = "https://intentius.io/chant/schemas/workspace/points/v1/points.schema.json";
+/** Why `points` read nothing. Closed. */
+export declare const POINTS_ERROR_CODES: readonly ["declaration-missing", "declaration-ambiguous", "declaration-unparseable", "declaration-invalid", "placement-invalid", "reader-too-old", "root-chant-required", "not-a-git-repository", "revision-unknown"];
+/** Why one answer kind's points or questions could not be read. The document is still printed. Closed. */
+export declare const POINTS_SOURCE_REASON_CODES: readonly ["kind-unreadable", "kind-invalid", "schema-unreadable", "schema-id-mismatch", "schema-invalid", "location-missing", "points-invalid"];
+type SourceReasonCode = (typeof POINTS_SOURCE_REASON_CODES)[number];
+/** One point as `points` lists it. */
+export interface PointView {
+    name: string;
+    title: string;
+    /** The answer kind file, from the workspace root, whose records answer it. */
+    kind: string;
+    /** The points file, from the repository root. */
+    file: string;
+    /** sha256 of the declaration: a question asked under another version answers an older question. */
+    version: string;
+    questionType: string;
+    instructions: string;
+    candidates: (string | boolean)[];
+    /** Each input: its name, the read-contract output it names, and its description. */
+    inputs: {
+        name: string;
+        output: string;
+        description: string;
+    }[];
+    deciders: Decider[];
+    quorum: {
+        count: number;
+        roles?: string[];
+    };
+}
+/** One answer kind the read covered. */
+export interface SourceView {
+    /** The kind file, as declared from the workspace root, or as given with --kind. */
+    kind: string;
+    /** The points file from the repository root, or null when the kind couldn't be loaded. */
+    points: string | null;
+    reason: {
+        code: SourceReasonCode;
+        message: string;
+    } | null;
+}
+export type PointsDocument = {
+    $schema: string;
+    contract: number;
+    chant: string;
+    at: string | null;
+    workspace: {
+        name: string;
+        root: string;
+    };
+    /** Whether only open questions are listed (--open). */
+    open: boolean;
+    sources: SourceView[];
+    points: PointView[];
+    questions: QuestionView[];
+    summary: {
+        points: number;
+        questions: number;
+        open: number;
+        escalated: number;
+        proposed: number;
+        answered: number;
+    };
+} | {
+    $schema: string;
+    contract: number;
+    chant: string;
+    error: {
+        code: WorkspaceErrorCode;
+        message: string;
+        location: ErrorLocation | null;
+    };
+};
+export interface PointsQuery {
+    cwd: string;
+    at?: string;
+    open?: boolean;
+    /** One answer kind file, in place of the declared ones. */
+    kind?: string;
+}
+/** Read the points and questions. Never throws a read error: a declaration that can't be read is the failure document. */
+export declare function workspacePoints(query: PointsQuery): Promise<PointsDocument>;
+/** The document as lines for a person. */
+export declare function formatPoints(doc: Extract<PointsDocument, {
+    points: unknown;
+}>): string;
+/** A POST /v1/systemone response the caller already has, as the model call: its answer to the point asked. */
+export declare function responseAsk(response: unknown): ModelAsk;
+/** `chant workspace points`, and its `ask` and `answer` verbs. */
+export declare function runWorkspacePoints(ctx: CommandContext): Promise<number>;
+export {};
+//# sourceMappingURL=points-cli.d.ts.map

package/dist/workspace/points-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"points-cli.d.ts","sourceRoot":"","sources":["../../src/workspace/points-cli.ts"],"names":[],"mappings":"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"}

package/dist/workspace/points.d.ts

@@ -0,0 +1,320 @@
+/**
+ * Decision points (ws-058, #2738): the recurring questions a workspace asks of
+ * its own graph, declared as data, and the answers they leave (#2739).
+ *
+ * A points file is JSON, validated against `decision-points.schema.json`, and
+ * named by a record kind's `answers.points`: the kind whose records are the
+ * answers. Each point is a typed question (`noul`, `choice` or `score`, the
+ * question types of the POST /v1/systemone wire format, #2491), the inputs it
+ * reads, each named as a read-contract output, and an ordered chain of
+ * deciders:
+ *
+ *   table   rows of { when, answer }; the first row whose conditions all hold answers.
+ *   model   a backend asked the question with the inputs as its state, at a
+ *           pinned model id. An answer at or above the threshold is a
+ *           proposal a person confirms; below it, the next decider is asked.
+ *   quorum  people. Always last: the question escalates to them.
+ *
+ * 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
+ * not asked and the chain moves on.
+ *
+ * Taken from chud's `packages/runtime/src/decide.mjs` at 43afcf1: the chain,
+ * the observation rule, the point version and the inputs hash. The records
+ * are chant records: `decide.ts` writes them, and {@link applyAnswers} warns
+ * about them on read.
+ */
+import type { RecordSource } from "./record-source.js";
+import type { LoadedRecordKind, ReadRecordsOptions, RecordEntry } from "./records.js";
+export declare const DECISION_POINTS_SCHEMA_ID: string;
+/**
+ * The read-contract outputs a point's input may name (#2738), each with the
+ * output schema and `$defs` entry that describes it. Closed: an input naming
+ * anything else is refused. `record`, `decision` and `work-item` are records
+ * as `records --json` lists them, of any kind, a decision kind and a work kind.
+ */
+export declare const POINT_INPUT_OUTPUTS: {
+    readonly record: {
+        readonly schema: "records";
+        readonly def: "record";
+        readonly description: "a record of any kind, as records --json lists it";
+    };
+    readonly decision: {
+        readonly schema: "records";
+        readonly def: "record";
+        readonly description: "a decision record, as records --json lists it";
+    };
+    readonly "work-item": {
+        readonly schema: "records";
+        readonly def: "record";
+        readonly description: "a work item record, as records --json lists it (#2683)";
+    };
+    readonly finding: {
+        readonly schema: "intent";
+        readonly def: "finding";
+        readonly description: "a finding of graph --intent";
+    };
+    readonly region: {
+        readonly schema: "intent";
+        readonly def: "region";
+        readonly description: "the region an intent graph covers";
+    };
+    readonly commit: {
+        readonly schema: "intent";
+        readonly def: "commit";
+        readonly description: "a commit in an intent graph's window";
+    };
+    readonly member: {
+        readonly schema: "ls";
+        readonly def: "member";
+        readonly description: "a member, as ls lists it";
+    };
+    readonly gate: {
+        readonly schema: "status";
+        readonly def: "gate";
+        readonly description: "a gate, as status lists it";
+    };
+    readonly release: {
+        readonly schema: "status";
+        readonly def: "release";
+        readonly description: "a release, as status lists it; a release plan's fields until the lifecycle ledger lists plans (#2717)";
+    };
+    readonly environment: {
+        readonly schema: "status";
+        readonly def: "environment";
+        readonly description: "an environment, as status lists it";
+    };
+    readonly component: {
+        readonly schema: "composites";
+        readonly def: "component";
+        readonly description: "a component, as graph --composites lists it";
+    };
+};
+export type PointInputOutput = keyof typeof POINT_INPUT_OUTPUTS;
+export declare const POINT_INPUT_OUTPUT_NAMES: PointInputOutput[];
+/** The output an input name reads: the part before its first dot. */
+export declare function inputOutput(name: string): string;
+export type QuestionType = "noul" | "choice" | "score";
+export interface Question {
+    /** `boolean` in a points file is read as `noul`. */
+    type: QuestionType;
+    instructions: string;
+    criteria: Record<string, string> | string[];
+}
+export type Scalar = string | number | boolean | null;
+export type Condition = Scalar | {
+    eq?: Scalar;
+    ne?: Scalar;
+    lt?: number;
+    lte?: number;
+    gt?: number;
+    gte?: number;
+    in?: Scalar[];
+};
+export interface TableRow {
+    when: Record<string, Condition>;
+    answer: string | boolean;
+    note?: string;
+}
+export type Decider = {
+    kind: "table";
+    rows: TableRow[];
+    note?: string;
+} | {
+    kind: "model";
+    backend: string;
+    model: string;
+    threshold: number;
+    unreachable?: "escalate" | "fail";
+    note?: string;
+} | {
+    kind: "quorum";
+    count: number;
+    roles?: string[];
+    note?: string;
+};
+export interface Point {
+    title: string;
+    question: Question;
+    inputs: Record<string, string>;
+    deciders: Decider[];
+}
+/** One problem with a points file: the JSON path of the field, or null for the file, and what is wrong. */
+export interface PointProblem {
+    field: string | null;
+    message: string;
+}
+export declare class PointsError extends Error {
+    readonly file: string;
+    readonly problems: PointProblem[];
+    constructor(file: string, problems: PointProblem[]);
+}
+/** A question's candidate answers: true and false, a choice's options, or a score's levels. */
+export declare function candidates(question: Question): (string | boolean)[];
+/** The schema's problems with `data`, as JSON paths. */
+export declare function schemaProblems(data: unknown): PointProblem[];
+/**
+ * Parse and validate a points file's text. Returns its points, with
+ * `boolean` read as `noul`. Throws a {@link PointsError} naming the file and
+ * each field.
+ */
+export declare function parsePoints(text: string, file: string): Record<string, Point>;
+/** One point by name, or undefined. */
+export declare function pointOf(points: Record<string, Point>, name: string): Point | undefined;
+/** JSON with keys sorted and undefined members left out, the text every hash here is taken over. */
+export declare function canonical(value: unknown): string;
+/** The version of a point: the sha256 of its declaration. Editing the question or any decider changes it. */
+export declare const pointVersion: (point: Point) => string;
+/** What is answered once: the point, its version and the inputs. */
+export declare const inputsHash: (name: string, version: string, inputs: Record<string, unknown>) => string;
+/** The id of the answer to `name` for inputs hashing to `hash`: the name and the hash's first 12 hex digits. */
+export declare const answerId: (name: string, hash: string) => string;
+/** The quorum a point ends in. */
+export declare function quorumOf(point: Point): {
+    count: number;
+    roles?: string[];
+};
+/** Whether every condition in a row's `when` holds for these inputs. An input the state lacks never matches. */
+export declare const matches: (when: Record<string, Condition>, inputs: Record<string, unknown>) => boolean;
+/** A question as the POST /v1/systemone wire format asks it (#2491). */
+export interface WireQuestion {
+    type: QuestionType;
+    instructions: string;
+    criteria: Record<string, string> | string[];
+}
+/** One answer in the wire format's shape. */
+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: "unsupported";
+};
+export declare function wireQuestion(question: Question): WireQuestion;
+/** What a model decider is asked. */
+export interface ModelRequest {
+    point: string;
+    backend: string;
+    /** The pinned model id. */
+    model: string;
+    question: WireQuestion;
+    /** The inputs, as the state. */
+    state: Record<string, unknown>;
+}
+/**
+ * The model call, supplied by the caller: the decide Op activity (#2740), a
+ * runtime's decider, or a test's stub. It resolves with the model id that
+ * answered and one answer in the wire format's shape. Throwing means the
+ * backend could not be reached or gave nothing usable.
+ */
+export type ModelAsk = (request: ModelRequest) => Promise<{
+    model: string;
+    answer: WireAnswer;
+}>;
+export type Observation = {
+    observed: true;
+    answer: string | boolean;
+    probabilities: Record<string, number>;
+    confidence: number;
+} | {
+    observed: false;
+    answer?: string | boolean | null;
+    probabilities?: Record<string, number>;
+    confidence?: number;
+    reason: string;
+};
+/**
+ * A model's wire answer against the question and the decider's threshold
+ * (chud's rule):
+ *
+ * - noul p: true when p is at least the threshold, false when 1 - p is,
+ *   otherwise not observed. Its confidence is max(p, 1 - p).
+ * - choice and score: the choice (a score's most probable level) when the
+ *   reported confidence is at least the threshold. A backend that reports no
+ *   confidence is read by its largest probability.
+ *
+ * An answer outside the candidates, or an unsupported question, is not observed.
+ */
+export declare function observe(question: Question, answer: WireAnswer | undefined, threshold: number): Observation;
+/** A decider that was asked and did not answer, and why. */
+export interface Escalation {
+    kind: "table" | "model";
+    reason: string;
+    backend?: string;
+    model?: string;
+    answer?: string | boolean | null;
+    probabilities?: Record<string, number>;
+    confidence?: number;
+    threshold?: number;
+}
+export type ChainResult = {
+    status: "answered";
+    answer: string | boolean;
+    decider: {
+        kind: "table";
+        row: number;
+    };
+    note?: string;
+    escalations: Escalation[];
+} | {
+    status: "proposed";
+    answer: string | boolean;
+    decider: {
+        kind: "model";
+        backend: string;
+        model: string;
+    };
+    probabilities: Record<string, number>;
+    confidence: number;
+    threshold: number;
+    escalations: Escalation[];
+} | {
+    status: "escalated";
+    decider: {
+        kind: "quorum";
+        count: number;
+        roles?: string[];
+    };
+    escalations: Escalation[];
+};
+/** A model decider declared `unreachable: "fail"` could not answer, so the ask fails and nothing is written. */
+export declare class DeciderFailed extends Error {
+    constructor(message: string);
+}
+/**
+ * Ask a point's deciders in order. A table row answers; a model at or above
+ * its threshold proposes; otherwise the question escalates to the quorum.
+ * Each decider that did not answer is in `escalations`, with why. A model
+ * decider is asked through `ask`; without it, it is not asked.
+ */
+export declare function runChain(name: string, point: Point, inputs: Record<string, unknown>, ask?: ModelAsk): Promise<ChainResult>;
+/** Why an answer record carries a warning. Closed, like the record warning codes. */
+export declare const ANSWER_WARNING_CODES: readonly ["answer-points-unreadable", "answer-point-unknown", "answer-point-changed"];
+export type AnswerWarningCode = (typeof ANSWER_WARNING_CODES)[number];
+/** The points file an answer kind names, from `root` with / separators. */
+export declare function pointsFileOf(loaded: LoadedRecordKind, root: string): string;
+/** The points an answer kind names, read from `source` (the tree read), or the problems reading them. */
+export declare function readPointsThrough(source: RecordSource, file: string): {
+    points: Record<string, Point>;
+} | {
+    error: string;
+    problems: PointProblem[];
+};
+/**
+ * Give an answer kind's records their warnings, in place: the points file
+ * can't be read, the answer's point is gone, or the point changed since. They
+ * never make a record invalid.
+ */
+export declare function applyAnswers(loaded: LoadedRecordKind, entries: RecordEntry[], options: ReadRecordsOptions): void;
+//# sourceMappingURL=points.d.ts.map