@vibe-agent-toolkit/cli 0.2.0-rc.10 → 0.2.0-rc.12

package/dist/commands/resources/check-progress.js

@@ -38,19 +38,44 @@
  * exactly and automatically by the schema the reader compiles with.
  */
 import { appendFileSync } from 'node:fs';
+import { POPULATION_ORIGINS } from '@vibe-agent-toolkit/resources';
+import { ExitCode } from '@vibe-agent-toolkit/schema';
 import { z } from 'zod';
+import { LENS_POPULATIONS } from '../../utils/lens-population.js';
+/**
+ * The child has booted — Node is up, the CLI is loaded, and no work has begun.
+ *
+ * 🚨 **The defect this closes: the population was charged the child's boot.**
+ * The watchdog's clock starts at the spawn, and the population line used to be
+ * the child's FIRST line — so Node's startup and the CLI's module graph were
+ * silently billed to the one unit the budget is already a total bound for. On a
+ * loaded runner the boot alone grows by seconds, and a run whose tree was fine
+ * was killed "during population" for its neighbours' load. This line closes the
+ * boot's window and opens the population's own, so the budget measures work.
+ *
+ * It carries no fields: the fact that it was written is the whole message. Its
+ * ABSENCE is what {@link unitInFlight} reads as `startup` — a run killed before
+ * it could say anything at all.
+ */
+const StartedEntrySchema = z.object({
+    kind: z.literal('started'),
+}).strict();
 /**
  * The population finished — how it was obtained, what it cost, and how much of
  * the tree it covered.
  *
  * Written the instant the projection is ready, because a kill BEFORE this line
- * means there is no projection at all and therefore no honest document to
- * publish. The parent distinguishes those two endings by this line's presence
- * and nothing else, so it must never be written early or optimistically.
+ * means there is no projection at all: the document the parent publishes then
+ * carries its population fields as `null`, not as a value nobody measured. The
+ * parent distinguishes those two endings by this line's presence and nothing
+ * else, so it must never be written early or optimistically.
  */
 const PopulationEntrySchema = z.object({
     kind: z.literal('population'),
-    population: z.union([z.literal('derived'), z.literal('store')]),
+    population: z.enum(POPULATION_ORIGINS),
+    // Carried across for the reason `lensMs` is: an interrupted run's document is
+    // rebuilt from these lines alone.
+    lensPopulation: z.enum(LENS_POPULATIONS),
     populationMs: z.number(),
     // Carried across the process boundary rather than recomputed, for the same
     // reason every other field here is: a killed run's document is rebuilt from
@@ -122,6 +147,7 @@ const ChecksCompleteEntrySchema = z.object({
     kind: z.literal('checks-complete'),
 }).strict();
 const ProgressEntrySchema = z.discriminatedUnion('kind', [
+    StartedEntrySchema,
     PopulationEntrySchema,
     StartEntrySchema,
     CheckEntrySchema,
@@ -176,15 +202,23 @@ function readLine(line) {
  *
  * 🔑 The population sentinel is keyed on the population line's ABSENCE rather
  * than on there being no `start` lines. Those are different states: a run killed
- * during population has no projection and no honest document, while a run killed
- * between the population and the first statement has both.
+ * during population has no projection, while a run killed between the population
+ * and the first statement has one.
+ *
+ * 🔑 The startup sentinel is keyed the same way, on the `started` line's
+ * absence — never on an empty log. Before that line the child was still loading
+ * Node and the CLI, nothing had touched the tree, and advice about sizing the
+ * budget against a population would be advice about a unit that never began.
  *
  * @param entries - What {@link parseProgressLog} recovered
  * @returns The unit in flight
  */
 export function unitInFlight(entries) {
-    if (!entries.some((entry) => entry.kind === 'population'))
-        return { kind: 'population' };
+    if (!entries.some((entry) => entry.kind === 'population')) {
+        return entries.some((entry) => entry.kind === 'started')
+            ? { kind: 'population' }
+            : { kind: 'startup' };
+    }
     const completed = new Set(entries.filter((entry) => entry.kind === 'check').map((entry) => entry.name));
     // 🪤 The `completed` set is what makes this unique, NOT the scan direction.
     // The runner is serial — one statement at a time, its cost filed before the
@@ -211,12 +245,79 @@ export function unitInFlight(entries) {
  * queued behind work the event loop never gets back to, so the line naming the
  * rule that hangs would exist only in memory — where `SIGKILL` destroys it.
  *
- * @param path - Where the supervisor is watching
+ * @param child - Where the supervisor is watching
  * @returns A writer that appends one entry and returns once it is on disk
  */
-export function createProgressWriter(path) {
+export function createProgressWriter(child) {
     return (entry) => {
-        appendFileSync(path, `${JSON.stringify(entry)}\n`, 'utf-8');
+        appendFileSync(child.progressLog, `${JSON.stringify(entry)}\n`, 'utf-8');
     };
 }
+/**
+ * End this supervised child the moment its supervisor is gone, however the supervisor ended.
+ *
+ * ## 🚨 Why: the bound lives in the supervisor
+ *
+ * A supervisor that dies where none of its own code runs — SIGKILL, an OOM killer — cannot take the
+ * child down, and the child would run on with nothing bounding it and nobody reading what it
+ * publishes. This is the POSIX path: on Windows an outside kill of the supervisor
+ * (`TerminateProcess`) ends this process too, before any of its code runs, because libuv spawns it
+ * in a kill-on-close job object whose only handle the supervisor holds. The pipe below is there on
+ * Windows as well, and harmless.
+ *
+ * ## 🔑 How: the supervisor holds this process's stdin open and never writes to it
+ *
+ * The supervisor spawns the child with stdin as a pipe whose write end only it holds, and it never
+ * writes or ends it. However the supervisor ends, the OS closes that end, and this process reads
+ * end-of-file — with no pid to compare and no liveness probe to misread (a pid
+ * reused, or a probe refused `EPERM` in a sandbox, both used to read wrongly). On EOF, a read error
+ * or a close, the child ends at once: exit 2 and ONE stderr line, no document — nobody is left to
+ * read one. It ends by `process.exit`, never by a signal handler: the child must never install one
+ * (see `check-supervisor.ts`). Nothing else in the child reads stdin.
+ *
+ * The stream is UNREFERENCED, so a child that finishes is never held open by it.
+ *
+ * ⚠️ **It fires when this process's event loop next turns, and only then.** The population is
+ * asynchronous I/O, so an orphan there ends at once. The checks run one after another
+ * synchronously, and a statement blocked inside SQLite reaches nothing until it returns — so an
+ * orphan in the middle of them runs on until the LAST check returns. It then ends before it
+ * publishes anything, because the child turns its loop first ({@link letSupervisorLossSurface}).
+ *
+ * @param supervisorPid - The supervisor's pid, named in the stderr line
+ * @param stdin - This process's stdin: the caller passes `process.stdin`; a test hands it a stream
+ *   it owns
+ */
+export function endWhenSupervisorGone(supervisorPid, stdin) {
+    let ended = false;
+    const end = () => {
+        if (ended)
+            return;
+        ended = true;
+        process.stderr.write(`vat resources check: the process supervising this checks run (pid ${String(supervisorPid)})`
+            + ' is gone, so nothing bounds the run or reads its report. Ending it unfinished.\n');
+        process.exit(ExitCode.ERROR);
+    };
+    stdin.once('end', end);
+    stdin.once('close', end);
+    stdin.once('error', end);
+    // Flowing, so end-of-file is read at all; the supervisor never writes, so nothing arrives.
+    stdin.resume();
+    stdin.unref?.();
+}
+/**
+ * Let a supervisor's loss END this child before it publishes: turn the event loop twice, so an
+ * end-of-file that has waited on stdin since the supervisor died — while the synchronous check loop
+ * held the thread — is read, and {@link endWhenSupervisorGone} exits before any document is written.
+ *
+ * Twice, because the first turn may begin after this iteration's poll phase: the second always
+ * crosses one. Without it, a child orphaned inside a check wrote its document to a pipe nobody
+ * reads and exited 0.
+ *
+ * @returns A promise that resolves after two turns — when the child is still supervised
+ */
+export async function letSupervisorLossSurface() {
+    const turn = () => new Promise((resolve) => setImmediate(resolve));
+    await turn();
+    await turn();
+}
 //# sourceMappingURL=check-progress.js.map

package/dist/commands/resources/check-progress.js.map

@@ -1 +1 @@
-{"version":3,"file":"check-progress.js","sourceRoot":"","sources":["../../../src/commands/resources/check-progress.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"check-progress.js","sourceRoot":"","sources":["../../../src/commands/resources/check-progress.ts"],"names":[],"mappings":"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"}

package/dist/commands/resources/check-schema.d.ts

@@ -0,0 +1,335 @@
+/**
+ * The document `vat resources check` publishes, apart from the command.
+ *
+ * A sibling module because the published-shape registry imports it and the
+ * command imports the writer that imports the registry: a schema declared in
+ * the command module itself would be an import cycle, read before it is
+ * initialised.
+ */
+import { type Report } from '@vibe-agent-toolkit/schema';
+import { z } from 'zod';
+import type { ExaminedDeclaration } from '../../utils/run-integrity.js';
+/**
+ * A signed bound on what the derived rows settle, as `@vibe-agent-toolkit/resources`
+ * states it.
+ *
+ * ⛔ The direction vocabulary is IMPORTED, never respelled: `LIMIT_DIRECTIONS`
+ * is the one list, tied to `StatedLimit['direction']` by `satisfies`, so a
+ * fifth direction cannot leave this schema quietly rejecting it.
+ */
+export declare const StatedLimitSchema: z.ZodObject<{
+    id: z.ZodString;
+    direction: z.ZodEnum<["over-report", "under-report", "scope", "assumption"]>;
+    statement: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    direction: "scope" | "over-report" | "under-report" | "assumption";
+    statement: string;
+}, {
+    id: string;
+    direction: "scope" | "over-report" | "under-report" | "assumption";
+    statement: string;
+}>;
+/**
+ * What the check run reports beyond its findings.
+ *
+ * The envelope's `examined` is `membersEnumerated` — what the rules ran
+ * AGAINST. `checksRun` is the other denominator, the number of RULES, and both
+ * are needed: zero findings is the pass condition and either number at zero
+ * makes that pass vacuous.
+ */
+declare const CheckDataSchema: z.ZodObject<{
+    root: z.ZodString;
+    /**
+     * Whether the projection was derived this run or read from the store.
+     *
+     * 🔑 `null` — together with `populationSecs`, `lensSecs` and
+     * `lensesEvaluated` — exactly when the run was interrupted before its
+     * population completed. There was no projection, so there is no origin, cost
+     * or lens set to report, and a `RESOURCE_CHECK_BROKEN` finding says why.
+     */
+    population: z.ZodNullable<z.ZodEnum<["store" | "derived", ...("store" | "derived")[]]>>;
+    /** What the population cost — charged to no check, see `CheckCost`. Null as `population` is. */
+    populationSecs: z.ZodNullable<z.ZodNumber>;
+    /** What evaluating the lenses cost, paid before the first statement ran. Null as `population` is. */
+    lensSecs: z.ZodNullable<z.ZodNumber>;
+    /**
+     * Which lenses that covers — the derived relations this run's checks could
+     * actually read. 🔑 An empty list says "no check asked for a derived relation"
+     * rather than "a lens stopped running"; without it `lensSecs: 0` is the same
+     * document either way, and a gate whose rules silently read empty relations is
+     * a gate that cannot fail. Null as `population` is — `[]` would claim "no
+     * check asked", about a run that never got far enough to ask.
+     */
+    lensesEvaluated: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Where the lenses' own populations came from: `none` when no evaluated lens
+     * populated anything (no statement named a claude-context relation), `store`
+     * when every one that did was served from the store, otherwise `derived`.
+     * Null as `population` is — no population happened at all.
+     */
+    lensPopulation: z.ZodNullable<z.ZodEnum<["none", "store" | "derived", ...("store" | "derived")[]]>>;
+    /**
+     * The prose frame {@link CheckDataSchema.limits} is read under. Present
+     * exactly when a lens with stated bounds was evaluated.
+     */
+    boundsStatement: z.ZodOptional<z.ZodString>;
+    /**
+     * What the derived rows this run could read do NOT settle — signed and
+     * directional, the same list `vat claude context` publishes beside its own
+     * answer. Absent when no bounded lens ran: an empty list would claim nothing
+     * bounds the answer, which is stronger than "the answer holds no such row".
+     */
+    limits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        direction: z.ZodEnum<["over-report", "under-report", "scope", "assumption"]>;
+        statement: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        direction: "scope" | "over-report" | "under-report" | "assumption";
+        statement: string;
+    }, {
+        id: string;
+        direction: "scope" | "over-report" | "under-report" | "assumption";
+        statement: string;
+    }>, "many">>;
+    /** The number of rules that EXECUTED. Derived from `checks`, never carried beside it. */
+    checksRun: z.ZodNumber;
+    /** What each rule cost, directly under the denominator it is the breakdown of. */
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        /** Three significant figures, so a 0.4 ms rule serializes as 0.0004 rather than a zero that reads as "not measured". */
+        durationSecs: z.ZodNumber;
+        /** Rows the statement returned. ABSENT, never 0, when the statement did not complete. */
+        rows: z.ZodOptional<z.ZodNumber>;
+        broken: z.ZodOptional<z.ZodLiteral<true>>;
+        /** Present and `true` only for a rule VAT supplied — see `CheckCost.builtin` in `check.ts`. */
+        builtin: z.ZodOptional<z.ZodLiteral<true>>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        durationSecs: number;
+        rows?: number | undefined;
+        broken?: true | undefined;
+        builtin?: true | undefined;
+    }, {
+        name: string;
+        durationSecs: number;
+        rows?: number | undefined;
+        broken?: true | undefined;
+        builtin?: true | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    root: string;
+    checks: {
+        name: string;
+        durationSecs: number;
+        rows?: number | undefined;
+        broken?: true | undefined;
+        builtin?: true | undefined;
+    }[];
+    population: "store" | "derived" | null;
+    populationSecs: number | null;
+    lensSecs: number | null;
+    lensesEvaluated: string[] | null;
+    lensPopulation: "store" | "none" | "derived" | null;
+    checksRun: number;
+    boundsStatement?: string | undefined;
+    limits?: {
+        id: string;
+        direction: "scope" | "over-report" | "under-report" | "assumption";
+        statement: string;
+    }[] | undefined;
+}, {
+    root: string;
+    checks: {
+        name: string;
+        durationSecs: number;
+        rows?: number | undefined;
+        broken?: true | undefined;
+        builtin?: true | undefined;
+    }[];
+    population: "store" | "derived" | null;
+    populationSecs: number | null;
+    lensSecs: number | null;
+    lensesEvaluated: string[] | null;
+    lensPopulation: "store" | "none" | "derived" | null;
+    checksRun: number;
+    boundsStatement?: string | undefined;
+    limits?: {
+        id: string;
+        direction: "scope" | "over-report" | "under-report" | "assumption";
+        statement: string;
+    }[] | undefined;
+}>;
+export type CheckData = z.infer<typeof CheckDataSchema>;
+/** The document this command publishes. */
+export declare const CHECK_REPORT_SCHEMA: import("@vibe-agent-toolkit/schema").ReportZodSchema<z.ZodObject<{
+    root: z.ZodString;
+    /**
+     * Whether the projection was derived this run or read from the store.
+     *
+     * 🔑 `null` — together with `populationSecs`, `lensSecs` and
+     * `lensesEvaluated` — exactly when the run was interrupted before its
+     * population completed. There was no projection, so there is no origin, cost
+     * or lens set to report, and a `RESOURCE_CHECK_BROKEN` finding says why.
+     */
+    population: z.ZodNullable<z.ZodEnum<["store" | "derived", ...("store" | "derived")[]]>>;
+    /** What the population cost — charged to no check, see `CheckCost`. Null as `population` is. */
+    populationSecs: z.ZodNullable<z.ZodNumber>;
+    /** What evaluating the lenses cost, paid before the first statement ran. Null as `population` is. */
+    lensSecs: z.ZodNullable<z.ZodNumber>;
+    /**
+     * Which lenses that covers — the derived relations this run's checks could
+     * actually read. 🔑 An empty list says "no check asked for a derived relation"
+     * rather than "a lens stopped running"; without it `lensSecs: 0` is the same
+     * document either way, and a gate whose rules silently read empty relations is
+     * a gate that cannot fail. Null as `population` is — `[]` would claim "no
+     * check asked", about a run that never got far enough to ask.
+     */
+    lensesEvaluated: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Where the lenses' own populations came from: `none` when no evaluated lens
+     * populated anything (no statement named a claude-context relation), `store`
+     * when every one that did was served from the store, otherwise `derived`.
+     * Null as `population` is — no population happened at all.
+     */
+    lensPopulation: z.ZodNullable<z.ZodEnum<["none", "store" | "derived", ...("store" | "derived")[]]>>;
+    /**
+     * The prose frame {@link CheckDataSchema.limits} is read under. Present
+     * exactly when a lens with stated bounds was evaluated.
+     */
+    boundsStatement: z.ZodOptional<z.ZodString>;
+    /**
+     * What the derived rows this run could read do NOT settle — signed and
+     * directional, the same list `vat claude context` publishes beside its own
+     * answer. Absent when no bounded lens ran: an empty list would claim nothing
+     * bounds the answer, which is stronger than "the answer holds no such row".
+     */
+    limits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        direction: z.ZodEnum<["over-report", "under-report", "scope", "assumption"]>;
+        statement: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        direction: "scope" | "over-report" | "under-report" | "assumption";
+        statement: string;
+    }, {
+        id: string;
+        direction: "scope" | "over-report" | "under-report" | "assumption";
+        statement: string;
+    }>, "many">>;
+    /** The number of rules that EXECUTED. Derived from `checks`, never carried beside it. */
+    checksRun: z.ZodNumber;
+    /** What each rule cost, directly under the denominator it is the breakdown of. */
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        /** Three significant figures, so a 0.4 ms rule serializes as 0.0004 rather than a zero that reads as "not measured". */
+        durationSecs: z.ZodNumber;
+        /** Rows the statement returned. ABSENT, never 0, when the statement did not complete. */
+        rows: z.ZodOptional<z.ZodNumber>;
+        broken: z.ZodOptional<z.ZodLiteral<true>>;
+        /** Present and `true` only for a rule VAT supplied — see `CheckCost.builtin` in `check.ts`. */
+        builtin: z.ZodOptional<z.ZodLiteral<true>>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        durationSecs: number;
+        rows?: number | undefined;
+        broken?: true | undefined;
+        builtin?: true | undefined;
+    }, {
+        name: string;
+        durationSecs: number;
+        rows?: number | undefined;
+        broken?: true | undefined;
+        builtin?: true | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    root: string;
+    checks: {
+        name: string;
+        durationSecs: number;
+        rows?: number | undefined;
+        broken?: true | undefined;
+        builtin?: true | undefined;
+    }[];
+    population: "store" | "derived" | null;
+    populationSecs: number | null;
+    lensSecs: number | null;
+    lensesEvaluated: string[] | null;
+    lensPopulation: "store" | "none" | "derived" | null;
+    checksRun: number;
+    boundsStatement?: string | undefined;
+    limits?: {
+        id: string;
+        direction: "scope" | "over-report" | "under-report" | "assumption";
+        statement: string;
+    }[] | undefined;
+}, {
+    root: string;
+    checks: {
+        name: string;
+        durationSecs: number;
+        rows?: number | undefined;
+        broken?: true | undefined;
+        builtin?: true | undefined;
+    }[];
+    population: "store" | "derived" | null;
+    populationSecs: number | null;
+    lensSecs: number | null;
+    lensesEvaluated: string[] | null;
+    lensPopulation: "store" | "none" | "derived" | null;
+    checksRun: number;
+    boundsStatement?: string | undefined;
+    limits?: {
+        id: string;
+        direction: "scope" | "over-report" | "under-report" | "assumption";
+        statement: string;
+    }[] | undefined;
+}>, z.ZodObject<Omit<{
+    code: z.ZodString;
+    severity: z.ZodEnum<["error", "warning", "info", "ignore"]>;
+    message: z.ZodString;
+    location: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    line: z.ZodOptional<z.ZodNumber>;
+    field: z.ZodOptional<z.ZodString>;
+    link: z.ZodOptional<z.ZodString>;
+    fix: z.ZodOptional<z.ZodString>;
+    reference: z.ZodOptional<z.ZodString>;
+    suggestion: z.ZodOptional<z.ZodString>;
+}, "severity"> & {
+    severity: z.ZodEnum<["error", "warning", "info"]>;
+    column: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    code: string;
+    message: string;
+    severity: "error" | "warning" | "info";
+    fix?: string | undefined;
+    reference?: string | undefined;
+    location?: string | undefined;
+    line?: number | undefined;
+    field?: string | undefined;
+    link?: string | undefined;
+    suggestion?: string | undefined;
+    column?: number | undefined;
+}, {
+    code: string;
+    message: string;
+    severity: "error" | "warning" | "info";
+    fix?: string | undefined;
+    reference?: string | undefined;
+    location?: string | undefined;
+    line?: number | undefined;
+    field?: string | undefined;
+    link?: string | undefined;
+    suggestion?: string | undefined;
+    column?: number | undefined;
+}>>;
+export type CheckReport = Report<CheckData>;
+/**
+ * What `examined` counts for `vat resources check`, and the remedy when it is zero. One
+ * declaration for the verb's own writer (the published-shape registry) and for the `checks`
+ * phase `vat validate` runs, so a run that examined nothing is refused the same way in both.
+ */
+export declare const RESOURCES_CHECK_EXAMINED: ExaminedDeclaration;
+export {};
+//# sourceMappingURL=check-schema.d.ts.map

package/dist/commands/resources/check-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-schema.d.ts","sourceRoot":"","sources":["../../../src/commands/resources/check-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAA+B,KAAK,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACtF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAcxE;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;EAInB,CAAC;AAEZ;;;;;;;GAOG;AACH,QAAA,MAAM,eAAe;;IAEnB;;;;;;;OAOG;;IAEH,gGAAgG;;IAEhG,qGAAqG;;IAErG;;;;;;;OAOG;;IAEH;;;;;OAKG;;IAEH;;;OAGG;;IAEH;;;;;OAKG;;;;;;;;;;;;;;IAEH,yFAAyF;;IAEzF,kFAAkF;;;QA5ElF,wHAAwH;;QAExH,yFAAyF;;;QAGzF,+FAA+F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyEtF,CAAC;AAEZ,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,2CAA2C;AAC3C,eAAO,MAAM,mBAAmB;;IAlD9B;;;;;;;OAOG;;IAEH,gGAAgG;;IAEhG,qGAAqG;;IAErG;;;;;;;OAOG;;IAEH;;;;;OAKG;;IAEH;;;OAGG;;IAEH;;;;;OAKG;;;;;;;;;;;;;;IAEH,yFAAyF;;IAEzF,kFAAkF;;;QA5ElF,wHAAwH;;QAExH,yFAAyF;;;QAGzF,+FAA+F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8ElB,CAAC;AAEhF,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAGtC,CAAC"}

package/dist/commands/resources/check-schema.js

@@ -0,0 +1,104 @@
+/**
+ * The document `vat resources check` publishes, apart from the command.
+ *
+ * A sibling module because the published-shape registry imports it and the
+ * command imports the writer that imports the registry: a schema declared in
+ * the command module itself would be an import cycle, read before it is
+ * initialised.
+ */
+import { LIMIT_DIRECTIONS, POPULATION_ORIGINS } from '@vibe-agent-toolkit/resources';
+import { FindingSchema, reportSchema } from '@vibe-agent-toolkit/schema';
+import { z } from 'zod';
+import { LENS_POPULATIONS } from '../../utils/lens-population.js';
+/** What one rule cost, as the document publishes it. */
+const PublishedCheckCostSchema = z.object({
+    name: z.string(),
+    /** Three significant figures, so a 0.4 ms rule serializes as 0.0004 rather than a zero that reads as "not measured". */
+    durationSecs: z.number().nonnegative(),
+    /** Rows the statement returned. ABSENT, never 0, when the statement did not complete. */
+    rows: z.number().int().nonnegative().optional(),
+    broken: z.literal(true).optional(),
+    /** Present and `true` only for a rule VAT supplied — see `CheckCost.builtin` in `check.ts`. */
+    builtin: z.literal(true).optional(),
+}).strict();
+/**
+ * A signed bound on what the derived rows settle, as `@vibe-agent-toolkit/resources`
+ * states it.
+ *
+ * ⛔ The direction vocabulary is IMPORTED, never respelled: `LIMIT_DIRECTIONS`
+ * is the one list, tied to `StatedLimit['direction']` by `satisfies`, so a
+ * fifth direction cannot leave this schema quietly rejecting it.
+ */
+export const StatedLimitSchema = z.object({
+    id: z.string(),
+    direction: z.enum(LIMIT_DIRECTIONS),
+    statement: z.string(),
+}).strict();
+/**
+ * What the check run reports beyond its findings.
+ *
+ * The envelope's `examined` is `membersEnumerated` — what the rules ran
+ * AGAINST. `checksRun` is the other denominator, the number of RULES, and both
+ * are needed: zero findings is the pass condition and either number at zero
+ * makes that pass vacuous.
+ */
+const CheckDataSchema = z.object({
+    root: z.string(),
+    /**
+     * Whether the projection was derived this run or read from the store.
+     *
+     * 🔑 `null` — together with `populationSecs`, `lensSecs` and
+     * `lensesEvaluated` — exactly when the run was interrupted before its
+     * population completed. There was no projection, so there is no origin, cost
+     * or lens set to report, and a `RESOURCE_CHECK_BROKEN` finding says why.
+     */
+    population: z.enum(POPULATION_ORIGINS).nullable(),
+    /** What the population cost — charged to no check, see `CheckCost`. Null as `population` is. */
+    populationSecs: z.number().nonnegative().nullable(),
+    /** What evaluating the lenses cost, paid before the first statement ran. Null as `population` is. */
+    lensSecs: z.number().nonnegative().nullable(),
+    /**
+     * Which lenses that covers — the derived relations this run's checks could
+     * actually read. 🔑 An empty list says "no check asked for a derived relation"
+     * rather than "a lens stopped running"; without it `lensSecs: 0` is the same
+     * document either way, and a gate whose rules silently read empty relations is
+     * a gate that cannot fail. Null as `population` is — `[]` would claim "no
+     * check asked", about a run that never got far enough to ask.
+     */
+    lensesEvaluated: z.array(z.string()).nullable(),
+    /**
+     * Where the lenses' own populations came from: `none` when no evaluated lens
+     * populated anything (no statement named a claude-context relation), `store`
+     * when every one that did was served from the store, otherwise `derived`.
+     * Null as `population` is — no population happened at all.
+     */
+    lensPopulation: z.enum(LENS_POPULATIONS).nullable(),
+    /**
+     * The prose frame {@link CheckDataSchema.limits} is read under. Present
+     * exactly when a lens with stated bounds was evaluated.
+     */
+    boundsStatement: z.string().optional(),
+    /**
+     * What the derived rows this run could read do NOT settle — signed and
+     * directional, the same list `vat claude context` publishes beside its own
+     * answer. Absent when no bounded lens ran: an empty list would claim nothing
+     * bounds the answer, which is stronger than "the answer holds no such row".
+     */
+    limits: z.array(StatedLimitSchema).optional(),
+    /** The number of rules that EXECUTED. Derived from `checks`, never carried beside it. */
+    checksRun: z.number().int().nonnegative(),
+    /** What each rule cost, directly under the denominator it is the breakdown of. */
+    checks: z.array(PublishedCheckCostSchema),
+}).strict();
+/** The document this command publishes. */
+export const CHECK_REPORT_SCHEMA = reportSchema(CheckDataSchema, FindingSchema);
+/**
+ * What `examined` counts for `vat resources check`, and the remedy when it is zero. One
+ * declaration for the verb's own writer (the published-shape registry) and for the `checks`
+ * phase `vat validate` runs, so a run that examined nothing is refused the same way in both.
+ */
+export const RESOURCES_CHECK_EXAMINED = {
+    unit: 'resources in the population',
+    whenZero: 'The projection holds no resource under the project root: check that the project root this run resolved is the one you meant, and that its files are not all gitignored.',
+};
+//# sourceMappingURL=check-schema.js.map

package/dist/commands/resources/check-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-schema.js","sourceRoot":"","sources":["../../../src/commands/resources/check-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACrF,OAAO,EAAE,aAAa,EAAE,YAAY,EAAe,MAAM,4BAA4B,CAAC;AACtF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAGlE,wDAAwD;AACxD,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,wHAAwH;IACxH,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE;IACtC,yFAAyF;IACzF,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;IAC/C,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE;IAClC,+FAA+F;IAC/F,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE;CACpC,CAAC,CAAC,MAAM,EAAE,CAAC;AAEZ;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,SAAS,EAAE,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC;IACnC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;CACtB,CAAC,CAAC,MAAM,EAAE,CAAC;AAEZ;;;;;;;GAOG;AACH,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB;;;;;;;OAOG;IACH,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,QAAQ,EAAE;IACjD,gGAAgG;IAChG,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;IACnD,qGAAqG;IACrG,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;IAC7C;;;;;;;OAOG;IACH,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IAC/C;;;;;OAKG;IACH,cAAc,EAAE,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,QAAQ,EAAE;IACnD;;;OAGG;IACH,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACtC;;;;;OAKG;IACH,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,QAAQ,EAAE;IAC7C,yFAAyF;IACzF,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IACzC,kFAAkF;IAClF,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC;CAC1C,CAAC,CAAC,MAAM,EAAE,CAAC;AAIZ,2CAA2C;AAC3C,MAAM,CAAC,MAAM,mBAAmB,GAAG,YAAY,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC;AAIhF;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAwB;IAC3D,IAAI,EAAE,6BAA6B;IACnC,QAAQ,EAAE,yKAAyK;CACpL,CAAC"}