@intentius/chant 0.90.0 → 0.93.0

package/dist/op/work-lease-run.d.ts.map

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

package/dist/workspace/__fixtures__/decide-workspace.d.ts

@@ -0,0 +1,100 @@
+/**
+ * A throwaway workspace for the decide tests: a git repository with an answer
+ * kind (the reference workspace's), a task kind the points read through the
+ * read contract, three points (a noul, a choice and a score), and a box member
+ * that declares one brokered capability and one without a broker.
+ */
+/** The chant checkout the tests run in. */
+export declare const REPO: string;
+export declare const MODEL = "jev-1.13.0";
+export declare const POINTS: {
+    points: {
+        triage: {
+            title: string;
+            question: {
+                type: string;
+                instructions: string;
+                criteria: {
+                    true: string;
+                    false: string;
+                };
+            };
+            inputs: {
+                "record.size": string;
+                "record.risky": string;
+            };
+            deciders: ({
+                kind: string;
+                backend: string;
+                model: string;
+                threshold: number;
+            } | {
+                kind: string;
+                rows: {
+                    when: {
+                        "record.size": number;
+                    };
+                    answer: boolean;
+                }[];
+                count?: undefined;
+            } | {
+                kind: string;
+                count: number;
+                rows?: undefined;
+            })[];
+        };
+        route: {
+            title: string;
+            question: {
+                type: string;
+                instructions: string;
+                criteria: {
+                    platform: string;
+                    app: string;
+                    docs: string;
+                };
+            };
+            inputs: {
+                "record.title": string;
+                "record.size": string;
+            };
+            deciders: ({
+                kind: string;
+                backend: string;
+                model: string;
+                threshold: number;
+            } | {
+                kind: string;
+                count: number;
+            })[];
+        };
+        effort: {
+            title: string;
+            question: {
+                type: string;
+                instructions: string;
+                criteria: string[];
+            };
+            inputs: {
+                "record.size": string;
+                "member.kind": string;
+            };
+            deciders: ({
+                kind: string;
+                backend: string;
+                model: string;
+                threshold: number;
+            } | {
+                kind: string;
+                count: number;
+            })[];
+        };
+    };
+};
+export declare function cleanScratch(): void;
+export declare function git(cwd: string, ...args: string[]): string;
+/** Make the workspace and commit it. Returns its root. */
+export declare function workspace(points?: unknown): string;
+/** The front matter text of a written record. */
+export declare const recordText: (root: string, path: string) => string;
+//# sourceMappingURL=decide-workspace.d.ts.map

package/dist/workspace/__fixtures__/decide-workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decide-workspace.d.ts","sourceRoot":"","sources":["../../../src/workspace/__fixtures__/decide-workspace.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,2CAA2C;AAC3C,eAAO,MAAM,IAAI,QAAwE,CAAC;AAG1F,eAAO,MAAM,KAAK,eAAe,CAAC;AAIlC,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqBlB,CAAC;AAkCF,wBAAgB,YAAY,IAAI,IAAI,CAEnC;AAED,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAE1D;AAED,0DAA0D;AAC1D,wBAAgB,SAAS,CAAC,MAAM,GAAE,OAAgB,GAAG,MAAM,CAyC1D;AAED,iDAAiD;AACjD,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,EAAE,MAAM,MAAM,KAAG,MAAiD,CAAC"}

package/dist/workspace/answers-ledger.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Answer records held on the lifecycle ledger (#2786).
+ *
+ * A steward's writes never touch the checkout's index or working tree
+ * (`../op/steward.ts`): the working tree is the coding agent's. A decision
+ * point asked in a steward's turn still has to leave its question somewhere a
+ * person finds it after the turn ends, and an Op's leased worktree is removed
+ * with the run. So a question asked in a steward's turn is written to
+ * `chant/lifecycle`, beside the lease histories and run records, under
+ * `_answers/<kind name>/<id>.md` in the ledger of the member that owns the
+ * answer kind. The file is the same Markdown record the kind's directory
+ * would hold, and it is written with git plumbing, like every ledger write.
+ *
+ * Readers see the ledger's answers as if they sat in the kind's directory:
+ * {@link withLedgerAnswers} lays them over the working tree, so `points`,
+ * `points --open`, a later `points ask` of the same question and `points
+ * answer` all find them. A record on the ledger wins over a file of the same
+ * name in the tree, because the ledger copy is the one a steward rewrote.
+ * People's answer to a question held on the ledger is written back there, so
+ * answering through hud in a box does not touch the checkout either.
+ *
+ * `points --at <rev>` reads a revision of the working branch, which the
+ * ledger is not part of, so it lists the tree's records only.
+ */
+import type { RecordSource } from "./record-source.js";
+/** The directory on `chant/lifecycle`, under the member's prefix, that holds answer records. */
+export declare const ANSWERS_LEDGER_DIR = "_answers";
+/** One answer record on the ledger. */
+export interface LedgerAnswer {
+    /** Where the record reads as being: the kind's directory, from the repository root. */
+    path: string;
+    /** Where it is: `chant/lifecycle:<path on the branch>`, which `git show` reads. */
+    ledger: string;
+    text: string;
+    /** Its blob sha, for a compare-and-set rewrite. */
+    sha: string;
+}
+/** The answer records one kind holds on the ledger. */
+export interface LedgerAnswers {
+    /** Where the ledger is resolved from: the kind file's directory, so the member owning the kind owns its answers. */
+    cwd: string;
+    /** The directory on the branch, relative to the member's prefix. */
+    dir: string;
+    /** The kind's records directory, from the repository root. */
+    dirRel: string;
+    /** By the path each record reads as. */
+    byPath: Map<string, LedgerAnswer>;
+}
+/** The ledger directory of the kind named `kindName`. */
+export declare function answersLedgerDir(kindName: string): string;
+/**
+ * Read the answer records the kind at `kindFile` holds on the ledger. Empty
+ * when there are none, when there is no ledger branch, and outside a git
+ * repository.
+ */
+export declare function readLedgerAnswers(kind: {
+    file: string;
+    name: string;
+    dirRel: string;
+}): Promise<LedgerAnswers>;
+/** `base` with each ledger answer at the path it reads as, over any file of the same name. */
+export declare function withLedgerAnswers(base: RecordSource, answers: LedgerAnswers): RecordSource;
+/** Fetch `chant/lifecycle` before a ledger write when it fast-forwards, so a question another clone asked is found. Best effort. */
+export declare function refreshLedger(kindFile: string): Promise<void>;
+/**
+ * Write the record read as `path` to the ledger, expecting the blob it had
+ * when it was read (`prior`, null for a new record), then push the branch.
+ * A changed blob throws `RefCASConflictError` from `../lifecycle/git`. The
+ * push is best effort: a question that did not reach the remote is still
+ * open here. Returns where the record went.
+ */
+export declare function writeLedgerAnswer(answers: LedgerAnswers, path: string, text: string, message: string, prior: string | null): Promise<{
+    ledger: string;
+    pushed: boolean;
+}>;
+//# sourceMappingURL=answers-ledger.d.ts.map

package/dist/workspace/answers-ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"answers-ledger.d.ts","sourceRoot":"","sources":["../../src/workspace/answers-ledger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGpD,gGAAgG;AAChG,eAAO,MAAM,kBAAkB,aAAa,CAAC;AAI7C,uCAAuC;AACvC,MAAM,WAAW,YAAY;IAC3B,uFAAuF;IACvF,IAAI,EAAE,MAAM,CAAC;IACb,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,GAAG,EAAE,MAAM,CAAC;CACb;AAED,uDAAuD;AACvD,MAAM,WAAW,aAAa;IAC5B,oHAAoH;IACpH,GAAG,EAAE,MAAM,CAAC;IACZ,oEAAoE;IACpE,GAAG,EAAE,MAAM,CAAC;IACZ,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAC;IACf,wCAAwC;IACxC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CACnC;AAED,yDAAyD;AACzD,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEzD;AAMD;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAmBpH;AAED,8FAA8F;AAC9F,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,aAAa,GAAG,YAAY,CAI1F;AAED,oIAAoI;AACpI,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEnE;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAAC,CAK/K"}

package/dist/workspace/box-isolation.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Box isolation (#2727): the ports, state paths and cookie names each box
+ * uses, derived from its identity and its host, never chosen by a runtime.
+ *
+ * A box is a member with a `box` block (#2726), and its name is the
+ * member's. A box's identity is its host, its name and its slot, from the
+ * block's `host` and `slot`. Everything else
+ * follows from those and the host's declaration, and nothing else goes in:
+ *
+ * - port `p` is `host.ports.from + slot * host.ports.perBox + offset(p)`;
+ * - the state directory is `<host.stateRoot>/<box name>`, and state entry
+ *   `k` is that directory joined with the entry's relative path;
+ * - cookie `c` is `<c>_<box name>`.
+ *
+ * So the same declaration gives the same values on every machine and every
+ * run, and adding or removing a box changes no other box's values. The state
+ * paths keep their environment reference (`${XDG_STATE_HOME}` by default):
+ * the runtime that sets them expands it on its machine, and chant never
+ * reads the machine.
+ *
+ * Distinct names on one host give distinct state paths and cookie names by
+ * construction (a member name has no `_`, so `<c>_<box>` splits one way).
+ * Ports are the only value two boxes can share: two boxes on one host with
+ * the same slot, or two ports in one box at the same offset. `chant
+ * workspace check` compares every value anyway (WSP123), so an entry whose
+ * path escapes its directory is caught too.
+ */
+import { type BoxIsolationDeclaration, type Declaration, type Host, type Member } from "./declaration.js";
+/** A box's isolation, resolved: what `chant workspace status --json` prints in the member's box block. */
+export interface ResolvedIsolation {
+    host: string;
+    slot: number;
+    /** The box's block of its host's range, inclusive. */
+    portRange: {
+        from: number;
+        to: number;
+    };
+    /** Each declared port's number, in file order. */
+    ports: Record<string, number>;
+    /** `<stateRoot>/<box name>`, with the environment reference unexpanded. */
+    stateDir: string;
+    /** Each declared state entry's path, under `stateDir`. */
+    state: Record<string, string>;
+    /** Each declared cookie's name for this box. */
+    cookies: Record<string, string>;
+}
+/** The host's state root as written, or the default. */
+export declare function stateRootOf(host: Host): string;
+/** Resolve the isolation of the box named `name` on its host. */
+export declare function resolveIsolation(name: string, box: BoxIsolationDeclaration, host: Host): ResolvedIsolation;
+/** A member whose box block declares its isolation, with it resolved. */
+export interface IsolatedBox {
+    member: Member;
+    isolation: ResolvedIsolation;
+}
+/** Every box that declares its isolation, resolved, in member order. The declaration read already checked each box's host exists. */
+export declare function resolveBoxes(declaration: Declaration): IsolatedBox[];
+/**
+ * Why a host's `stateRoot` is a literal machine path, or undefined when it is
+ * not. A state root starts with an environment reference the runtime expands,
+ * and that reference is not `$HOME`: a path under a home directory names one
+ * person's machine layout (`${HOME}/<user>/...`), where `${XDG_STATE_HOME}`
+ * names the place the machine keeps state.
+ */
+export declare function stateRootLiteral(root: string): string | undefined;
+/**
+ * Why a state entry's path is not one relative to the box's state directory,
+ * or undefined when it is: absolute, home-relative, starting with an
+ * environment reference, a Windows drive path, or with a `..` segment.
+ */
+export declare function statePathLiteral(path: string): string | undefined;
+export interface BoxLiteral {
+    /** The box, or null for a host's state root. */
+    box: string | null;
+    message: string;
+    pointer: string;
+}
+/** Every literal machine path in the hosts and boxes. */
+export declare function boxLiterals(declaration: Declaration): BoxLiteral[];
+export interface BoxCollision {
+    host: string;
+    what: "port" | "state" | "cookie";
+    /** The shared value. */
+    value: string;
+    /** Each holder as `<box>.<name>`, in declaration order. */
+    holders: {
+        box: string;
+        name: string;
+        pointer: string;
+    }[];
+}
+/**
+ * Every value two holders on one host resolve to. Ports collide within a box
+ * too, since two listeners can't share a port; state entries in one box may
+ * name one file on purpose (a runtime and the door both reading hud's
+ * identity), and cookies are unique in a box by the schema.
+ */
+export declare function boxCollisions(declaration: Declaration): BoxCollision[];
+//# sourceMappingURL=box-isolation.d.ts.map

package/dist/workspace/box-isolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"box-isolation.d.ts","sourceRoot":"","sources":["../../src/workspace/box-isolation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAsB,KAAK,uBAAuB,EAAE,KAAK,WAAW,EAAE,KAAK,IAAI,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAG3H,0GAA0G;AAC1G,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,SAAS,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,2EAA2E;IAC3E,QAAQ,EAAE,MAAM,CAAC;IACjB,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED,wDAAwD;AACxD,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE9C;AAID,iEAAiE;AACjE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,uBAAuB,EAAE,IAAI,EAAE,IAAI,GAAG,iBAAiB,CAY1G;AAED,yEAAyE;AACzE,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,iBAAiB,CAAC;CAC9B;AAED,qIAAqI;AACrI,wBAAgB,YAAY,CAAC,WAAW,EAAE,WAAW,GAAG,WAAW,EAAE,CAQpE;AAOD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKjE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOjE;AAED,MAAM,WAAW,UAAU;IACzB,gDAAgD;IAChD,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,yDAAyD;AACzD,wBAAgB,WAAW,CAAC,WAAW,EAAE,WAAW,GAAG,UAAU,EAAE,CAoBlE;AAID,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;IAClC,wBAAwB;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC3D;AAaD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,WAAW,GAAG,YAAY,EAAE,CA2BtE"}

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

@@ -0,0 +1,16 @@
+/**
+ * `chant workspace check --changes <base>..<head> [--work <id>] [--severity
+ * off|warn|fail] [--kind <kind file>...] [--json]` (#2773): the forward
+ * coverage check (`changes.ts`), printed as JSON with `--json` or as one line
+ * per changed path, then the findings.
+ */
+import type { CommandContext } from "../cli/registry.js";
+import { type ChangesDocument } from "./changes.js";
+type Result = Exclude<ChangesDocument, {
+    error: unknown;
+}>;
+/** One line per changed path, then the findings and a summary. */
+export declare function formatChanges(doc: Result): string;
+export declare function runWorkspaceChanges(ctx: CommandContext, cwd: string): Promise<number>;
+export {};
+//# sourceMappingURL=changes-cli.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"changes-cli.d.ts","sourceRoot":"","sources":["../../src/workspace/changes-cli.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAmC,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AAKlF,KAAK,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC;AAE3D,kEAAkE;AAClE,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAmBjD;AAED,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAgB3F"}

package/dist/workspace/changes.d.ts

@@ -0,0 +1,200 @@
+/**
+ * The forward coverage check: `chant workspace check --changes
+ * <base>..<head>` (#2773).
+ *
+ * `graph --intent` reads the join between records and code backwards, from a
+ * region to the decisions and work items whose `constrains` cover it. This
+ * reads it forwards. Each path a diff changes is mapped to the current
+ * records whose `constrains` cover it, and two gaps are findings with closed
+ * codes:
+ *
+ * - `change-uncovered`: no current decided record and no open work item
+ *   covers the path, by a `path:` entry that is the path or a directory
+ *   above it, or by the `member:` of the member holding it.
+ * - `change-out-of-scope`: a record in hand for the change lists the path in
+ *   its `out_of_scope` (the field its kind names in `outOfScope`). With
+ *   `--work <id>`, the records in hand are that work item and the decisions it
+ *   implements; without it, every current record that covers some path the
+ *   diff changes.
+ *
+ * A path the declaration's `changes.ignore` globs match is listed as
+ * `ignored`, and a record file of a kind read as `record`: a change to the
+ * records is the coverage itself. The declaration's `changes.severity` says
+ * what a finding does: `off` reports none, `warn` (the default) reports them
+ * and passes, `fail` reports them and fails. Nothing here runs unless the
+ * check is asked for, so a workspace that never asks pays nothing.
+ *
+ * Records are read at `<head>`, so a change that adds the work item covering
+ * it is covered. Each finding carries `triage`, the `{ finding, region }` a
+ * work item's `source` takes (`work.schema.json`'s `sourceGap`), so the
+ * finding-triage decision point (#2741) can seed a work item or a decision
+ * from it; see {@link changeFindingSource}. When a work kind is read, each
+ * finding also says whether a work item already addresses it, the way `graph
+ * --intent` says it for its own findings (#2683), and
+ * {@link changeFindingTriageInputs} turns a finding into that point's inputs
+ * (#2794). Git is read through a local `git` subprocess only: no fetch, no
+ * network.
+ */
+import { type ChangeSeverity } from "./declaration.js";
+/** The version of the `changes` document this chant writes. */
+export declare const CHANGES_CONTRACT_VERSION = 1;
+/** `$id` of the JSON Schema for the document, shipped beside this file. */
+export declare const CHANGES_OUTPUT_SCHEMA_ID = "https://intentius.io/chant/schemas/workspace/changes/v1/changes.schema.json";
+/** The finding codes. Closed: a reader may switch on them. */
+export declare const CHANGES_FINDING_CODES: readonly ["change-uncovered", "change-out-of-scope"];
+export type ChangesFindingCode = (typeof CHANGES_FINDING_CODES)[number];
+/** Why the check failed as a whole: the declaration's codes, the record kind's, or a `--work` item no record has. */
+export declare const CHANGES_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", "kind-unreadable", "kind-invalid", "schema-unreadable", "schema-id-mismatch", "schema-invalid", "location-missing", "work-item-unknown"];
+export type ChangesErrorCode = (typeof CHANGES_ERROR_CODES)[number];
+export declare const CHANGE_SEVERITIES: readonly ["off", "warn", "fail"];
+/** A record, as `<kind name>/<id>`, and the entry that ties it to the path. */
+export interface ChangeRecordRef {
+    record: string;
+    state: string | null;
+    /** The constrains or out_of_scope entry. */
+    entry: string;
+}
+export type ChangeStatus = "covered" | "uncovered" | "out-of-scope" | "ignored" | "record";
+export interface ChangedPath {
+    /** From the workspace root. */
+    path: string;
+    change: "added" | "modified" | "deleted" | "renamed";
+    /** For a rename, the path it had at base. */
+    from: string | null;
+    /** The member whose directory holds the path, or null. */
+    member: string | null;
+    /** Whether the path is a generated file, as `graph --intent` reads a region's `generated` (#2794). */
+    generated: boolean;
+    status: ChangeStatus;
+    /** The current records covering the path, with the entry that covers it. */
+    coveredBy: ChangeRecordRef[];
+    /** The records in hand that put the path out of scope. */
+    outOfScopeBy: ChangeRecordRef[];
+    /** For an ignored path, the first glob that matched it. */
+    ignoredBy: string | null;
+}
+export interface ChangeFinding {
+    /** `finding:<code>:<path>`: one finding per path. */
+    id: string;
+    code: ChangesFindingCode;
+    path: string;
+    message: string;
+    severity: "warn" | "fail";
+    /** The records the finding concerns, as `<kind name>/<id>`: for out-of-scope, the records that put the path out. */
+    records: string[];
+    /** What a work item's `source` takes to name this gap (#2741): `{ finding, region }`. */
+    triage: {
+        finding: ChangesFindingCode;
+        region: string;
+    };
+    /**
+     * Present when a work kind was read (#2794): whether a work item addresses
+     * the finding, because its `source.finding` is this code and its
+     * `source.region` is this path or a directory above it.
+     */
+    addressed?: boolean;
+    /** Present when a work kind was read: the work items addressing the finding, as `<kind name>/<id>`, each with its state. */
+    addressedBy?: {
+        record: string;
+        state: string | null;
+    }[];
+}
+/** The inputs of the finding-triage decision point (#2741), by the names `decisions/points.json` declares. */
+export type ChangeFindingTriageInputs = {
+    "finding.code": ChangesFindingCode;
+    "finding.message": string;
+    "finding.addressed": boolean;
+    "region.path": string;
+    "region.member": string | null;
+    "region.generated": boolean;
+};
+interface Head {
+    $schema: string;
+    contract: number;
+    chant: string;
+}
+export type ChangesDocument = (Head & {
+    workspace: {
+        name: string;
+        root: string;
+    };
+    range: {
+        spec: string;
+        base: string;
+        head: string;
+    };
+    severity: ChangeSeverity;
+    ignore: string[];
+    /** The work item in hand, from `--work`, or null. */
+    work: {
+        record: string;
+        state: string | null;
+    } | null;
+    kinds: {
+        file: string;
+        name: string;
+        role: "decision" | "work" | "other";
+    }[];
+    paths: ChangedPath[];
+    findings: ChangeFinding[];
+    summary: {
+        paths: number;
+        covered: number;
+        uncovered: number;
+        outOfScope: number;
+        ignored: number;
+        records: number;
+    };
+    /** False only when severity is fail and there are findings. */
+    ok: boolean;
+}) | (Head & {
+    error: {
+        code: ChangesErrorCode;
+        message: string;
+    };
+});
+export interface ChangesQuery {
+    /** Where the walk up to the declaration starts. */
+    cwd: string;
+    /** `<base>..<head>`, `<base>...<head>` (from their merge base), or `<base>` alone, to HEAD. */
+    range: string;
+    /** Kind files, relative to `cwd`. Left out, every record kind the declaration names. */
+    kinds?: string[];
+    /** The id of the work item in hand, such as the item an Op's work lease holds. */
+    work?: string;
+    /** In place of the declaration's `changes.severity`. */
+    severity?: ChangeSeverity;
+}
+export interface ChangesResult {
+    doc: ChangesDocument;
+    /** The read failed, or severity is fail and there are findings. */
+    failed: boolean;
+}
+/** The `source` a work item seeded from this finding carries (`work.schema.json`'s `sourceGap`): the seam for the finding-triage point (#2741). */
+export declare function changeFindingSource(finding: Pick<ChangeFinding, "code" | "path">): {
+    finding: ChangesFindingCode;
+    region: string;
+};
+/**
+ * The finding-triage point's inputs for a change finding and the entry in
+ * `paths` it fired on (#2794), for `askPoint` or the `decide` activity. The
+ * same names a caller fills from `graph --intent`'s finding and region nodes.
+ * The region is the changed file, so `region.generated` is never null. A
+ * document that read no work kind has no `addressed`, and it is passed as
+ * false: nothing that was read addresses the finding.
+ */
+export declare function changeFindingTriageInputs(finding: Pick<ChangeFinding, "code" | "message" | "path" | "addressed">, path: Pick<ChangedPath, "path" | "member" | "generated">): ChangeFindingTriageInputs;
+/** Run the check and build the document. Never throws a {@link WorkspaceReadError} or {@link RecordReadError}. */
+export declare function checkChanges(query: ChangesQuery): Promise<ChangesResult>;
+/**
+ * For a checkout on a work branch, `chant/work/[<member>/]<id>`, as an Op
+ * with `changesCheckout` works in (#2748): the range from where the branch
+ * left the main worktree's HEAD to its own HEAD, and the item's id. Undefined
+ * on any other branch.
+ */
+export declare function workBranchChanges(cwd: string): {
+    range: string;
+    work: string;
+} | undefined;
+export {};
+//# sourceMappingURL=changes.d.ts.map

package/dist/workspace/changes.d.ts.map

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

package/dist/workspace/chant-migrations/chud-lexicon-exit-fly-site.d.ts

@@ -0,0 +1,59 @@
+/**
+ * `chud-lexicon-exit-fly-site` (#2809): declare a migrated repo's Fly site
+ * with the fly lexicon's `FlySite` composite.
+ *
+ * `chud-lexicon-exit` (0.92.0) deleted deploy/site.ts, chud's `ChudLocalSite`
+ * composite, and removed chud's `FlySite` marker from deploy/fly.ts, so the
+ * repo declared no composite instance: `chant workspace graph --composites`
+ * listed none, and nothing told a reader the app component deploys the site.
+ * Per ws-056 the Fly resources stay on the fly lexicon. This migration:
+ *
+ * - rewrites deploy/fly.ts as one `FlySite` instance (`flySite`) with the
+ *   values deploy/fly.ts and deploy/fly-machine.ts declared, and deletes
+ *   deploy/fly-machine.ts, when the two declare exactly the template's
+ *   resources (comments aside). The build's plan has the same App, Volume,
+ *   IP, Secret and one Machine, which the release Op's `flyRelease` finds;
+ * - names `FlySite` in the app component's `composites`, so the listing joins
+ *   the instance to the component.
+ *
+ * A site the project changed keeps its files, and the plan lists the
+ * composite as not moved. The plan is empty unless the app component is the
+ * one `chud-lexicon-exit` wrote and names no composites yet.
+ */
+import type { ChantMigration } from "../chant-migrations.js";
+export declare const CHUD_LEXICON_EXIT_FLY_SITE = "chud-lexicon-exit-fly-site";
+/** The template's Fly site, as deploy/fly.ts and deploy/fly-machine.ts declare it. */
+export interface FlySiteValues {
+    /** The import that gives the app's name, kept as it is: `import { appSlug } from "../app-name.ts";`. */
+    nameImport: string | null;
+    /** The expression the App's name is, as written. */
+    app: string;
+    region: string;
+    machine: string;
+    image: string;
+    port: string;
+    env: string;
+    cpuKind: string;
+    cpus: string;
+    memoryMb: string;
+    volume: {
+        name: string;
+        sizeGb: string;
+        path: string;
+    };
+    ip: string;
+    secret: {
+        name: string;
+        value: string;
+    };
+}
+/**
+ * The Fly site's values when deploy/fly.ts and deploy/fly-machine.ts declare
+ * exactly the template's resources (their comments aside), or null. A site
+ * the project changed is left in its files, and the plan says so.
+ */
+export declare function readFlySite(fly: string, machine: string): FlySiteValues | null;
+/** deploy/fly.ts declaring the site with the fly lexicon's FlySite composite. */
+export declare function flySiteFile(v: FlySiteValues): string;
+export declare const chudLexiconExitFlySite: ChantMigration;
+//# sourceMappingURL=chud-lexicon-exit-fly-site.d.ts.map

package/dist/workspace/chant-migrations/chud-lexicon-exit-fly-site.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chud-lexicon-exit-fly-site.d.ts","sourceRoot":"","sources":["../../../src/workspace/chant-migrations/chud-lexicon-exit-fly-site.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAsE,MAAM,qBAAqB,CAAC;AAE9H,eAAO,MAAM,0BAA0B,+BAA+B,CAAC;AASvE,sFAAsF;AACtF,MAAM,WAAW,aAAa;IAC5B,wGAAwG;IACxG,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,oDAAoD;IACpD,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACvD,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CACzC;AAgDD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAuB9E;AAED,iFAAiF;AACjF,wBAAgB,WAAW,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CA4CpD;AAqDD,eAAO,MAAM,sBAAsB,EAAE,cAIpC,CAAC"}

package/dist/workspace/chant-migrations/chud-lexicon-exit-live-names.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `chud-lexicon-exit-live-names` (#2833): join the migrated `app` component
+ * to the Machine its release Op ships to, so `chant components status --live`
+ * reads it reconciled instead of stale.
+ *
+ * `chud-lexicon-exit` (0.92.0) rewrote `deploy/app.component.ts` off chud's
+ * app component, and wrote no `liveNames` on it. `components status --live`
+ * joins a component to live entities by name (`Component.liveNames`, falling
+ * back to the component's own name), and the component is `app` while the
+ * Machine the release Op ships to is some other entity. With no `liveNames`,
+ * the identity fallback looks for an entity named `app`, finds none, and the
+ * status reads `stale` even right after a release.
+ *
+ * This migration adds `liveNames: [<name>]` to the app component chant
+ * wrote, deriving `<name>` from what the member's Fly resources actually
+ * declare (#2839) rather than assuming one: while `deploy/fly-machine.ts`
+ * still declares the Machine directly, it is the entity `server`, its own
+ * top-level export. Once chant#2809's `FlySite` migration has taken over
+ * (deploy/fly.ts declares the site with the fly lexicon's `FlySite`
+ * composite and `fly-machine.ts` is gone), the composite expands its
+ * `machine` member under the site's own instance name, so the Machine is
+ * `<instance>Machine` — `flySiteMachine` for the instance name the FlySite
+ * migration writes (`flySite`), but read from the file rather than assumed,
+ * since a person may rename the export. The two migrations run in registry
+ * order (`FlySite` first), so a fresh upgrade that takes both always sees the
+ * post-`FlySite` shape by the time this one plans.
+ *
+ * It looks for the component `chud-lexicon-exit` left (by its own comment and
+ * shape) and inserts the field after `dependsOn: [],` rather than next to
+ * `archetype` — chant#2809's `FlySite` migration recognises the component by
+ * the exact, contiguous text `archetype: "service",\n  dependsOn: [],\n`, so
+ * anything inserted between those two lines (by either migration, in either
+ * order) would stop it from finding a component whose `composites` a person
+ * later removes. Anchoring after `dependsOn` instead keeps that pair intact
+ * whichever of the two migrations plans first.
+ *
+ * The plan is empty once `liveNames` already names the Machine this would
+ * derive. A component whose `liveNames` is exactly `["server"]` — this
+ * migration's own hardcoded output before #2839 — is corrected once the
+ * Machine it names is gone (`FlySite` has since taken over); any other
+ * hand-set value is left alone, on the same "by any hand" rule the empty
+ * case follows. It is a conflict when the component still reads as
+ * chud-lexicon-exit's but the `dependsOn: [],` line the edit anchors on is
+ * gone, or neither `deploy/fly.ts` nor `deploy/fly-machine.ts` says what the
+ * Machine's live name is — either way a person needs to add the mapping by
+ * hand.
+ */
+import type { ChantMigration } from "../chant-migrations.js";
+export declare const CHUD_LEXICON_EXIT_LIVE_NAMES = "chud-lexicon-exit-live-names";
+export declare const chudLexiconExitLiveNames: ChantMigration;
+//# sourceMappingURL=chud-lexicon-exit-live-names.d.ts.map

package/dist/workspace/chant-migrations/chud-lexicon-exit-live-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chud-lexicon-exit-live-names.d.ts","sourceRoot":"","sources":["../../../src/workspace/chant-migrations/chud-lexicon-exit-live-names.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAGH,OAAO,KAAK,EAAE,cAAc,EAA0E,MAAM,qBAAqB,CAAC;AAGlI,eAAO,MAAM,4BAA4B,iCAAiC,CAAC;AA2G3E,eAAO,MAAM,wBAAwB,EAAE,cAItC,CAAC"}