plumbbob 0.9.3 → 0.9.5

package/node_modules/checkride/dist/agent-setup/scripts.js

@@ -0,0 +1,299 @@
+/**
+ * The hook scripts checkride generates into a consumer repo.
+ *
+ * checkride owns these files and overwrites them on every `agent-setup`/`init`,
+ * so consumer customization belongs beside them, never in them. That is also why
+ * the settings entry each harness gets is a stable one-liner invoking a script
+ * rather than the behavior inline: a refresh rewrites the script freely without
+ * ever clobbering an entry a human may have edited.
+ *
+ * **Every script here is one a harness's configuration could not express.** A
+ * generated file in someone's repo is a standing cost — reviewed, kept in sync,
+ * wondered about — so it is written only where config falls short. Claude Code
+ * takes just the gate: its `protect` is a `permissions.deny` rule and its
+ * `dirty` an inline command. Cursor, whose config is hooks and nothing else,
+ * still takes all three. The gate is the one both need, because it alone has a
+ * branch neither config can carry (see {@link gateTail}).
+ */
+import { DIRTY_MARKER } from '../gate.js';
+import { execCommand } from '../pm/index.js';
+/**
+ * The repo root, however the calling harness spells it. Cursor sets
+ * `CURSOR_PROJECT_DIR` (and `CLAUDE_PROJECT_DIR` as an alias); Claude Code sets
+ * only the latter. The final `.` fallback keeps the script working under an
+ * older harness that sets neither, where the cwd is already the project.
+ */
+const PROJECT_DIR = '"${CURSOR_PROJECT_DIR:-${CLAUDE_PROJECT_DIR:-.}}"';
+/**
+ * `<pm> exec checkride <args…>`, spelled for `pm`'s launcher. Quieted: the gate
+ * parses this command's stdout, so pnpm's narration must not lead it.
+ */
+function checkrideCommand(pm, args) {
+    return execCommand(pm, ['checkride', ...args], { quiet: true });
+}
+/**
+ * What a harness is told when `checkride gate` itself could not run.
+ *
+ * Emitted through `printf '%s\n' '…'` — single-quoted, never double — because
+ * the text carries backticks and `sh` runs a backtick span inside double quotes
+ * as a command. The first draft of this message used `echo "…"` and the shell
+ * silently ate the two quoted command names, substituting their output. Keep it
+ * free of single quotes for the same reason.
+ */
+const UNRUNNABLE = 'checkride: the gate could not run — `checkride gate` is not resolvable in this repo. ' +
+    'Install checkride (or re-run `checkride agent-setup`) before finishing.';
+/**
+ * The one line that hands `harness` the {@link UNRUNNABLE} verdict, and the exit
+ * status that goes with it.
+ *
+ * The statuses differ because the harnesses do: Claude Code blocks on 2, while
+ * Cursor reads any non-zero stop hook as a *broken* hook and ends the turn —
+ * there, blocking has to ride in the body with an exit of 0. Kept as a pair so
+ * no branch can pick one without the other.
+ */
+function unrunnable(harness) {
+    return harness === 'cursor'
+        ? { emit: `printf '%s\\n' '${JSON.stringify({ followup_message: UNRUNNABLE })}'`, exit: 0 }
+        : { emit: `printf '%s\\n' '${UNRUNNABLE}' >&2`, exit: 2 };
+}
+/**
+ * Translate the gate's exit status into `harness`'s protocol.
+ *
+ * The interesting branch is the last one. `checkride gate` exits 0 or 2 by
+ * design; anything else means it never ran — an uninstalled checkride, a broken
+ * launcher — and that must **block**, not pass. Claude Code reads a plain exit 1
+ * as "hook failed, carry on", which would leave a repo whose gate had silently
+ * stopped gating: precisely the vacuous green checkride exists to prevent. So
+ * the gate alone fails closed. (`protect` fails open, deliberately: the cost of
+ * a broken protect hook is a repo where nothing can be written at all.)
+ */
+function gateTail(harness) {
+    const { emit, exit } = unrunnable(harness);
+    if (harness === 'cursor') {
+        return [
+            '# On success checkride has already written its JSON to stdout, which is what',
+            '# Cursor reads. Only the never-ran case is left to answer for.',
+            '[ "$status" -eq 0 ] && exit 0',
+            emit,
+            `exit ${exit}`,
+        ];
+    }
+    return [
+        '# Claude Code parses a hook body only on exit 0, and only a body can carry a',
+        '# user-visible message alongside the block. So when checkride produced one,',
+        '# forward it and exit 0: the verdict rides in `decision`, not in the status.',
+        'if [ -n "$body" ]; then',
+        "  printf '%s\\n' \"$body\"",
+        '  case "$status" in',
+        '    0|2) exit 0 ;;',
+        '  esac',
+        'fi',
+        '',
+        '# No body — an older checkride that reports only through the exit code.',
+        '[ "$status" -eq 0 ] && exit 0',
+        '[ "$status" -eq 2 ] && exit 2',
+        '',
+        "# Neither of checkride's two gate codes: it never ran. Block anyway.",
+        emit,
+        `exit ${exit}`,
+    ];
+}
+/**
+ * Enter the repo, or report the same "could not run" verdict as any other way
+ * the gate can fail to start.
+ *
+ * Spelled as a block rather than `cd … || exit 2` for two reasons: a bare status
+ * tells the agent nothing, and under Cursor a non-zero stop hook is a *broken*
+ * hook, so the one branch that used to exit 2 there was the one branch that
+ * silently let a turn end.
+ */
+function enterRepo(harness) {
+    const { emit, exit } = unrunnable(harness);
+    return [`if ! cd ${PROJECT_DIR}; then`, `  ${emit}`, `  exit ${exit}`, 'fi'];
+}
+/**
+ * How the gate's stdout is taken.
+ *
+ * Cursor's script lets it stream straight through: Cursor reads the hook's own
+ * stdout, and there is nothing for the script to decide. Claude Code's captures
+ * it, because the script has to *choose an exit code based on whether a body
+ * came back* — see {@link gateTail}. Capturing costs nothing that is visible:
+ * the pipeline's human-readable progress is on stderr and streams live either
+ * way; stdout carries only the one-line JSON verdict, written at the very end.
+ */
+function invokeGate(pm, harness, args) {
+    const command = checkrideCommand(pm, args);
+    return harness === 'cursor'
+        ? [command, 'status=$?']
+        : [`body=$(${command})`, 'status=$?'];
+}
+/**
+ * The gate script: `cd` to the repo, hand off to `checkride gate`, and translate
+ * the result into the harness's protocol.
+ *
+ * `dirtyGuard` (on when the `dirty` hook is written alongside — the default)
+ * makes the gate conditional on the edit marker, so pure-conversation turns
+ * don't pay for a full pipeline run. Without the marker hook the guard would
+ * disarm the gate entirely, so a `--hook gate` selection writes it unguarded.
+ */
+export function gateScript(pm, opts) {
+    const args = ['gate', '--harness', opts.harness, ...((opts.dirtyGuard ?? true) ? ['--if-dirty'] : [])];
+    return [
+        '#!/bin/sh',
+        `# checkride-gate.sh — the ${opts.harness} stop-hook gate.`,
+        '#',
+        '# checkride owns this file: `checkride agent-setup` (and `checkride init`)',
+        '# overwrite it on every run. Customize via a sibling script or the',
+        '# environment, not by editing here — edits are lost on the next refresh.',
+        '#',
+        "# Runs the repo's `check` script as a hard gate, and reports the verdict in",
+        `# ${opts.harness}'s hook protocol. See \`checkride gate --help\`.`,
+        '',
+        ...enterRepo(opts.harness),
+        '',
+        ...invokeGate(pm, opts.harness, args),
+        ...gateTail(opts.harness),
+        '',
+    ].join('\n');
+}
+/**
+ * The dirty script: mark that this turn edited a file. A stop hook fires on
+ * every turn, including pure-conversation ones; the marker is what lets the gate
+ * skip those instead of taxing every reply with a full pipeline run.
+ *
+ * It exits 0 unconditionally. A failure to record an edit must never block the
+ * edit itself — the cost of a missed marker is one skipped gate, and the cost of
+ * a hard failure here is a repo where no file can be written.
+ */
+export function dirtyScript() {
+    return [
+        '#!/bin/sh',
+        '# checkride-dirty.sh — record that this turn edited a file.',
+        '#',
+        '# checkride owns this file: `checkride agent-setup` (and `checkride init`)',
+        '# overwrite it on every run.',
+        '#',
+        '# The gate reads this marker under `--if-dirty` and clears it on green.',
+        '',
+        `cd ${PROJECT_DIR} || exit 0`,
+        `mkdir -p "$(dirname ${DIRTY_MARKER})" && touch ${DIRTY_MARKER}`,
+        'exit 0',
+        '',
+    ].join('\n');
+}
+/**
+ * Keys Cursor may use for the target path in a tool call's `tool_input`.
+ *
+ * Cursor documents the shape for `Shell` but not for `Write`/`Delete`, so the
+ * list is deliberately broad and order-independent: the script takes the first
+ * string it finds. It keeps Claude Code's documented `file_path` and
+ * `notebook_path` too, since a harness that borrowed the schema would send
+ * those. An unrecognized shape yields no target and the script fails open, which
+ * is the correct failure — a protect hook that cannot read its input must not
+ * become a repo where nothing can be written.
+ *
+ * **The Cursor half of this list is a guess, and a wrong guess is silent**: an
+ * unmatched shape allows the write with no output, so `protect` would simply
+ * stop protecting and nothing would say so. The tests here can only assert the
+ * keys checkride *chose*, never the ones Cursor sends, so this is settled by one
+ * live `preToolUse` payload and not by anything in this repo. Until it is,
+ * `protect` is best-effort under Cursor — see docs/cursor.md. (Neither harness
+ * matches its shell tool, so a redirect writes the baseline under both; that gap
+ * is older and accepted.)
+ */
+const PATH_KEYS = ['file_path', 'notebook_path', 'path', 'target_file', 'filePath', 'relative_workspace_path'];
+/** The deny message, shared by both harnesses. */
+const DENY_MESSAGE = "'checkride: ' + rel + ' is checkride-owned accounting. Never edit the baseline or .check ' +\n" +
+    "    'artifacts to make a check pass — fix the finding instead (the ratchet prunes the baseline on its own).'";
+/**
+ * How Cursor spells "deny this tool call": a JSON body on stdout with exit 0. It
+ * reads a non-zero hook as a *broken* hook and proceeds, so the denial has to
+ * travel in the body, where `agent_message` is what the model sees.
+ */
+function denyTail() {
+    return [
+        '  const message = ' + DENY_MESSAGE + ';',
+        '  process.stdout.write(JSON.stringify({',
+        "    permission: 'deny',",
+        '    user_message: message,',
+        '    agent_message: message,',
+        '  }));',
+        '  process.exit(0);',
+    ];
+}
+/**
+ * The `protect` deny script: "never add to the baseline to make a check pass" as
+ * enforcement, not README advice. A Node script (not sh) because the hook
+ * protocol is JSON on stdin, and every checkride repo has node by construction;
+ * `.cjs` so it runs regardless of the repo's module type. Only edit tools are
+ * matched — reads are never denied, because triage depends on reading `.check/`
+ * artifacts.
+ *
+ * **Cursor only.** Claude Code enforces the same paths through
+ * `permissions.deny`, which is checked below the hook layer and costs nothing
+ * per tool call, so it needs no script. Cursor has no documented equivalent —
+ * its config is hooks — so the script survives for the harness that still
+ * requires one. If Cursor grows a file-path deny list, this file goes away.
+ */
+export function protectScript() {
+    return [
+        '#!/usr/bin/env node',
+        "// checkride-protect.cjs — deny agent edits to checkride's accounting files.",
+        '// checkride owns this file: `checkride agent-setup` (and `checkride init`)',
+        '// overwrite it on every run.',
+        '//',
+        '// Pre-tool hook for Cursor. Reads the tool call as JSON on stdin and',
+        '// denies the write when it targets the baseline or .check/. Reads are never',
+        '// matched — triage depends on reading .check artifacts.',
+        "'use strict';",
+        "const { realpathSync } = require('node:fs');",
+        "const { basename, dirname, isAbsolute, relative, resolve, sep } = require('node:path');",
+        '',
+        `const PATH_KEYS = ${JSON.stringify(PATH_KEYS)};`,
+        '',
+        '// Resolve symlinks in `p`, so a symlinked prefix cannot make an in-repo path',
+        '// look external. On macOS the repo root routinely arrives in two spellings —',
+        '// the harness passes /var/…, the environment reports /private/var/… — and a',
+        '// raw string comparison across the two rejects every path in the repo.',
+        '//',
+        '// `p` need not exist: this hook runs *before* the write, and the target is',
+        '// often a file (or a whole directory) that is about to be created. So walk up',
+        '// to the first ancestor that does exist, resolve that, and re-append the rest.',
+        'function canon(p) {',
+        '  let dir = resolve(p);',
+        '  const rest = [];',
+        '  for (;;) {',
+        '    try {',
+        '      return resolve(realpathSync(dir), ...rest);',
+        '    } catch {',
+        '      const up = dirname(dir);',
+        '      if (up === dir) return resolve(p);',
+        '      rest.unshift(basename(dir));',
+        '      dir = up;',
+        '    }',
+        '  }',
+        '}',
+        '',
+        "let raw = '';",
+        "process.stdin.on('data', (chunk) => { raw += chunk; });",
+        "process.stdin.on('end', () => {",
+        '  let input;',
+        '  try {',
+        '    input = JSON.parse(raw);',
+        '  } catch {',
+        '    process.exit(0); // fail open: a broken hook must not brick every edit',
+        '  }',
+        '  const tool = (input && input.tool_input) || {};',
+        "  const target = PATH_KEYS.map((k) => tool[k]).find((v) => typeof v === 'string' && v.length > 0);",
+        '  if (target === undefined) process.exit(0);',
+        '  const root = canon(process.env.CURSOR_PROJECT_DIR || process.env.CLAUDE_PROJECT_DIR || process.cwd());',
+        '  const abs = canon(isAbsolute(target) ? target : resolve(root, target));',
+        "  const rel = relative(root, abs).split(sep).join('/');",
+        "  const denied = rel === 'checkride.baseline.json' || rel === '.check' || rel.startsWith('.check/');",
+        '  if (!denied) process.exit(0);',
+        ...denyTail(),
+        '});',
+        '',
+    ].join('\n');
+}
+//# sourceMappingURL=scripts.js.map

package/node_modules/checkride/dist/agent-setup/scripts.js.map

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

package/node_modules/checkride/dist/agent-setup/skills.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Skill delivery for harnesses that have no plugin system.
+ *
+ * Claude Code gets `check` and `qa` from the bundled plugin
+ * (`.claude-plugin/plugin.json`), installed once and shared across every repo.
+ * Cursor has no equivalent — it discovers skills from directories on disk — so
+ * for Cursor the same two skills are written into the repo, from the same source
+ * files the plugin ships. One authored copy, two delivery mechanisms.
+ *
+ * The only edit made on the way through is the frontmatter `name`: a bare
+ * `check` would take the `/check` slash command in every repo it lands in, which
+ * is not a name checkride should be squatting. The plugin gets namespacing for
+ * free (`/checkride:check`); here it has to be spelled out.
+ */
+import type { HookFile } from './files.js';
+/** Where Cursor discovers project skills, relative to the repo root. */
+export declare const CURSOR_SKILLS_DIR = ".cursor/skills";
+/**
+ * Rewrite the `name:` field inside the leading frontmatter block, and only
+ * there — a `name:` further down is prose in the skill body, not metadata.
+ */
+export declare function renameSkill(body: string, name: string): string;
+/**
+ * Write the bundled skills into `cwd`'s Cursor skills directory. A source skill
+ * that cannot be read is skipped rather than fatal: a broken or trimmed install
+ * should cost the skills, not the whole `agent-setup`.
+ */
+export declare function writeCursorSkills(cwd: string, opts?: {
+    dryRun?: boolean;
+}): Promise<HookFile[]>;
+//# sourceMappingURL=skills.d.ts.map

package/node_modules/checkride/dist/agent-setup/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../src/agent-setup/skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C,wEAAwE;AACxE,eAAO,MAAM,iBAAiB,mBAAmB,CAAC;AAalD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAM9D;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAWzG"}

package/node_modules/checkride/dist/agent-setup/skills.js

@@ -0,0 +1,56 @@
+/**
+ * Skill delivery for harnesses that have no plugin system.
+ *
+ * Claude Code gets `check` and `qa` from the bundled plugin
+ * (`.claude-plugin/plugin.json`), installed once and shared across every repo.
+ * Cursor has no equivalent — it discovers skills from directories on disk — so
+ * for Cursor the same two skills are written into the repo, from the same source
+ * files the plugin ships. One authored copy, two delivery mechanisms.
+ *
+ * The only edit made on the way through is the frontmatter `name`: a bare
+ * `check` would take the `/check` slash command in every repo it lands in, which
+ * is not a name checkride should be squatting. The plugin gets namespacing for
+ * free (`/checkride:check`); here it has to be spelled out.
+ */
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { putFile, readIfExists } from './files.js';
+/** Where Cursor discovers project skills, relative to the repo root. */
+export const CURSOR_SKILLS_DIR = '.cursor/skills';
+const HERE = dirname(fileURLToPath(import.meta.url));
+/** The package's own `skills/` directory, which ships in the published tarball. */
+const SKILLS_DIR = join(HERE, '..', '..', 'skills');
+/** Source skill → the name it takes once it is a repo-local Cursor skill. */
+const SKILLS = [
+    { source: 'check', name: 'checkride-check' },
+    { source: 'qa', name: 'checkride-qa' },
+];
+/**
+ * Rewrite the `name:` field inside the leading frontmatter block, and only
+ * there — a `name:` further down is prose in the skill body, not metadata.
+ */
+export function renameSkill(body, name) {
+    const frontmatter = /^(---\r?\n)([\s\S]*?)(\r?\n---)/.exec(body);
+    if (!frontmatter)
+        return body;
+    const [, open, fields, close] = frontmatter;
+    const renamed = (fields ?? '').replace(/^name:.*$/m, `name: ${name}`);
+    return `${open}${renamed}${close}${body.slice(frontmatter[0].length)}`;
+}
+/**
+ * Write the bundled skills into `cwd`'s Cursor skills directory. A source skill
+ * that cannot be read is skipped rather than fatal: a broken or trimmed install
+ * should cost the skills, not the whole `agent-setup`.
+ */
+export async function writeCursorSkills(cwd, opts = {}) {
+    const dryRun = opts.dryRun ?? false;
+    const written = await Promise.all(SKILLS.map(async (skill) => {
+        const body = await readIfExists(join(SKILLS_DIR, skill.source, 'SKILL.md'));
+        if (body === null)
+            return null;
+        const rel = `${CURSOR_SKILLS_DIR}/${skill.name}/SKILL.md`;
+        return putFile(cwd, rel, renameSkill(body, skill.name), { dryRun });
+    }));
+    return written.filter((f) => f !== null);
+}
+//# sourceMappingURL=skills.js.map

package/node_modules/checkride/dist/agent-setup/skills.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.js","sourceRoot":"","sources":["../../src/agent-setup/skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGzC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEnD,wEAAwE;AACxE,MAAM,CAAC,MAAM,iBAAiB,GAAG,gBAAgB,CAAC;AAElD,MAAM,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAErD,mFAAmF;AACnF,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;AAEpD,6EAA6E;AAC7E,MAAM,MAAM,GAAgD;IAC1D,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE;IAC5C,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE;CACvC,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY,EAAE,IAAY;IACpD,MAAM,WAAW,GAAG,iCAAiC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACjE,IAAI,CAAC,WAAW;QAAE,OAAO,IAAI,CAAC;IAC9B,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,GAAG,WAAW,CAAC;IAC5C,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,EAAE,SAAS,IAAI,EAAE,CAAC,CAAC;IACtE,OAAO,GAAG,IAAI,GAAG,OAAO,GAAG,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC;AACzE,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,GAAW,EAAE,OAA6B,EAAE;IAClF,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,KAAK,CAAC;IACpC,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;QACzB,MAAM,IAAI,GAAG,MAAM,YAAY,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;QAC5E,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,IAAI,CAAC;QAC/B,MAAM,GAAG,GAAG,GAAG,iBAAiB,IAAI,KAAK,CAAC,IAAI,WAAW,CAAC;QAC1D,OAAO,OAAO,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;IACtE,CAAC,CAAC,CACH,CAAC;IACF,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC;AAC3C,CAAC"}

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

@@ -0,0 +1,30 @@
+/**
+ * What the repo *declared* it checks — as opposed to what a given run selected.
+ *
+ * The summary records the slots a run selected; it says nothing about the ones
+ * the repo opted into and did not run. Both readers need that difference:
+ * triage uses it to name the slots a narrow run left uncovered, and the quality
+ * extractor uses it to tell "opted in but not run this time" apart from "never
+ * opted in at all" — three of its four artifacts come from opt-in slots, so the
+ * distinction decides whether a gap is a finding or the repo's normal state.
+ *
+ * `null` throughout means *unknowable*, never *empty*: a repo with no
+ * `checkride.config.json` runs the default catalogue, and neither reader will
+ * guess at it.
+ *
+ * The `../artifacts` barrel is this module's only public surface.
+ */
+/**
+ * Slots the repo names in `checkride.config.json` and has not switched off
+ * (`false` disables one), sorted. `null` when the repo has no config file, or
+ * when the config is unparseable — that is the gate's problem to report, not
+ * the reader's to crash on.
+ *
+ * `cwd` is resolved first because `loadConfig` throws outright on a relative
+ * one, and both readers take their `cwd` from a command-line argument. Left
+ * unresolved, `dist/<reader>/cli.js .` would land in the catch below and report
+ * the repo's slots as *unknowable* — a silently degraded answer, which is the
+ * failure mode these readers exist to prevent.
+ */
+export declare function configuredSlots(cwd: string): string[] | null;
+//# sourceMappingURL=configured.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"configured.d.ts","sourceRoot":"","sources":["../../src/artifacts/configured.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAMH;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAW5D"}

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

@@ -0,0 +1,45 @@
+/**
+ * What the repo *declared* it checks — as opposed to what a given run selected.
+ *
+ * The summary records the slots a run selected; it says nothing about the ones
+ * the repo opted into and did not run. Both readers need that difference:
+ * triage uses it to name the slots a narrow run left uncovered, and the quality
+ * extractor uses it to tell "opted in but not run this time" apart from "never
+ * opted in at all" — three of its four artifacts come from opt-in slots, so the
+ * distinction decides whether a gap is a finding or the repo's normal state.
+ *
+ * `null` throughout means *unknowable*, never *empty*: a repo with no
+ * `checkride.config.json` runs the default catalogue, and neither reader will
+ * guess at it.
+ *
+ * The `../artifacts` barrel is this module's only public surface.
+ */
+import { resolve } from 'node:path';
+import { loadConfig } from '../config.js';
+/**
+ * Slots the repo names in `checkride.config.json` and has not switched off
+ * (`false` disables one), sorted. `null` when the repo has no config file, or
+ * when the config is unparseable — that is the gate's problem to report, not
+ * the reader's to crash on.
+ *
+ * `cwd` is resolved first because `loadConfig` throws outright on a relative
+ * one, and both readers take their `cwd` from a command-line argument. Left
+ * unresolved, `dist/<reader>/cli.js .` would land in the catch below and report
+ * the repo's slots as *unknowable* — a silently degraded answer, which is the
+ * failure mode these readers exist to prevent.
+ */
+export function configuredSlots(cwd) {
+    try {
+        const checks = loadConfig(resolve(cwd))?.checks;
+        if (!checks)
+            return null;
+        return Object.entries(checks)
+            .filter(([, value]) => value !== false)
+            .map(([slot]) => slot)
+            .toSorted();
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=configured.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"configured.js","sourceRoot":"","sources":["../../src/artifacts/configured.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAAC,GAAW;IACzC,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC;QAChD,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC;QACzB,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;aAC1B,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,KAAK,CAAC;aACtC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC;aACrB,QAAQ,EAAE,CAAC;IAChB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,33 @@
+/**
+ * Human-scale rendering of the quantities both readers report: file sizes,
+ * elapsed time, and a bounded tail of captured output.
+ *
+ * Sizes and ages carry the judgment in a reader's table — "2.3 MB" and "4d" are
+ * the whole reason an agent knows not to open a file — so they get one
+ * implementation rather than one per reader.
+ *
+ * {@link tail} is truncation, never normalization: it drops whole lines from
+ * the front and says how many, leaving the bytes it keeps exactly as the tool
+ * emitted them.
+ *
+ * The `../artifacts` barrel is this module's only public surface.
+ */
+/** `483 B`, `5.1 KB`, `2.3 MB` — one decimal above a kilobyte, none below. */
+export declare function formatBytes(bytes: number): string;
+/** `340ms`, `1.4s`, `12m`, `4.1d` — the coarsest unit that keeps a whole part. */
+export declare function formatDuration(ms: number): string;
+/** A bounded excerpt of captured output, with what it left out stated. */
+export type Excerpt = {
+    text: string;
+    /** Lines dropped from the front, so the caller can say so rather than imply completeness. */
+    omittedLines: number;
+    /** Size of the full input, so "1.2 KB of 40 KB" is sayable. */
+    totalBytes: number;
+};
+/**
+ * The last `maxLines` non-blank lines of `text`, further trimmed from the front
+ * until the excerpt fits `maxBytes`. A compiler, a test runner and a crashing
+ * harness all put the thing worth reading at the end.
+ */
+export declare function tail(text: string, maxLines: number, maxBytes: number): Excerpt;
+//# sourceMappingURL=format.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/artifacts/format.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAQH,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKjD;AASD,kFAAkF;AAClF,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAKjD;AAED,0EAA0E;AAC1E,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,6FAA6F;IAC7F,YAAY,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAQ9E"}

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

@@ -0,0 +1,56 @@
+/**
+ * Human-scale rendering of the quantities both readers report: file sizes,
+ * elapsed time, and a bounded tail of captured output.
+ *
+ * Sizes and ages carry the judgment in a reader's table — "2.3 MB" and "4d" are
+ * the whole reason an agent knows not to open a file — so they get one
+ * implementation rather than one per reader.
+ *
+ * {@link tail} is truncation, never normalization: it drops whole lines from
+ * the front and says how many, leaving the bytes it keeps exactly as the tool
+ * emitted them.
+ *
+ * The `../artifacts` barrel is this module's only public surface.
+ */
+const UNITS = [
+    { limit: 1024 ** 3, suffix: 'GB' },
+    { limit: 1024 ** 2, suffix: 'MB' },
+    { limit: 1024, suffix: 'KB' },
+];
+/** `483 B`, `5.1 KB`, `2.3 MB` — one decimal above a kilobyte, none below. */
+export function formatBytes(bytes) {
+    for (const { limit, suffix } of UNITS) {
+        if (bytes >= limit)
+            return `${(bytes / limit).toFixed(1)} ${suffix}`;
+    }
+    return `${bytes} B`;
+}
+const DURATIONS = [
+    { limit: 86_400_000, suffix: 'd' },
+    { limit: 3_600_000, suffix: 'h' },
+    { limit: 60_000, suffix: 'm' },
+    { limit: 1000, suffix: 's' },
+];
+/** `340ms`, `1.4s`, `12m`, `4.1d` — the coarsest unit that keeps a whole part. */
+export function formatDuration(ms) {
+    for (const { limit, suffix } of DURATIONS) {
+        if (ms >= limit)
+            return `${(ms / limit).toFixed(1)}${suffix}`;
+    }
+    return `${Math.round(ms)}ms`;
+}
+/**
+ * The last `maxLines` non-blank lines of `text`, further trimmed from the front
+ * until the excerpt fits `maxBytes`. A compiler, a test runner and a crashing
+ * harness all put the thing worth reading at the end.
+ */
+export function tail(text, maxLines, maxBytes) {
+    const lines = text.split('\n').filter((line) => line.trim() !== '');
+    const totalBytes = Buffer.byteLength(text, 'utf8');
+    let kept = lines.slice(-maxLines);
+    while (kept.length > 1 && Buffer.byteLength(kept.join('\n'), 'utf8') > maxBytes) {
+        kept = kept.slice(1);
+    }
+    return { text: kept.join('\n'), omittedLines: lines.length - kept.length, totalBytes };
+}
+//# sourceMappingURL=format.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../../src/artifacts/format.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,KAAK,GAAiD;IAC1D,EAAE,KAAK,EAAE,IAAI,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE;IAClC,EAAE,KAAK,EAAE,IAAI,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE;IAClC,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;CAC9B,CAAC;AAEF,8EAA8E;AAC9E,MAAM,UAAU,WAAW,CAAC,KAAa;IACvC,KAAK,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,KAAK,EAAE,CAAC;QACtC,IAAI,KAAK,IAAI,KAAK;YAAE,OAAO,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,MAAM,EAAE,CAAC;IACvE,CAAC;IACD,OAAO,GAAG,KAAK,IAAI,CAAC;AACtB,CAAC;AAED,MAAM,SAAS,GAAiD;IAC9D,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE;IAClC,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE;IACjC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE;IAC9B,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE;CAC7B,CAAC;AAEF,kFAAkF;AAClF,MAAM,UAAU,cAAc,CAAC,EAAU;IACvC,KAAK,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,SAAS,EAAE,CAAC;QAC1C,IAAI,EAAE,IAAI,KAAK;YAAE,OAAO,GAAG,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,EAAE,CAAC;IAChE,CAAC;IACD,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC;AAC/B,CAAC;AAWD;;;;GAIG;AACH,MAAM,UAAU,IAAI,CAAC,IAAY,EAAE,QAAgB,EAAE,QAAgB;IACnE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IACpE,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACnD,IAAI,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,CAAC;IAClC,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,GAAG,QAAQ,EAAE,CAAC;QAChF,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACvB,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,YAAY,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC;AACzF,CAAC"}

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

@@ -0,0 +1,32 @@
+/**
+ * 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.
+ */
+import type { Summary } from '../orchestrator.js';
+/** An artifact's standing relative to the run that wrote the summary. */
+export type Freshness = {
+    /** `unknown` when the summary's `timestamp` could not be parsed. */
+    state: 'fresh' | 'stale' | 'unknown';
+    /** How long before the run started the file was written; `null` unless stale. */
+    ageMs: number | 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 declare function runWindowStart(summary: Summary): number | null;
+/** Classify one artifact's mtime against the window from {@link runWindowStart}. */
+export declare function classifyFreshness(mtimeMs: number, windowStart: number | null): Freshness;
+//# sourceMappingURL=freshness.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"freshness.d.ts","sourceRoot":"","sources":["../../src/artifacts/freshness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD,yEAAyE;AACzE,MAAM,MAAM,SAAS,GAAG;IACtB,oEAAoE;IACpE,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;IACrC,iFAAiF;IACjF,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAKF;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAI9D;AAED,oFAAoF;AACpF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAIxF"}