plumbbob 0.9.3 → 0.10.0

package/node_modules/checkride/dist/tool-json.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Tolerant parsing of a tool's stdout as JSON.
+ *
+ * A tool that emits JSON does not always get stdout to itself: any launcher,
+ * wrapper or shell profile can print before it does. checkride suppresses the
+ * one case it controls at the invocation (pnpm's dependency-check narration —
+ * see `translateExec` and `docs/tools.md` §Launcher quirks), but a consumer's
+ * launcher is not checkride's to pin, so the read tolerates a preamble too.
+ *
+ * **Skipping a preamble is not normalizing.** The tool's own bytes are returned
+ * verbatim from the first character of the JSON onward — nothing inside them is
+ * rewritten, reordered or reformatted, and what gets dropped was never the
+ * tool's output to begin with. That is what keeps this compatible with "the raw
+ * file is the truth" (`docs/contract.md`), which is a promise, not a detail.
+ */
+/** A tool's stdout parsed as JSON: the value, and the exact text it came from. */
+export type ToolJson = {
+    /** The parsed value. */
+    value: unknown;
+    /**
+     * The JSON text with any preamble removed — what belongs in
+     * `.check/<slot>.json`, so the artifact a consumer opens actually parses.
+     */
+    text: string;
+};
+/**
+ * Parse `raw` as JSON, tolerating up to {@link MAX_PREAMBLE_LINES} lines of
+ * non-JSON ahead of it. Clean output takes the fast path and is returned byte
+ * for byte. Returns `null` when nothing parses — every caller treats that as a
+ * loud failure, never as "clean".
+ */
+export declare function parseToolJson(raw: string): ToolJson | null;
+//# sourceMappingURL=tool-json.d.ts.map

package/node_modules/checkride/dist/tool-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-json.d.ts","sourceRoot":"","sources":["../src/tool-json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,kFAAkF;AAClF,MAAM,MAAM,QAAQ,GAAG;IACrB,wBAAwB;IACxB,KAAK,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAYF;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAgB1D"}

package/node_modules/checkride/dist/tool-json.js

@@ -0,0 +1,58 @@
+/**
+ * Tolerant parsing of a tool's stdout as JSON.
+ *
+ * A tool that emits JSON does not always get stdout to itself: any launcher,
+ * wrapper or shell profile can print before it does. checkride suppresses the
+ * one case it controls at the invocation (pnpm's dependency-check narration —
+ * see `translateExec` and `docs/tools.md` §Launcher quirks), but a consumer's
+ * launcher is not checkride's to pin, so the read tolerates a preamble too.
+ *
+ * **Skipping a preamble is not normalizing.** The tool's own bytes are returned
+ * verbatim from the first character of the JSON onward — nothing inside them is
+ * rewritten, reordered or reformatted, and what gets dropped was never the
+ * tool's output to begin with. That is what keeps this compatible with "the raw
+ * file is the truth" (`docs/contract.md`), which is a promise, not a detail.
+ */
+/**
+ * How many leading lines may precede the JSON before parsing gives up. Real
+ * preambles are one or two lines; the cap keeps a large non-JSON payload (a 650
+ * kB test log, say) from costing one parse attempt per line.
+ */
+const MAX_PREAMBLE_LINES = 10;
+/** Parse `text` as JSON, or `undefined` when it is not JSON at all. */
+function tryParse(text) {
+    if (text.trim() === '')
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Parse `raw` as JSON, tolerating up to {@link MAX_PREAMBLE_LINES} lines of
+ * non-JSON ahead of it. Clean output takes the fast path and is returned byte
+ * for byte. Returns `null` when nothing parses — every caller treats that as a
+ * loud failure, never as "clean".
+ */
+export function parseToolJson(raw) {
+    const whole = tryParse(raw);
+    if (whole !== undefined)
+        return { value: whole, text: raw };
+    // Retry from each subsequent line start. The tool's JSON begins at a line
+    // boundary because the preamble that precedes it ended with a newline.
+    let offset = 0;
+    for (let line = 0; line < MAX_PREAMBLE_LINES; line++) {
+        const newline = raw.indexOf('\n', offset);
+        if (newline === -1)
+            break;
+        offset = newline + 1;
+        const rest = raw.slice(offset);
+        const value = tryParse(rest);
+        if (value !== undefined)
+            return { value, text: rest };
+    }
+    return null;
+}
+//# sourceMappingURL=tool-json.js.map

package/node_modules/checkride/dist/tool-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-json.js","sourceRoot":"","sources":["../src/tool-json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;GAIG;AACH,MAAM,kBAAkB,GAAG,EAAE,CAAC;AAa9B,uEAAuE;AACvE,SAAS,QAAQ,CAAC,IAAY;IAC5B,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE;QAAE,OAAO,SAAS,CAAC;IACzC,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAY,CAAC;IACrC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,GAAW;IACvC,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;IAC5B,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;IAE5D,0EAA0E;IAC1E,uEAAuE;IACvE,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,kBAAkB,EAAE,IAAI,EAAE,EAAE,CAAC;QACrD,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC1C,IAAI,OAAO,KAAK,CAAC,CAAC;YAAE,MAAM;QAC1B,MAAM,GAAG,OAAO,GAAG,CAAC,CAAC;QACrB,MAAM,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC/B,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC7B,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IACxD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/node_modules/checkride/dist/triage/cli.d.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+/**
+ * Executable form of the triage reader — what the bundled `/checkride:check`
+ * skill invokes:
+ *
+ * ```
+ * node <plugin-root>/dist/triage/cli.js [cwd]
+ * ```
+ *
+ * It ships in the package's existing `dist/`, so both the published tarball and
+ * an installed plugin cache already carry it and no consumer build step exists.
+ * It adds no CLI command, flag or config to checkride itself: `dist/cli.js`
+ * knows nothing about this file.
+ *
+ * Exit code 0 means *a report was rendered*, however the gate came back — the
+ * gate's verdict is in the Markdown, not in this process's status, so a red repo
+ * does not look to the caller like a broken reader. Only a failure to produce a
+ * report at all exits non-zero.
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/node_modules/checkride/dist/triage/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/triage/cli.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;GAiBG"}

package/node_modules/checkride/dist/triage/cli.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+/**
+ * Executable form of the triage reader — what the bundled `/checkride:check`
+ * skill invokes:
+ *
+ * ```
+ * node <plugin-root>/dist/triage/cli.js [cwd]
+ * ```
+ *
+ * It ships in the package's existing `dist/`, so both the published tarball and
+ * an installed plugin cache already carry it and no consumer build step exists.
+ * It adds no CLI command, flag or config to checkride itself: `dist/cli.js`
+ * knows nothing about this file.
+ *
+ * Exit code 0 means *a report was rendered*, however the gate came back — the
+ * gate's verdict is in the Markdown, not in this process's status, so a red repo
+ * does not look to the caller like a broken reader. Only a failure to produce a
+ * report at all exits non-zero.
+ */
+import { realEnv } from './env.js';
+import { renderTriage } from './render.js';
+import { triage } from './triage.js';
+const [, , cwdArg] = process.argv;
+const report = await triage(cwdArg ?? process.cwd(), realEnv);
+process.stdout.write(`${renderTriage(report)}\n`);
+//# sourceMappingURL=cli.js.map

package/node_modules/checkride/dist/triage/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/triage/cli.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,CAAC,EAAE,AAAD,EAAG,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;AAClC,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,MAAM,IAAI,OAAO,CAAC,GAAG,EAAE,EAAE,OAAO,CAAC,CAAC;AAC9D,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC"}

package/node_modules/checkride/dist/triage/doctor-fold.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Folding `checkride doctor` into the broken-harness branch.
+ *
+ * Exit 2 means the harness broke or was misused, and every check result from
+ * that run is untrustworthy. "Broken harness" on its own costs a round-trip:
+ * the agent has to go ask what broke. `doctor` already answers that — it is
+ * read-only, runs no checks, and splits 0/1 the same way — so triage runs it at
+ * the one moment it is the right answer and arrives with the diagnosis attached.
+ *
+ * It is spawned as `node <repo's checkride>/dist/cli.js doctor --json`, not
+ * through the package manager: `<pm> exec` can print its own noise onto stdout,
+ * and the JSON report is the thing being parsed. It is also deliberately the
+ * *repo's* installed checkride rather than the one this reader ships inside —
+ * diagnosing an environment with a different version's doctor is how a reader
+ * reports a problem the repo does not have.
+ */
+import type { TriageEnv } from './env.js';
+/** One required doctor row that is not ok — an environment problem to fix. */
+export type DoctorFinding = {
+    name: string;
+    status: string;
+    found: string | null;
+    expected: string | null;
+    hint: string | null;
+};
+/** What the fold-in produced. Every state is reportable; none is an error. */
+export type DoctorFold = {
+    state: 'ran';
+    ok: boolean;
+    exitCode: number | null;
+    findings: DoctorFinding[];
+} | {
+    state: 'unavailable';
+    reason: string;
+} | {
+    state: 'unreadable';
+    reason: string;
+};
+/**
+ * The checkride CLI this repo would run: its installed copy, or its own build
+ * when `cwd` *is* the checkride package (the dogfooding case). Never some other
+ * repo's `dist/cli.js` — the package name has to say so.
+ */
+export declare function resolveCheckrideCli(cwd: string): string | null;
+/**
+ * Run the repo's `checkride doctor --json` and extract what is broken. Never
+ * throws; an absent or unparseable doctor is reported as such so the report can
+ * say "the harness broke and I could not ask why" instead of inventing a cause.
+ */
+export declare function foldDoctor(cwd: string, env: TriageEnv): Promise<DoctorFold>;
+//# sourceMappingURL=doctor-fold.d.ts.map

package/node_modules/checkride/dist/triage/doctor-fold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-fold.d.ts","sourceRoot":"","sources":["../../src/triage/doctor-fold.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C,8EAA8E;AAC9E,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB,CAAC;AAEF,8EAA8E;AAC9E,MAAM,MAAM,UAAU,GAClB;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,EAAE,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,EAAE,aAAa,EAAE,CAAA;CAAE,GACjF;IAAE,KAAK,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,KAAK,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAe5C;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAM9D;AAwBD;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAUjF"}

package/node_modules/checkride/dist/triage/doctor-fold.js

@@ -0,0 +1,88 @@
+/**
+ * Folding `checkride doctor` into the broken-harness branch.
+ *
+ * Exit 2 means the harness broke or was misused, and every check result from
+ * that run is untrustworthy. "Broken harness" on its own costs a round-trip:
+ * the agent has to go ask what broke. `doctor` already answers that — it is
+ * read-only, runs no checks, and splits 0/1 the same way — so triage runs it at
+ * the one moment it is the right answer and arrives with the diagnosis attached.
+ *
+ * It is spawned as `node <repo's checkride>/dist/cli.js doctor --json`, not
+ * through the package manager: `<pm> exec` can print its own noise onto stdout,
+ * and the JSON report is the thing being parsed. It is also deliberately the
+ * *repo's* installed checkride rather than the one this reader ships inside —
+ * diagnosing an environment with a different version's doctor is how a reader
+ * reports a problem the repo does not have.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { asStringOrNull, isRecord, parseJson } from '../artifacts/index.js';
+/** A doctor probe is a read; it should never be the thing that hangs a triage. */
+const DOCTOR_TIMEOUT_MS = 120_000;
+/** Read a package.json `name` field, or `null` when it cannot be read. */
+function packageName(cwd) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf8'));
+        return pkg.name ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The checkride CLI this repo would run: its installed copy, or its own build
+ * when `cwd` *is* the checkride package (the dogfooding case). Never some other
+ * repo's `dist/cli.js` — the package name has to say so.
+ */
+export function resolveCheckrideCli(cwd) {
+    const installed = join(cwd, 'node_modules', 'checkride', 'dist', 'cli.js');
+    if (existsSync(installed))
+        return installed;
+    const own = join(cwd, 'dist', 'cli.js');
+    if (packageName(cwd) === 'checkride' && existsSync(own))
+        return own;
+    return null;
+}
+/** Narrow one `checks[]` row to a finding, or `null` when it is not a problem. */
+function toFinding(value) {
+    if (!isRecord(value))
+        return null;
+    if (value['required'] !== true || value['status'] === 'ok')
+        return null;
+    return {
+        name: asStringOrNull(value['name']) ?? 'unnamed check',
+        status: asStringOrNull(value['status']) ?? 'unknown',
+        found: asStringOrNull(value['found']),
+        expected: asStringOrNull(value['expected']),
+        hint: asStringOrNull(value['hint']),
+    };
+}
+/** Pull the required-and-not-ok rows out of a `doctor --json` report. */
+function readFindings(stdout) {
+    const report = parseJson(stdout);
+    if (!isRecord(report))
+        return null;
+    const checks = report['checks'];
+    if (!Array.isArray(checks))
+        return null;
+    return checks.map(toFinding).filter((f) => f !== null);
+}
+/**
+ * Run the repo's `checkride doctor --json` and extract what is broken. Never
+ * throws; an absent or unparseable doctor is reported as such so the report can
+ * say "the harness broke and I could not ask why" instead of inventing a cause.
+ */
+export async function foldDoctor(cwd, env) {
+    const cli = resolveCheckrideCli(cwd);
+    if (cli === null) {
+        return { state: 'unavailable', reason: 'checkride is not installed in this repo (no node_modules/checkride)' };
+    }
+    const outcome = await env.spawn(process.execPath, [cli, 'doctor', '--json'], { cwd, timeoutMs: DOCTOR_TIMEOUT_MS });
+    if (outcome.error !== null)
+        return { state: 'unreadable', reason: `could not run doctor: ${outcome.error}` };
+    const findings = readFindings(outcome.stdout);
+    if (findings === null)
+        return { state: 'unreadable', reason: 'doctor --json did not produce a readable report' };
+    return { state: 'ran', ok: outcome.code === 0, exitCode: outcome.code, findings };
+}
+//# sourceMappingURL=doctor-fold.js.map

package/node_modules/checkride/dist/triage/doctor-fold.js.map

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

package/node_modules/checkride/dist/triage/env.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The triage reader's process surface: spawning, and the clock.
+ *
+ * Both are injectable because the reader's hardest guarantees are about
+ * *failure* — it must survive a red gate, a broken harness, a missing binary
+ * and a hung run without dying itself, and none of those are reachable from a
+ * test that has to spawn a real toolchain to get there.
+ *
+ * {@link spawnCapture} never rejects. A reader that throws on a red gate would
+ * fail exactly when it is needed, so a spawn failure is a *value* — an outcome
+ * with `error` set — not an exception.
+ */
+/**
+ * A finished (or failed) child process. `code` is `null` when the process died
+ * by signal or never started; `error` is set only in the latter case.
+ */
+export type SpawnOutcome = {
+    code: number | null;
+    signal: string | null;
+    stdout: string;
+    stderr: string;
+    /** The spawn error message when the process could not start at all. */
+    error: string | null;
+};
+/** Run a command and capture it. The one process touch the reader makes. */
+export type Spawner = (command: string, args: readonly string[], opts: {
+    cwd: string;
+    timeoutMs: number;
+}) => Promise<SpawnOutcome>;
+/** Everything the reader needs from the outside world. */
+export type TriageEnv = {
+    spawn: Spawner;
+    now: () => number;
+    /** Budget for the gate run. A hung check must not hang the agent waiting on it. */
+    timeoutMs: number;
+};
+/**
+ * Spawn `command`, capture both streams, and resolve however it ends. Never rejects.
+ *
+ * `detached`, so the child leads its own process group and the timeout can
+ * reap the whole tree. The gate is `<pm> run check`, which means the process
+ * actually doing the work is a *grandchild* — a bare `proc.kill()` signals the
+ * package-manager wrapper and leaves the checks themselves running, which both
+ * defeats the budget and can hold this promise open forever, since `close`
+ * waits on every inherited pipe. `killGroupEscalating` signals the group and
+ * insists with SIGKILL after the grace (see `../proc.ts`).
+ */
+export declare function spawnCapture(command: string, args: readonly string[], opts: {
+    cwd: string;
+    timeoutMs: number;
+}): Promise<SpawnOutcome>;
+/** The real process surface. */
+export declare const realEnv: TriageEnv;
+//# sourceMappingURL=env.d.ts.map

package/node_modules/checkride/dist/triage/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/triage/env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAMH;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,uEAAuE;IACvE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF,4EAA4E;AAC5E,MAAM,MAAM,OAAO,GAAG,CACpB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,KACrC,OAAO,CAAC,YAAY,CAAC,CAAC;AAE3B,0DAA0D;AAC1D,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,mFAAmF;IACnF,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoBF;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACvC,OAAO,CAAC,YAAY,CAAC,CA+BvB;AAED,gCAAgC;AAChC,eAAO,MAAM,OAAO,EAAE,SAIrB,CAAC"}

package/node_modules/checkride/dist/triage/env.js

@@ -0,0 +1,81 @@
+/**
+ * The triage reader's process surface: spawning, and the clock.
+ *
+ * Both are injectable because the reader's hardest guarantees are about
+ * *failure* — it must survive a red gate, a broken harness, a missing binary
+ * and a hung run without dying itself, and none of those are reachable from a
+ * test that has to spawn a real toolchain to get there.
+ *
+ * {@link spawnCapture} never rejects. A reader that throws on a red gate would
+ * fail exactly when it is needed, so a spawn failure is a *value* — an outcome
+ * with `error` set — not an exception.
+ */
+import { spawn } from 'node:child_process';
+import { killGroupEscalating } from '../proc.js';
+/**
+ * A full gate can legitimately take minutes (mutation testing, a cold build),
+ * so the ceiling is generous: it exists to break a hang, not to police a slow
+ * repo. checkride's own per-check timeouts fire long before this does.
+ */
+const DEFAULT_GATE_TIMEOUT_MS = 20 * 60 * 1000;
+/**
+ * Keep the tail of each stream. The reader only ever renders an excerpt, and a
+ * runaway tool must not be able to exhaust memory before the run even ends.
+ */
+const MAX_CAPTURE_CHARS = 256 * 1024;
+function appendCapped(buffer, chunk) {
+    const next = buffer + chunk;
+    return next.length > MAX_CAPTURE_CHARS ? next.slice(next.length - MAX_CAPTURE_CHARS) : next;
+}
+/**
+ * Spawn `command`, capture both streams, and resolve however it ends. Never rejects.
+ *
+ * `detached`, so the child leads its own process group and the timeout can
+ * reap the whole tree. The gate is `<pm> run check`, which means the process
+ * actually doing the work is a *grandchild* — a bare `proc.kill()` signals the
+ * package-manager wrapper and leaves the checks themselves running, which both
+ * defeats the budget and can hold this promise open forever, since `close`
+ * waits on every inherited pipe. `killGroupEscalating` signals the group and
+ * insists with SIGKILL after the grace (see `../proc.ts`).
+ */
+export function spawnCapture(command, args, opts) {
+    return new Promise((resolve) => {
+        const proc = spawn(command, [...args], {
+            cwd: opts.cwd,
+            detached: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1' },
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        let escalation = null;
+        const timer = setTimeout(() => { escalation = killGroupEscalating(proc.pid); }, opts.timeoutMs);
+        const settle = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            // A pending SIGKILL timer would hold the event loop open past the run.
+            if (escalation !== null)
+                clearTimeout(escalation);
+            resolve(outcome);
+        };
+        // Decoded string streams: the internal StringDecoder holds a partial
+        // multibyte sequence until its continuation bytes arrive, so `+=` never
+        // concatenates half a character.
+        proc.stdout.setEncoding('utf8');
+        proc.stderr.setEncoding('utf8');
+        proc.stdout.on('data', (chunk) => { stdout = appendCapped(stdout, chunk); });
+        proc.stderr.on('data', (chunk) => { stderr = appendCapped(stderr, chunk); });
+        proc.on('error', (err) => { settle({ code: null, signal: null, stdout, stderr, error: err.message }); });
+        proc.on('close', (code, signal) => { settle({ code, signal, stdout, stderr, error: null }); });
+    });
+}
+/** The real process surface. */
+export const realEnv = {
+    spawn: spawnCapture,
+    now: () => Date.now(),
+    timeoutMs: DEFAULT_GATE_TIMEOUT_MS,
+};
+//# sourceMappingURL=env.js.map

package/node_modules/checkride/dist/triage/env.js.map

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

package/node_modules/checkride/dist/triage/gate.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Running the gate — the preflight every triage begins with.
+ *
+ * The reader runs the repo's *own* `check` script rather than `checkride`
+ * directly, because that script is the repo's definition of done and may carry
+ * deliberate `--only` / `--skip` / `--changed` that a direct invocation would
+ * bypass. It also means a pre-existing `summary.json` is never mistaken for
+ * evidence: every run overwrites it, so `ok: true` on disk can mean "three of
+ * seventeen slots passed fourteen minutes ago".
+ *
+ * checkride promises the 0/1/2 exit split, so the verdict branches on that
+ * before anything is read. Anything outside it — 127, a signal death, a wrapper
+ * command that failed before checkride ran — is `off-contract`, reported as
+ * itself rather than folded into one of the three.
+ *
+ * One exit *inside* the split still is not checkride's: a package manager that
+ * refuses to start the script — an `engines.node` pin the running Node does not
+ * satisfy, most often — exits 1, exactly as a red pipeline does. Left
+ * unclassified, the reader an agent is sent to by a red gate would confirm the
+ * red and point at slots that never ran. See `../pm/launch.ts`.
+ */
+import type { PackageManager } from '../pm/index.js';
+import type { TriageEnv } from './env.js';
+/** How the gate ended, in the reader's vocabulary. */
+export type GateVerdict = 'green' | 'red' | 'could-not-start' | 'harness-broken' | 'off-contract' | 'not-run';
+/** The gate run: what was executed, how it ended, and what it printed. */
+export type GateOutcome = {
+    verdict: GateVerdict;
+    /** The repo's `scripts.check`, verbatim — the definition of done. */
+    script: string | null;
+    /** The command line as run, for the report to quote. */
+    command: string;
+    pm: PackageManager;
+    exitCode: number | null;
+    signal: string | null;
+    startedMs: number;
+    durationMs: number;
+    stdout: string;
+    stderr: string;
+    spawnError: string | null;
+    /** Why the package manager never started the script, on the `could-not-start` verdict. */
+    refusal: string | null;
+    /** Selection flags found in the script text: it narrows the run on purpose. */
+    narrowingFlags: string[];
+};
+/**
+ * Run `<pm> run check` in `cwd` and classify the result. Never throws: a repo
+ * with no `check` script, a missing package manager and a gate that fails are
+ * all outcomes, because each is something the report has to say.
+ */
+export declare function runGate(cwd: string, env: TriageEnv): Promise<GateOutcome>;
+/**
+ * Whether this ending means the harness itself is suspect, not the code.
+ *
+ * `could-not-start` belongs here for the strongest version of that reason:
+ * nothing ran at all, so the environment is the entire finding and the slot
+ * table is not evidence of anything. It is also what folds `doctor` into the
+ * report, which is where the reader will find the Node the hook got.
+ */
+export declare function isHarnessProblem(verdict: GateVerdict): boolean;
+//# sourceMappingURL=gate.d.ts.map

package/node_modules/checkride/dist/triage/gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../src/triage/gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,KAAK,EAAgB,SAAS,EAAE,MAAM,UAAU,CAAC;AAExD,sDAAsD;AACtD,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,KAAK,GAAG,iBAAiB,GAAG,gBAAgB,GAAG,cAAc,GAAG,SAAS,CAAC;AAE9G,0EAA0E;AAC1E,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,WAAW,CAAC;IACrB,qEAAqE;IACrE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,cAAc,CAAC;IACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,0FAA0F;IAC1F,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,+EAA+E;IAC/E,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AA0DF;;;;GAIG;AACH,wBAAsB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,CA0B/E;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAE9D"}

package/node_modules/checkride/dist/triage/gate.js

@@ -0,0 +1,121 @@
+/**
+ * Running the gate — the preflight every triage begins with.
+ *
+ * The reader runs the repo's *own* `check` script rather than `checkride`
+ * directly, because that script is the repo's definition of done and may carry
+ * deliberate `--only` / `--skip` / `--changed` that a direct invocation would
+ * bypass. It also means a pre-existing `summary.json` is never mistaken for
+ * evidence: every run overwrites it, so `ok: true` on disk can mean "three of
+ * seventeen slots passed fourteen minutes ago".
+ *
+ * checkride promises the 0/1/2 exit split, so the verdict branches on that
+ * before anything is read. Anything outside it — 127, a signal death, a wrapper
+ * command that failed before checkride ran — is `off-contract`, reported as
+ * itself rather than folded into one of the three.
+ *
+ * One exit *inside* the split still is not checkride's: a package manager that
+ * refuses to start the script — an `engines.node` pin the running Node does not
+ * satisfy, most often — exits 1, exactly as a red pipeline does. Left
+ * unclassified, the reader an agent is sent to by a red gate would confirm the
+ * red and point at slots that never ran. See `../pm/launch.ts`.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { readSummary } from '../artifacts/index.js';
+import { detectPackageManager, launchRefusal } from '../pm/index.js';
+/** Script name every checkride repo exposes; `checkride init` writes it. */
+const CHECK_SCRIPT = 'check';
+/**
+ * Flags that make a green run cover less than the repo configures. Detected
+ * textually in the script, which is exact and needs no knowledge of the
+ * installed checkride's catalogue.
+ */
+const NARROWING_FLAGS = ['--only', '--skip', '--changed'];
+/** checkride's promised exit split. Everything else is off-contract. */
+const VERDICT_BY_CODE = { 0: 'green', 1: 'red', 2: 'harness-broken' };
+/** Read `scripts.check` from `cwd`'s package.json, or `null` when there is none. */
+function readCheckScript(cwd) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf8'));
+        return pkg.scripts?.[CHECK_SCRIPT] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Tolerance for a summary written moments before the gate's own clock reading —
+ * mirrors `MTIME_TOLERANCE_MS` in `./triage.ts`, where the same comparison
+ * decides whether the summary belongs to this run.
+ */
+const MTIME_TOLERANCE_MS = 1000;
+/**
+ * Did this run write a summary? Proof that the pipeline started, whatever its
+ * output happens to contain — the guard that keeps a check which merely
+ * *printed* a package-manager error code from being read as a refusal to launch.
+ */
+async function wroteSummary(cwd, startedMs) {
+    const read = await readSummary(cwd);
+    return read.state === 'ok' && read.mtimeMs >= startedMs - MTIME_TOLERANCE_MS;
+}
+/**
+ * Classify an exit-1 gate: a red pipeline, or a package manager that never
+ * started one. Only exit 1 is examined — 0 and 2 are checkride's own answers and
+ * mean the pipeline ran, and everything else is already `off-contract`.
+ */
+async function refusalFor(outcome, cwd, startedMs) {
+    if (outcome.code !== 1 || (await wroteSummary(cwd, startedMs)))
+        return null;
+    return launchRefusal(`${outcome.stdout}${outcome.stderr}`)?.cause ?? null;
+}
+function verdictFor(outcome, refusal) {
+    if (outcome.error !== null || outcome.code === null)
+        return 'off-contract';
+    if (refusal !== null)
+        return 'could-not-start';
+    return VERDICT_BY_CODE[outcome.code] ?? 'off-contract';
+}
+/**
+ * Run `<pm> run check` in `cwd` and classify the result. Never throws: a repo
+ * with no `check` script, a missing package manager and a gate that fails are
+ * all outcomes, because each is something the report has to say.
+ */
+export async function runGate(cwd, env) {
+    const pm = detectPackageManager({ cwd });
+    const script = readCheckScript(cwd);
+    const base = {
+        script,
+        command: `${pm} run ${CHECK_SCRIPT}`,
+        pm,
+        startedMs: env.now(),
+        narrowingFlags: NARROWING_FLAGS.filter((flag) => script?.includes(flag) ?? false),
+    };
+    if (script === null) {
+        return { ...base, verdict: 'not-run', exitCode: null, signal: null, durationMs: 0, stdout: '', stderr: '', spawnError: null, refusal: null };
+    }
+    const outcome = await env.spawn(pm, ['run', CHECK_SCRIPT], { cwd, timeoutMs: env.timeoutMs });
+    const refusal = await refusalFor(outcome, cwd, base.startedMs);
+    return {
+        ...base,
+        verdict: verdictFor(outcome, refusal),
+        exitCode: outcome.code,
+        signal: outcome.signal,
+        durationMs: env.now() - base.startedMs,
+        stdout: outcome.stdout,
+        stderr: outcome.stderr,
+        spawnError: outcome.error,
+        refusal,
+    };
+}
+/**
+ * Whether this ending means the harness itself is suspect, not the code.
+ *
+ * `could-not-start` belongs here for the strongest version of that reason:
+ * nothing ran at all, so the environment is the entire finding and the slot
+ * table is not evidence of anything. It is also what folds `doctor` into the
+ * report, which is where the reader will find the Node the hook got.
+ */
+export function isHarnessProblem(verdict) {
+    return verdict === 'harness-broken' || verdict === 'off-contract' || verdict === 'could-not-start';
+}
+//# sourceMappingURL=gate.js.map