plumbbob 0.9.3 → 0.9.5

package/node_modules/checkride/dist/artifacts/freshness.js

@@ -0,0 +1,37 @@
+/**
+ * The freshness window — which `.check/` files belong to the run that wrote the
+ * summary sitting beside them.
+ *
+ * The window is `[timestamp - total_duration_ms, ∞)`: the run's *start*, not
+ * its end, because `timestamp` is stamped once every check has finished (see
+ * `buildSummary` in `../orchestrator.ts`) and every artifact the run just wrote
+ * is therefore older than it. Anything outside the window is labelled with its
+ * age, never silently dropped.
+ *
+ * Why a window at all, and why this derivation is contract-legal:
+ * `docs/plugin.md` §How the readers decide an artifact is stale.
+ *
+ * The `../artifacts` barrel is this module's only public surface.
+ */
+const FRESH = { state: 'fresh', ageMs: null };
+const UNKNOWN = { state: 'unknown', ageMs: null };
+/**
+ * Epoch milliseconds at which the run began, or `null` when `timestamp` is not
+ * a parseable date. Callers treat `null` as "cannot judge freshness" rather
+ * than guessing in either direction.
+ */
+export function runWindowStart(summary) {
+    const stamped = Date.parse(summary.timestamp);
+    if (Number.isNaN(stamped))
+        return null;
+    return stamped - summary.total_duration_ms;
+}
+/** Classify one artifact's mtime against the window from {@link runWindowStart}. */
+export function classifyFreshness(mtimeMs, windowStart) {
+    if (windowStart === null)
+        return UNKNOWN;
+    if (mtimeMs >= windowStart)
+        return FRESH;
+    return { state: 'stale', ageMs: windowStart - mtimeMs };
+}
+//# sourceMappingURL=freshness.js.map

package/node_modules/checkride/dist/artifacts/freshness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"freshness.js","sourceRoot":"","sources":["../../src/artifacts/freshness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAYH,MAAM,KAAK,GAAc,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AACzD,MAAM,OAAO,GAAc,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAE7D;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,OAAgB;IAC7C,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAC9C,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC;QAAE,OAAO,IAAI,CAAC;IACvC,OAAO,OAAO,GAAG,OAAO,CAAC,iBAAiB,CAAC;AAC7C,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,iBAAiB,CAAC,OAAe,EAAE,WAA0B;IAC3E,IAAI,WAAW,KAAK,IAAI;QAAE,OAAO,OAAO,CAAC;IACzC,IAAI,OAAO,IAAI,WAAW;QAAE,OAAO,KAAK,CAAC;IACzC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,EAAE,CAAC;AAC1D,CAAC"}

package/node_modules/checkride/dist/artifacts/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Artifacts module — the shared, bounded read of what a checkride run left in
+ * `.check/`. Parse the summary and pin its schema, judge each file against the
+ * run's freshness window, resolve a slot's raw output by the documented
+ * convention, and size what was found without opening it.
+ *
+ * Both bundled-plugin readers (`../triage` and `../qa`) consume the
+ * contract only through here — one copy of the summary parse,
+ * one freshness rule, one raw-output lookup. This barrel is the module's only
+ * public surface: siblings import from `../artifacts/index.js`, never from a
+ * file inside it.
+ */
+export { configuredSlots } from './configured.js';
+export { formatBytes, formatDuration, tail } from './format.js';
+export { classifyFreshness, runWindowStart } from './freshness.js';
+export type { Freshness } from './freshness.js';
+export { asNumberOrNull, asRecord, asRecordArray, asStringOrNull, isRecord, parseJson } from './json.js';
+export { listArtifacts, resolveRawOutput, statArtifact } from './raw.js';
+export type { ArtifactFile, RawOutput } from './raw.js';
+export { CHECK_DIR, parseSummary, readSummary, SUPPORTED_SCHEMA_VERSION } from './summary.js';
+export type { SummaryRead } from './summary.js';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/checkride/dist/artifacts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/artifacts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAElD,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACnE,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,aAAa,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEzG,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACzE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAExD,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAC9F,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC"}

package/node_modules/checkride/dist/artifacts/index.js

@@ -0,0 +1,19 @@
+/**
+ * Artifacts module — the shared, bounded read of what a checkride run left in
+ * `.check/`. Parse the summary and pin its schema, judge each file against the
+ * run's freshness window, resolve a slot's raw output by the documented
+ * convention, and size what was found without opening it.
+ *
+ * Both bundled-plugin readers (`../triage` and `../qa`) consume the
+ * contract only through here — one copy of the summary parse,
+ * one freshness rule, one raw-output lookup. This barrel is the module's only
+ * public surface: siblings import from `../artifacts/index.js`, never from a
+ * file inside it.
+ */
+export { configuredSlots } from './configured.js';
+export { formatBytes, formatDuration, tail } from './format.js';
+export { classifyFreshness, runWindowStart } from './freshness.js';
+export { asNumberOrNull, asRecord, asRecordArray, asStringOrNull, isRecord, parseJson } from './json.js';
+export { listArtifacts, resolveRawOutput, statArtifact } from './raw.js';
+export { CHECK_DIR, parseSummary, readSummary, SUPPORTED_SCHEMA_VERSION } from './summary.js';
+//# sourceMappingURL=index.js.map

package/node_modules/checkride/dist/artifacts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/artifacts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAElD,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGnE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,aAAa,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEzG,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAGzE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC"}

package/node_modules/checkride/dist/artifacts/json.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Defensive JSON narrowing for artifact reads.
+ *
+ * Both readers parse files a *different* checkride version may have written, so
+ * every field access goes through a guard rather than a cast: a reader that
+ * crashes on an unexpected shape is worse than one that says what it could not
+ * read. These are the smallest primitives that make a `JSON.parse` result
+ * usable without `any` and without asserting a type onto unvalidated bytes.
+ *
+ * The `../artifacts` barrel is this module's only public surface.
+ */
+import { isRecord } from '../json.js';
+import type { JsonRecord } from '../json.js';
+export { isRecord };
+export type { JsonRecord };
+/** A string field, or `null` for every other type — including a missing key. */
+export declare function asStringOrNull(value: unknown): string | null;
+/** A number field, or `null` for every other type — including a missing key. */
+export declare function asNumberOrNull(value: unknown): number | null;
+/**
+ * A nested object, or an empty one when the key is missing or holds something
+ * else. Reading a handful of fields off a block that may not exist is the
+ * common shape in these artifacts, and `{}` makes every such read a `null`
+ * rather than a branch at each call site.
+ */
+export declare function asRecord(value: unknown): JsonRecord;
+/** The object entries of an array field; `[]` when it is not an array at all. */
+export declare function asRecordArray(value: unknown): JsonRecord[];
+/** Parse JSON without throwing: the parsed value, or `null` when it is not JSON. */
+export declare function parseJson(raw: string): unknown;
+//# sourceMappingURL=json.d.ts.map

package/node_modules/checkride/dist/artifacts/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/artifacts/json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAK7C,OAAO,EAAE,QAAQ,EAAE,CAAC;AACpB,YAAY,EAAE,UAAU,EAAE,CAAC;AAE3B,gFAAgF;AAChF,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAE5D;AAED,gFAAgF;AAChF,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAE5D;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAEnD;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,EAAE,CAE1D;AAED,oFAAoF;AACpF,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAM9C"}

package/node_modules/checkride/dist/artifacts/json.js

@@ -0,0 +1,47 @@
+/**
+ * Defensive JSON narrowing for artifact reads.
+ *
+ * Both readers parse files a *different* checkride version may have written, so
+ * every field access goes through a guard rather than a cast: a reader that
+ * crashes on an unexpected shape is worse than one that says what it could not
+ * read. These are the smallest primitives that make a `JSON.parse` result
+ * usable without `any` and without asserting a type onto unvalidated bytes.
+ *
+ * The `../artifacts` barrel is this module's only public surface.
+ */
+import { isRecord } from '../json.js';
+// `isRecord`/`JsonRecord` are the package-wide primitives (`../json.ts`);
+// re-exported here so the artifacts barrel keeps its existing surface and the
+// readers' import sites are unchanged.
+export { isRecord };
+/** A string field, or `null` for every other type — including a missing key. */
+export function asStringOrNull(value) {
+    return typeof value === 'string' ? value : null;
+}
+/** A number field, or `null` for every other type — including a missing key. */
+export function asNumberOrNull(value) {
+    return typeof value === 'number' ? value : null;
+}
+/**
+ * A nested object, or an empty one when the key is missing or holds something
+ * else. Reading a handful of fields off a block that may not exist is the
+ * common shape in these artifacts, and `{}` makes every such read a `null`
+ * rather than a branch at each call site.
+ */
+export function asRecord(value) {
+    return isRecord(value) ? value : {};
+}
+/** The object entries of an array field; `[]` when it is not an array at all. */
+export function asRecordArray(value) {
+    return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+/** Parse JSON without throwing: the parsed value, or `null` when it is not JSON. */
+export function parseJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=json.js.map

package/node_modules/checkride/dist/artifacts/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../../src/artifacts/json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGtC,0EAA0E;AAC1E,8EAA8E;AAC9E,uCAAuC;AACvC,OAAO,EAAE,QAAQ,EAAE,CAAC;AAGpB,gFAAgF;AAChF,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AAClD,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AAClD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAc;IACrC,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AACtC,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,aAAa,CAAC,KAAc;IAC1C,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AAC5D,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,SAAS,CAAC,GAAW;IACnC,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}

package/node_modules/checkride/dist/artifacts/raw.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Locating a slot's raw output — the bytes the summary indexes but usually does
+ * not name.
+ *
+ * `output_file` is populated only when a tool emits JSON on stdout, so most
+ * slots carry `null` there while their real output sits in `.check/` under the
+ * documented convention (`<slot>.json`, else `<slot>.stdout.txt` /
+ * `<slot>.stderr.txt`). On a full run of this repo, 8 of 17 checks name no file
+ * — `test` among them, the slot most likely to need triage. A reader that
+ * reported "no output" for those would be wrong about the one thing it exists
+ * to get right, so it owns the convention as a fallback.
+ *
+ * Everything found is measured, never opened: the readers report *sizes* and
+ * point at the file. `mutation.json` in this repo is 2.3 MB; `test.json` is
+ * 650 KB beside a 5 KB `test.stdout.txt` saying the same thing, which is why a
+ * smaller text sibling wins over a large JSON one.
+ *
+ * The `../artifacts` barrel is this module's only public surface.
+ */
+import type { Freshness } from './freshness.js';
+/** One measured `.check/` file. Size and standing only — never contents. */
+export type ArtifactFile = {
+    /** Name within `.check/`, as an agent would type it: `lint.json`. */
+    file: string;
+    /** Absolute path, for a caller that does choose to open it. */
+    path: string;
+    bytes: number;
+    mtimeMs: number;
+    freshness: Freshness;
+};
+/**
+ * A slot's raw output: the file worth reading first, plus every other candidate
+ * found — so a caller can say what else is there instead of implying the chosen
+ * one is all of it.
+ */
+export type RawOutput = {
+    chosen: ArtifactFile;
+    candidates: ArtifactFile[];
+};
+/** Measure one `.check/` file, or `null` when it does not exist. */
+export declare function statArtifact(checkDir: string, file: string, windowStart: number | null): Promise<ArtifactFile | null>;
+/**
+ * Measure every file directly in `checkDir`, name-ordered so the render is
+ * byte-stable. Subdirectories and anything that vanishes mid-read drop out;
+ * an absent directory is `[]`, because "there is nothing there" is an answer.
+ *
+ * This is the fallback index. Normally the summary names what to look at and
+ * {@link resolveRawOutput} locates it, but when the summary cannot be parsed
+ * the directory itself is the only inventory that exists — and a reader that
+ * gave up there would leave an agent to run `ls` by hand, which is the
+ * unbounded read this module exists to prevent.
+ */
+export declare function listArtifacts(checkDir: string, windowStart: number | null): Promise<ArtifactFile[]>;
+/**
+ * Resolve a slot's raw output under `checkDir`, freshness-gating whatever it
+ * finds — a stale candidate is labelled, not dropped. `null` only when the slot
+ * genuinely wrote nothing.
+ */
+export declare function resolveRawOutput(checkDir: string, slot: string, outputFile: string | null, windowStart: number | null): Promise<RawOutput | null>;
+//# sourceMappingURL=raw.d.ts.map

package/node_modules/checkride/dist/artifacts/raw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw.d.ts","sourceRoot":"","sources":["../../src/artifacts/raw.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAGhD,4EAA4E;AAC5E,MAAM,MAAM,YAAY,GAAG;IACzB,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;CACtB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG;IAAE,MAAM,EAAE,YAAY,CAAC;IAAC,UAAU,EAAE,YAAY,EAAE,CAAA;CAAE,CAAC;AAE7E,oEAAoE;AACpE,wBAAsB,YAAY,CAChC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAAG,IAAI,GACzB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAS9B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAWzG;AAwBD;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,GAAG,IAAI,EACzB,WAAW,EAAE,MAAM,GAAG,IAAI,GACzB,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAO3B"}

package/node_modules/checkride/dist/artifacts/raw.js

@@ -0,0 +1,91 @@
+/**
+ * Locating a slot's raw output — the bytes the summary indexes but usually does
+ * not name.
+ *
+ * `output_file` is populated only when a tool emits JSON on stdout, so most
+ * slots carry `null` there while their real output sits in `.check/` under the
+ * documented convention (`<slot>.json`, else `<slot>.stdout.txt` /
+ * `<slot>.stderr.txt`). On a full run of this repo, 8 of 17 checks name no file
+ * — `test` among them, the slot most likely to need triage. A reader that
+ * reported "no output" for those would be wrong about the one thing it exists
+ * to get right, so it owns the convention as a fallback.
+ *
+ * Everything found is measured, never opened: the readers report *sizes* and
+ * point at the file. `mutation.json` in this repo is 2.3 MB; `test.json` is
+ * 650 KB beside a 5 KB `test.stdout.txt` saying the same thing, which is why a
+ * smaller text sibling wins over a large JSON one.
+ *
+ * The `../artifacts` barrel is this module's only public surface.
+ */
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { classifyFreshness } from './freshness.js';
+/** Measure one `.check/` file, or `null` when it does not exist. */
+export async function statArtifact(checkDir, file, windowStart) {
+    const path = join(checkDir, file);
+    try {
+        const stats = await stat(path);
+        if (!stats.isFile())
+            return null;
+        return { file, path, bytes: stats.size, mtimeMs: stats.mtimeMs, freshness: classifyFreshness(stats.mtimeMs, windowStart) };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Measure every file directly in `checkDir`, name-ordered so the render is
+ * byte-stable. Subdirectories and anything that vanishes mid-read drop out;
+ * an absent directory is `[]`, because "there is nothing there" is an answer.
+ *
+ * This is the fallback index. Normally the summary names what to look at and
+ * {@link resolveRawOutput} locates it, but when the summary cannot be parsed
+ * the directory itself is the only inventory that exists — and a reader that
+ * gave up there would leave an agent to run `ls` by hand, which is the
+ * unbounded read this module exists to prevent.
+ */
+export async function listArtifacts(checkDir, windowStart) {
+    let names;
+    try {
+        names = await readdir(checkDir);
+    }
+    catch {
+        return [];
+    }
+    const found = await Promise.all(names.toSorted().map((name) => statArtifact(checkDir, name, windowStart)));
+    return found.filter((file) => file !== null);
+}
+/**
+ * The convention, in priority order: what the summary named, then the JSON file,
+ * then the captured streams. Deduped, because `output_file` is usually
+ * `<slot>.json` when it is set at all.
+ */
+function candidateNames(slot, outputFile) {
+    const names = [outputFile, `${slot}.json`, `${slot}.stdout.txt`, `${slot}.stderr.txt`];
+    return [...new Set(names.filter((name) => name !== null))];
+}
+/**
+ * Pick what to read first. The convention order wins, except that a *smaller*
+ * text sibling beats a large JSON file: `test.stdout.txt` (5 KB) carries the
+ * same failure `test.json` (650 KB) does, and a reader that sends an agent to
+ * the big one has spent the context it was built to save. A text file that is
+ * already first stays first — stdout is the diagnostics, stderr the leftovers.
+ */
+function chooseRaw(first, rest) {
+    if (first.file.endsWith('.txt'))
+        return first;
+    return rest.find((c) => c.file.endsWith('.txt') && c.bytes < first.bytes) ?? first;
+}
+/**
+ * Resolve a slot's raw output under `checkDir`, freshness-gating whatever it
+ * finds — a stale candidate is labelled, not dropped. `null` only when the slot
+ * genuinely wrote nothing.
+ */
+export async function resolveRawOutput(checkDir, slot, outputFile, windowStart) {
+    const found = await Promise.all(candidateNames(slot, outputFile).map((name) => statArtifact(checkDir, name, windowStart)));
+    const [first, ...rest] = found.filter((c) => c !== null);
+    if (first === undefined)
+        return null;
+    return { chosen: chooseRaw(first, rest), candidates: [first, ...rest] };
+}
+//# sourceMappingURL=raw.js.map

package/node_modules/checkride/dist/artifacts/raw.js.map

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

package/node_modules/checkride/dist/artifacts/summary.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The `.check/summary.json` read — the one place either reader parses it.
+ *
+ * The summary is checkride's promised index: `schema_version`-ed, additive-only,
+ * deterministically ordered and crash-consistent. This module turns it into a
+ * five-state result rather than a value-or-throw, because every failure mode is
+ * something a reader has to *report* — a missing summary means the gate never
+ * wrote one, and a `schema_version` this reader does not understand means stop,
+ * not guess.
+ *
+ * `foreign` and `schema-mismatch` are deliberately separate states even though
+ * both end in "this reader cannot use the file". An absent `schema_version` is
+ * evidence the file was not written by checkride at all — a repo whose gate is
+ * a homegrown script that happens to write `.check/` — and the honest report
+ * there is "your gate is not checkride", not "STOP, version boundary". A
+ * `schema_version` of 2 is the opposite case: checkride wrote it, and a newer
+ * one, so guessing across the boundary is what has to stop.
+ *
+ * Validation here is deliberately structural, not schematic: the full JSON
+ * Schema lives in `schema/checkride.summary.schema.json` and is the engine's
+ * job. All this needs is enough narrowing that the fields the readers touch are
+ * the types they claim to be, with no cast onto unvalidated bytes.
+ *
+ * The `../artifacts` barrel is this module's only public surface.
+ */
+import type { Summary } from '../orchestrator.js';
+/** The gitignored directory every run writes its artifacts into. */
+export declare const CHECK_DIR = ".check";
+/**
+ * The only `schema_version` these readers understand.
+ *
+ * Deliberately a literal, not the engine's `SCHEMA_VERSION` import: the
+ * additive-only guarantee holds *within* a version and promises nothing across
+ * one, so a bump has to stop the reader loudly rather than be silently
+ * followed. `artifacts.test.ts` asserts this equals the engine's constant, so a
+ * future bump turns a test red — a deliberate update, never a quiet change of
+ * behavior.
+ */
+export declare const SUPPORTED_SCHEMA_VERSION = 1;
+/** The outcome of reading `.check/summary.json`. Every state is reportable. */
+export type SummaryRead = {
+    state: 'ok';
+    path: string;
+    mtimeMs: number;
+    summary: Summary;
+}
+/** A JSON object with no `schema_version` at all — not checkride's file. */
+ | {
+    state: 'foreign';
+    path: string;
+    mtimeMs: number;
+} | {
+    state: 'schema-mismatch';
+    path: string;
+    mtimeMs: number;
+    found: unknown;
+} | {
+    state: 'unreadable';
+    path: string;
+    detail: string;
+} | {
+    state: 'missing';
+    path: string;
+};
+/** Classify already-read bytes. Split out so tests can drive every state. */
+export declare function parseSummary(raw: string, path: string, mtimeMs: number): SummaryRead;
+/** Read and classify `<cwd>/.check/summary.json`. Never throws. */
+export declare function readSummary(cwd: string): Promise<SummaryRead>;
+//# sourceMappingURL=summary.d.ts.map

package/node_modules/checkride/dist/artifacts/summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summary.d.ts","sourceRoot":"","sources":["../../src/artifacts/summary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAKH,OAAO,KAAK,EAAE,OAAO,EAAgB,MAAM,oBAAoB,CAAC;AAIhE,oEAAoE;AACpE,eAAO,MAAM,SAAS,WAAW,CAAC;AAKlC;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,+EAA+E;AAC/E,MAAM,MAAM,WAAW,GACnB;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE;AAClE,4EAA4E;GAC1E;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACnD;IAAE,KAAK,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAC3E;IAAE,KAAK,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AA8CvC,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,CAcpF;AAED,mEAAmE;AACnE,wBAAsB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAQnE"}

package/node_modules/checkride/dist/artifacts/summary.js

@@ -0,0 +1,108 @@
+/**
+ * The `.check/summary.json` read — the one place either reader parses it.
+ *
+ * The summary is checkride's promised index: `schema_version`-ed, additive-only,
+ * deterministically ordered and crash-consistent. This module turns it into a
+ * five-state result rather than a value-or-throw, because every failure mode is
+ * something a reader has to *report* — a missing summary means the gate never
+ * wrote one, and a `schema_version` this reader does not understand means stop,
+ * not guess.
+ *
+ * `foreign` and `schema-mismatch` are deliberately separate states even though
+ * both end in "this reader cannot use the file". An absent `schema_version` is
+ * evidence the file was not written by checkride at all — a repo whose gate is
+ * a homegrown script that happens to write `.check/` — and the honest report
+ * there is "your gate is not checkride", not "STOP, version boundary". A
+ * `schema_version` of 2 is the opposite case: checkride wrote it, and a newer
+ * one, so guessing across the boundary is what has to stop.
+ *
+ * Validation here is deliberately structural, not schematic: the full JSON
+ * Schema lives in `schema/checkride.summary.schema.json` and is the engine's
+ * job. All this needs is enough narrowing that the fields the readers touch are
+ * the types they claim to be, with no cast onto unvalidated bytes.
+ *
+ * The `../artifacts` barrel is this module's only public surface.
+ */
+import { readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isRecord, parseJson } from './json.js';
+/** The gitignored directory every run writes its artifacts into. */
+export const CHECK_DIR = '.check';
+/** The aggregate report, beside the raw artifacts under {@link CHECK_DIR}. */
+const SUMMARY_FILE = 'summary.json';
+/**
+ * The only `schema_version` these readers understand.
+ *
+ * Deliberately a literal, not the engine's `SCHEMA_VERSION` import: the
+ * additive-only guarantee holds *within* a version and promises nothing across
+ * one, so a bump has to stop the reader loudly rather than be silently
+ * followed. `artifacts.test.ts` asserts this equals the engine's constant, so a
+ * future bump turns a test red — a deliberate update, never a quiet change of
+ * behavior.
+ */
+export const SUPPORTED_SCHEMA_VERSION = 1;
+/**
+ * Name, adapter and description are present and the right type. Bracket access
+ * throughout: these are unvalidated bytes, and reading them as a dynamic record
+ * is what they are.
+ */
+function hasCheckIdentity(value) {
+    return (typeof value['name'] === 'string' &&
+        typeof value['description'] === 'string' &&
+        (typeof value['adapter'] === 'string' || value['adapter'] === null));
+}
+/** The result fields the readers render are present and the right type. */
+function hasCheckOutcome(value) {
+    return (typeof value['ok'] === 'boolean' &&
+        typeof value['duration_ms'] === 'number' &&
+        (typeof value['exit_code'] === 'number' || value['exit_code'] === null) &&
+        (typeof value['output_file'] === 'string' || value['output_file'] === null));
+}
+/**
+ * One `checks[]` entry. The optional additive fields (`skipped`, `reason`,
+ * `baselined`) are read through `??` at the point of use, so they need no guard.
+ */
+function isCheck(value) {
+    return isRecord(value) && hasCheckIdentity(value) && hasCheckOutcome(value);
+}
+/** Every required top-level field, and a well-formed `checks[]`. */
+function isSummary(value) {
+    const checks = value['checks'];
+    return (typeof value['timestamp'] === 'string' &&
+        typeof value['ok'] === 'boolean' &&
+        typeof value['checks_run'] === 'number' &&
+        typeof value['total_duration_ms'] === 'number' &&
+        Array.isArray(checks) &&
+        checks.every(isCheck));
+}
+/** Classify already-read bytes. Split out so tests can drive every state. */
+export function parseSummary(raw, path, mtimeMs) {
+    const value = parseJson(raw);
+    if (!isRecord(value))
+        return { state: 'unreadable', path, detail: 'not a JSON object' };
+    // Provenance first, then version: a summary this reader cannot read is a
+    // whose-file-is-this problem or a version problem, not a shape problem, even
+    // when its other fields also fail to narrow. Key presence rather than value,
+    // so an explicit `"schema_version": null` stays a mismatch — a malformed
+    // checkride summary — instead of being read as a stranger's file.
+    if (!('schema_version' in value))
+        return { state: 'foreign', path, mtimeMs };
+    if (value['schema_version'] !== SUPPORTED_SCHEMA_VERSION) {
+        return { state: 'schema-mismatch', path, mtimeMs, found: value['schema_version'] };
+    }
+    if (!isSummary(value))
+        return { state: 'unreadable', path, detail: 'missing or mistyped required field(s)' };
+    return { state: 'ok', path, mtimeMs, summary: value };
+}
+/** Read and classify `<cwd>/.check/summary.json`. Never throws. */
+export async function readSummary(cwd) {
+    const path = join(cwd, CHECK_DIR, SUMMARY_FILE);
+    try {
+        const [stats, raw] = await Promise.all([stat(path), readFile(path, 'utf8')]);
+        return parseSummary(raw, path, stats.mtimeMs);
+    }
+    catch {
+        return { state: 'missing', path };
+    }
+}
+//# sourceMappingURL=summary.js.map

package/node_modules/checkride/dist/artifacts/summary.js.map

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

package/node_modules/checkride/dist/atomic.d.ts

@@ -8,6 +8,21 @@
  * version or the new complete version — `rename(2)` is atomic within a
  * directory — never torn.
  */
-/** Write `data` to `path` atomically: temp sibling first, then rename over. */
+/**
+ * Write `data` to `path` atomically: temp sibling, flushed to disk, then
+ * renamed over.
+ *
+ * The `fsync` before the rename is what makes the promise above true rather
+ * than nearly true. `rename(2)` is atomic for the *name*, but a write that is
+ * still sitting in the page cache when the machine loses power can leave the
+ * renamed inode holding nothing — the reader then finds a file that exists and
+ * is empty, which is the torn read this exists to prevent, just relocated.
+ *
+ * The containing directory is deliberately not synced. Without that, the
+ * rename itself may not survive a crash — but the reader then sees the
+ * *previous complete version*, which is exactly what is promised. Paying a
+ * second fsync per artifact to also guarantee which of the two you get is not
+ * worth it for a report that the next run rewrites anyway.
+ */
 export declare function writeFileAtomic(path: string, data: string): Promise<void>;
 //# sourceMappingURL=atomic.d.ts.map

package/node_modules/checkride/dist/atomic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atomic.d.ts","sourceRoot":"","sources":["../src/atomic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,+EAA+E;AAC/E,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAS/E"}
+{"version":3,"file":"atomic.d.ts","sourceRoot":"","sources":["../src/atomic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAe/E"}

package/node_modules/checkride/dist/atomic.js

@@ -8,12 +8,34 @@
  * version or the new complete version — `rename(2)` is atomic within a
  * directory — never torn.
  */
-import { rename, rm, writeFile } from 'node:fs/promises';
-/** Write `data` to `path` atomically: temp sibling first, then rename over. */
+import { open, rename, rm } from 'node:fs/promises';
+/**
+ * Write `data` to `path` atomically: temp sibling, flushed to disk, then
+ * renamed over.
+ *
+ * The `fsync` before the rename is what makes the promise above true rather
+ * than nearly true. `rename(2)` is atomic for the *name*, but a write that is
+ * still sitting in the page cache when the machine loses power can leave the
+ * renamed inode holding nothing — the reader then finds a file that exists and
+ * is empty, which is the torn read this exists to prevent, just relocated.
+ *
+ * The containing directory is deliberately not synced. Without that, the
+ * rename itself may not survive a crash — but the reader then sees the
+ * *previous complete version*, which is exactly what is promised. Paying a
+ * second fsync per artifact to also guarantee which of the two you get is not
+ * worth it for a report that the next run rewrites anyway.
+ */
 export async function writeFileAtomic(path, data) {
     const tmp = `${path}.${process.pid}.tmp`;
     try {
-        await writeFile(tmp, data);
+        const handle = await open(tmp, 'w');
+        try {
+            await handle.writeFile(data);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
         await rename(tmp, path);
     }
     catch (err) {

package/node_modules/checkride/dist/atomic.js.map

@@ -1 +1 @@
-{"version":3,"file":"atomic.js","sourceRoot":"","sources":["../src/atomic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEzD,+EAA+E;AAC/E,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,IAAY,EAAE,IAAY;IAC9D,MAAM,GAAG,GAAG,GAAG,IAAI,IAAI,OAAO,CAAC,GAAG,MAAM,CAAC;IACzC,IAAI,CAAC;QACH,MAAM,SAAS,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAC3B,MAAM,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAC1B,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QAC/B,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC"}
+{"version":3,"file":"atomic.js","sourceRoot":"","sources":["../src/atomic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,IAAY,EAAE,IAAY;IAC9D,MAAM,GAAG,GAAG,GAAG,IAAI,IAAI,OAAO,CAAC,GAAG,MAAM,CAAC;IACzC,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;QACpC,IAAI,CAAC;YACH,MAAM,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YAC7B,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;QACtB,CAAC;gBAAS,CAAC;YACT,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;QACvB,CAAC;QACD,MAAM,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAC1B,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QAC/B,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC"}