canary-test-cli 7.2.0 → 8.0.0

package/dist/engine/analysis/batwoman/probes.js

@@ -0,0 +1,195 @@
+/**
+ * The three shipped probes (spec Phase 2).
+ *
+ * Each answers one question about one artifact type: has this thing executed
+ * since the fix merged? None of them asserts the fix is correct, and none of
+ * them reaches the network directly -- `ExerciseContext.runs` is the single
+ * seam, and the `gh` implementation behind it lives in `gh-history.ts`.
+ *
+ * **A probe that cannot decide throws or abstains; it never guesses.** The
+ * registry turns a throw into `abstain`, so a probe is free to let a broken
+ * `RunHistoryPort` surface rather than inventing a verdict over history nobody
+ * managed to read. Reporting "not exercised" on an unread history would be a
+ * claim with no evidence behind it -- the exact defect batwoman exists to find.
+ */
+import { readFileSync, readdirSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { day, judgeRuns } from './run-window.js';
+import { explain, } from './verdict.js';
+const WORKFLOW_DIR = '.github/workflows';
+const WORKFLOW_RE = /^\.github\/workflows\/[^/]+\.ya?ml$/;
+/** Top-level `scripts/*.mjs` only: nested helpers are not workflow entry points. */
+const SCRIPT_RE = /^scripts\/[^/]+\.mjs$/;
+/**
+ * `.github/workflows/*.yml` -- decided by run history, explained by `on:`.
+ */
+export function workflowProbe() {
+    return {
+        id: 'workflow',
+        artifact: 'workflow',
+        matches: (file) => WORKFLOW_RE.test(file),
+        async probe(file, ctx) {
+            return judgeRuns(file, await ctx.runs.runsForWorkflow(file), ctx);
+        },
+    };
+}
+/** Workflow files that mention `name`, as repo-relative paths. */
+function workflowsReferencing(root, name) {
+    let entries;
+    try {
+        entries = readdirSync(join(root, WORKFLOW_DIR));
+    }
+    catch {
+        return [];
+    }
+    // Bounded by a non-word character so `scripts/lint.mjs` is not considered
+    // called by a workflow whose only mention is `scripts/lint-staged.mjs`.
+    const mention = new RegExp(`(^|[^\\w-])${name.replace(/\./g, '\\.')}(\\W|$)`);
+    const found = [];
+    for (const entry of entries.sort()) {
+        if (!/\.ya?ml$/.test(entry))
+            continue;
+        const path = `${WORKFLOW_DIR}/${entry}`;
+        try {
+            if (mention.test(readFileSync(join(root, path), 'utf8')))
+                found.push(path);
+        }
+        catch {
+            // An unreadable workflow cannot be shown to reference the script, so it
+            // is not counted as one. It is skipped rather than made fatal.
+        }
+    }
+    return found;
+}
+/** A caller's file name, which is what a reader recognises it by. */
+function named(verdict) {
+    return basename(verdict.file);
+}
+/** Nothing under `.github/workflows` mentions the script. */
+function unreferencedScript(file) {
+    return {
+        file,
+        status: 'abstain',
+        explanation: explain('No workflow under .github/workflows references this script, so its ' +
+            'execution cannot be traced. It may still be run by hand or from a ' +
+            'command this scan cannot see.'),
+        evidence: `searched ${WORKFLOW_DIR} for ${basename(file)}`,
+    };
+}
+/** At least one calling workflow ran after the merge, so the script ran too. */
+function scriptRanWith(file, ran, callers, ctx) {
+    return {
+        file,
+        status: 'exercised',
+        explanation: explain(`It is called by ${named(ran)}, which has run since this fix merged, ` +
+            'so the script ran with it.'),
+        evidence: `${callers.length} referencing workflow(s); ${named(ran)} ran after ${day(ctx.mergedAt)}`,
+    };
+}
+/** Every calling workflow has been dormant since the merge. */
+function everyCallerDormant(file, judged, ctx) {
+    return {
+        file,
+        status: 'not-exercised',
+        explanation: explain(`Every workflow that calls it (${judged.map(named).join(', ')}) has ` +
+            'been dormant since this fix merged, so the script has not run.'),
+        evidence: `${judged.length} referencing workflow(s), none run after ${day(ctx.mergedAt)}`,
+    };
+}
+/** At least one calling workflow's history could not be read back far enough. */
+function callerHistoryUnknown(file, blind, judged) {
+    return {
+        file,
+        status: 'abstain',
+        explanation: explain(`The run history of ${blind.map(named).join(', ')} was truncated before ` +
+            'reaching the merge, so whether this script has run since cannot be ' +
+            'told. This is not a claim that it has not run.'),
+        evidence: `${judged.length} referencing workflow(s); ${blind.length} with a truncated history`,
+    };
+}
+/**
+ * `scripts/*.mjs` -- resolved statically to the workflows that call it, then
+ * decided by their run history.
+ *
+ * **Abstains when nothing references it**, rather than reporting it never
+ * ran. Those are different facts: "no workflow calls this" is a statement
+ * about the repo, and it may well be run by a human, a hook, or a workflow
+ * that builds the command dynamically. Calling that `not-exercised` would
+ * assert something no file supports (spec D3).
+ */
+export function workflowScriptProbe() {
+    return {
+        id: 'workflow-script',
+        artifact: 'workflow script',
+        matches: (file) => SCRIPT_RE.test(file),
+        async probe(file, ctx) {
+            const callers = workflowsReferencing(ctx.root, basename(file));
+            if (callers.length === 0)
+                return unreferencedScript(file);
+            const judged = await Promise.all(callers.map(async (caller) => judgeRuns(caller, await ctx.runs.runsForWorkflow(caller), ctx)));
+            const ran = judged.find((v) => v.status === 'exercised');
+            if (ran !== undefined)
+                return scriptRanWith(file, ran, callers, ctx);
+            // A caller whose own history was truncated has not been shown to be
+            // dormant, so the script cannot be called dormant either. Folding an
+            // abstention into "every caller dormant" would launder the one status
+            // that admits ignorance into a claim (spec Phase 3).
+            const blind = judged.filter((v) => v.status === 'abstain');
+            if (blind.length > 0)
+                return callerHistoryUnknown(file, blind, judged);
+            return everyCallerDormant(file, judged, ctx);
+        },
+    };
+}
+/** Files that are read, not run. Extensions first, then exact names. */
+const NO_EXECUTION_EXT = /\.(md|json|ya?ml|toml|ini|txt)$/;
+const NO_EXECUTION_NAMES = new Set([
+    '.gitignore',
+    '.gitattributes',
+    '.npmrc',
+    '.nvmrc',
+    '.prettierignore',
+    '.editorconfig',
+    'LICENSE',
+    'CODEOWNERS',
+]);
+/**
+ * Prose and configuration -- `not-applicable` without reading anything.
+ *
+ * A workflow is YAML, so the extension alone would swallow every file in
+ * `.github/workflows/` and declare it unrunnable. Registration order already
+ * puts `workflowProbe` first, but relying on that alone would mean a reordered
+ * list silently reclassified every workflow as `not-applicable` -- a whole
+ * artifact type disappearing into a status that asks nothing of anyone, which
+ * is precisely the silence batwoman exists to remove. The exclusion is stated
+ * here so the probe is correct standing alone, and the order is asserted
+ * separately.
+ */
+export function noExecutionProbe() {
+    return {
+        id: 'no-execution',
+        artifact: 'documentation or configuration',
+        matches: (file) => !WORKFLOW_RE.test(file) &&
+            (NO_EXECUTION_EXT.test(file) || NO_EXECUTION_NAMES.has(basename(file))),
+        probe(file) {
+            return Promise.resolve({
+                file,
+                status: 'not-applicable',
+                explanation: explain('This file is read rather than run, so "has it executed" is not a ' +
+                    'question it can answer.'),
+            });
+        },
+    };
+}
+/**
+ * The shipped probes, in match order.
+ *
+ * Order matters: a workflow file matches both `workflowProbe` and
+ * `noExecutionProbe`'s `.yml` extension, and `matchProbe` takes the first
+ * match. Everything unmatched becomes a `no-probe` row, which is the honest
+ * state for `ts/src/**` in v1 and is countable rather than silent.
+ */
+export function shippedProbes() {
+    return [workflowProbe(), workflowScriptProbe(), noExecutionProbe()];
+}
+//# sourceMappingURL=probes.js.map

package/dist/engine/analysis/batwoman/registry.js

@@ -0,0 +1,142 @@
+/**
+ * The probe registry: matching, dispatch, and the two named non-answers.
+ *
+ * Per spec D3 the gaps have to be countable, so an unmatched file produces a
+ * `no-probe` verdict that names what it could not classify rather than
+ * silence. The noun phrase comes from the path, not from a probe -- by
+ * construction no probe matched, so no probe can supply it.
+ * `ExerciseProbe.artifact` is the matched-probe counterpart, supplied by the
+ * probes themselves (see `probes.ts`).
+ */
+import { CLAIMING_STATUSES, EXERCISE_STATUSES, explain, isExplanation, } from './verdict.js';
+/**
+ * Path patterns to the noun phrase a NO PROBE row prints.
+ *
+ * Order is load-bearing: `*.test.ts` must be read as a test file before the
+ * generic source-module rule claims it, and a skill's `SKILL.md` before the
+ * generic document rule. The final fallback is a phrase rather than an empty
+ * string, because a row that names nothing is the silence D3 exists to remove.
+ */
+const ARTIFACT_RULES = [
+    [/\.(test|spec)\.[cm]?[jt]sx?$/, 'test file'],
+    [/^agents\/skills\/.+\.md$/, 'skill document'],
+    [/\.(json|ya?ml|toml|ini|lock)$/, 'config'],
+    [/\.[cm]?[jt]sx?$/, 'source module'],
+    [/\.md$/, 'document'],
+];
+/** The noun phrase for a file, for use in a `no-probe` row. */
+export function describeArtifact(file) {
+    for (const [pattern, noun] of ARTIFACT_RULES) {
+        if (pattern.test(file))
+            return noun;
+    }
+    return 'unrecognised artifact';
+}
+/** The first probe claiming this file, or null. */
+export function matchProbe(probes, file) {
+    return probes.find((probe) => probe.matches(file)) ?? null;
+}
+/** An `abstain` naming the probe and what was wrong with its answer. */
+function distrust(probeId, file, fault) {
+    return {
+        file,
+        status: 'abstain',
+        explanation: explain(`the ${probeId} probe answered about this file but batwoman could not ` +
+            `trust its verdict, because ${fault}; the file is therefore ` +
+            'unassessed rather than clean.'),
+        evidence: `${probeId} probe answer`,
+    };
+}
+/**
+ * What is wrong with a probe's answer, or `null` if nothing is.
+ *
+ * The type boundary in `verdict.ts` makes each of these unrepresentable in
+ * TypeScript, so this is the seam for answers arriving from outside it: a
+ * JavaScript probe, a plugin, a `JSON.parse`. It matters because an out-of-
+ * union status reaches `tallyVerdicts`, where `byStatus[status] += 1` yields
+ * `NaN` and the summary line stops summing to its own denominator -- a
+ * false-green shape one level up from the one batwoman detects.
+ */
+function faultIn(answer, file) {
+    if (typeof answer !== 'object' || answer === null) {
+        return (`it returned ${answer === null ? 'null' : typeof answer} rather ` +
+            'than a verdict');
+    }
+    const verdict = answer;
+    if (verdict.file !== file) {
+        return `it answered about ${String(verdict.file)} instead`;
+    }
+    if (!EXERCISE_STATUSES.includes(verdict.status)) {
+        return `'${String(verdict.status)}' is not one of the five statuses`;
+    }
+    if (!isExplanation(verdict.explanation)) {
+        return ('it supplied no explanation, and a row that names a file and says ' +
+            'nothing about it is not a verdict');
+    }
+    const claims = CLAIMING_STATUSES.includes(verdict.status);
+    if (claims && typeof verdict.evidence !== 'string') {
+        return (`a '${String(verdict.status)}' claim must name the evidence ` +
+            'behind it, and this one named none');
+    }
+    return null;
+}
+/** One file's verdict, via the probe that claims it. */
+export async function probeFile(probes, file, ctx) {
+    // Answered ahead of dispatch, and ahead of the no-probe fallback. A file the
+    // closing PR deleted has nothing left to execute and no longer exists to
+    // classify, so neither "nothing looked" nor a port failure is the right
+    // report for it -- the answer does not depend on run history at all
+    // (spec Phase 3).
+    if (ctx.deleted.has(file)) {
+        return {
+            file,
+            status: 'not-applicable',
+            explanation: explain('It was deleted by this change, so there is nothing left to run.'),
+            evidence: 'deleted by this change',
+        };
+    }
+    const probe = matchProbe(probes, file);
+    if (probe === null) {
+        return {
+            file,
+            status: 'no-probe',
+            explanation: explain(`batwoman has no probe for this ${describeArtifact(file)}, so ` +
+                'nothing looked at whether it has run since the fix merged.'),
+        };
+    }
+    try {
+        const answer = await probe.probe(file, ctx);
+        const fault = faultIn(answer, file);
+        return fault === null
+            ? answer
+            : distrust(probe.id, file, fault);
+    }
+    catch (err) {
+        // Cannot-verify is a finding, not a pass (spec criterion 4). A probe whose
+        // evidence source failed knows strictly less than one that never ran, so
+        // the only honest answer is abstain -- and the `await` inside the `try` is
+        // load-bearing: without it a rejected promise escapes the catch.
+        return {
+            file,
+            status: 'abstain',
+            explanation: explain(`the ${probe.id} probe looked at this file but could not decide ` +
+                'whether it ran, because reading its evidence failed: ' +
+                `${err instanceof Error ? err.message : String(err)}.`),
+            evidence: `${probe.id} probe error`,
+        };
+    }
+}
+/**
+ * Probe every changed file, in input order, one at a time.
+ *
+ * Sequential rather than `Promise.all`: the real port shells out to `gh`, and a
+ * fan-out over a whole changed-file set would turn one audit into a burst of
+ * API calls. Order is preserved so the report is reproducible.
+ */
+export async function probeAll(probes, files, ctx) {
+    const verdicts = [];
+    for (const file of files)
+        verdicts.push(await probeFile(probes, file, ctx));
+    return verdicts;
+}
+//# sourceMappingURL=registry.js.map

package/dist/engine/analysis/batwoman/render.js

@@ -0,0 +1,194 @@
+/**
+ * batwoman's report, rendered through canary's persona registry (spec D7).
+ *
+ * Two rules bind harder than anything else here, and both are asserted in
+ * `ts/test/batwoman-render-invariants.test.ts` across all three registers
+ * rather than once against the default:
+ *
+ * **There is no success-only path.** Every run ends with one column per status,
+ * including the two that mean batwoman could not decide. A detector that
+ * covered two of seven changed files and printed a clean token would be a pass
+ * over a denominator of two presented as a pass over seven -- the exact defect
+ * batwoman exists to catch, committed by batwoman (spec D5).
+ *
+ * **Every row keeps its sentence.** `ExerciseVerdict.explanation` renders in
+ * every register, terse included. What the terse register drops is the material
+ * gated by the persona's `reasoning` flag -- the evidence line and the
+ * next-step guidance -- not the observation-and-cause sentence itself, which is
+ * the difference between a verdict and a status code.
+ */
+import { EXERCISE_STATUSES, tallyVerdicts, } from './verdict.js';
+import { WIDTH, fitLine, stamp, wrap } from './text.js';
+/** Column labels, in `EXERCISE_STATUSES` order. */
+const SUMMARY_LABELS = {
+    exercised: 'exercised',
+    'not-exercised': 'not exercised',
+    abstain: 'abstained',
+    'no-probe': 'no probe',
+    'not-applicable': 'n/a',
+};
+/**
+ * The one line every run prints.
+ *
+ * The changed-file total leads so the denominator is read before any count;
+ * the render suite asserts the columns sum to it.
+ */
+export function summaryLine(verdicts) {
+    const { changed, byStatus } = tallyVerdicts(verdicts);
+    const columns = EXERCISE_STATUSES.map((status) => `${byStatus[status]} ${SUMMARY_LABELS[status]}`);
+    return [`${changed} changed`, ...columns].join(' · ');
+}
+/**
+ * One `  Label     value` header row, wrapped with a hanging indent.
+ *
+ * The header wraps for the same reason the body does, and it is the amendment
+ * this module needed most: both values it carries are free text of unbounded
+ * length. A commit subject is whatever the author typed, and
+ * `ResolvedPersona.reason` is a composed sentence -- an unknown register
+ * produces one naming every candidate. Emitted unwrapped, those two lines were
+ * 83 and 199 columns wide against a 78-column report, and only short fixtures
+ * kept that from being visible.
+ */
+function labelled(label, value) {
+    const prefix = `  ${label.padEnd(9)}  `;
+    const lines = wrap(value, WIDTH, ' '.repeat(prefix.length));
+    const [first, ...rest] = lines;
+    // An empty value used to emit `  Closed by` and nothing else -- a label
+    // dangling over blank space, which is the same silent-empty shape the verdict
+    // model now forbids outright. Naming the gap keeps it countable by eye.
+    if (first === undefined)
+        return [`${prefix}(none recorded)`];
+    // The first line swaps the blank indent for the label; the rest keep it, so
+    // continuations align under the value rather than under the label.
+    return [prefix + first.slice(prefix.length), ...rest];
+}
+/**
+ * A commit oid at the length a human reads and pastes.
+ *
+ * The closure adapter carries the full 40-character oid, which is right for
+ * data and wrong for a 78-column report: printed whole it pushed the subject
+ * onto a second line and split the hash across the wrap, which reads as
+ * corruption rather than as a hash. Seven is git's own short form, and what
+ * the spec's sample shows. A value that is not an oid is left alone -- an
+ * abbreviated non-hash would be a lie about what it is.
+ */
+function abbreviate(sha) {
+    return /^[0-9a-f]{40}$/i.test(sha) ? sha.slice(0, 7) : sha;
+}
+function headerLines(options) {
+    const { header, repo, persona } = options;
+    return [
+        `canary batwoman — ${repo}#${header.issue}`,
+        '',
+        ...labelled('Closed by', `${abbreviate(header.mergeSha)}  ${header.mergeSubject}`),
+        ...labelled('Merged', stamp(header.mergedAt)),
+        // Printed so a reader who got terse output when they wanted guided output
+        // can tell a short report from a truncated one (spec criterion 9).
+        ...labelled('Register', `${persona.persona.id} (${persona.persona.label}) — ` +
+            `${persona.source}: ${persona.reason}`),
+        '',
+    ];
+}
+/** Section headings, in report order: the findings first. */
+const SECTIONS = [
+    ['not-exercised', 'NOT EXERCISED'],
+    ['abstain', 'ABSTAINED'],
+    ['no-probe', 'NO PROBE'],
+    ['exercised', 'EXERCISED'],
+    ['not-applicable', 'NOT APPLICABLE'],
+];
+/**
+ * A section heading.
+ *
+ * The first finding section states its denominator inline; the rest are counted
+ * against the same total one line below, in the summary that always prints.
+ */
+function heading(label, status, rows, total) {
+    const files = (count) => (count === 1 ? 'file' : 'files');
+    return status === 'not-exercised'
+        ? `  ${label} — ${rows} of ${total} changed ${files(total)}`
+        : `  ${label} — ${rows} ${files(rows)}`;
+}
+function briefRows(verdicts, reasoning) {
+    const lines = [];
+    for (const verdict of verdicts) {
+        lines.push(...fitLine(`    ${verdict.file}`, WIDTH, '      '));
+        lines.push(...wrap(verdict.explanation, WIDTH, '      '));
+        if (reasoning && verdict.evidence !== undefined) {
+            lines.push(...fitLine(`      Read: ${verdict.evidence}`, WIDTH, '        '));
+        }
+        lines.push('');
+    }
+    return lines;
+}
+/**
+ * What a reader can actually do about each status.
+ *
+ * `exercised` and `not-applicable` are absent on purpose: there is nothing to
+ * ask for, and inventing a step for them would be the guided register's version
+ * of a success token.
+ */
+const NEXT_STEPS = {
+    'not-exercised': 'Run the path this file belongs to, then re-run canary batwoman to ' +
+        'confirm it moved.',
+    abstain: 'Check the evidence source named above, then re-run canary batwoman so ' +
+        'this file gets a verdict instead of a gap.',
+    'no-probe': 'Add an ExerciseProbe for this artifact type so the gap stops being ' +
+        'uncountable, or confirm by hand that the file ran.',
+};
+function guidedRows(verdicts, status) {
+    const lines = [];
+    verdicts.forEach((verdict, index) => {
+        lines.push(...fitLine(`    ${index + 1}. ${verdict.file}`, WIDTH, '       '));
+        lines.push(...wrap(verdict.explanation, WIDTH, '       '));
+        if (verdict.evidence !== undefined) {
+            lines.push(...fitLine(`       Read: ${verdict.evidence}`, WIDTH, '         '));
+        }
+        const step = NEXT_STEPS[status];
+        if (step !== undefined) {
+            lines.push(...wrap(`Next: ${step}`, WIDTH, '       '));
+        }
+        lines.push('');
+    });
+    return lines;
+}
+function terseRows(verdicts) {
+    return verdicts.flatMap((verdict) => [
+        ...fitLine(`  - ${verdict.file}  ${verdict.status}`, WIDTH, '    '),
+        ...wrap(verdict.explanation, WIDTH, '    '),
+    ]);
+}
+function bodyLines(options) {
+    const { verdicts, persona } = options;
+    const lines = [];
+    for (const [status, label] of SECTIONS) {
+        const rows = verdicts.filter((verdict) => verdict.status === status);
+        // An empty section is omitted, not printed as a zero: the counts that
+        // matter are in the summary line, which prints all five unconditionally.
+        if (rows.length === 0)
+            continue;
+        if (persona.persona.depth === 'terse') {
+            lines.push(...terseRows(rows));
+            continue;
+        }
+        if (persona.persona.depth === 'guided') {
+            lines.push(heading(label, status, rows.length, verdicts.length));
+            lines.push(...guidedRows(rows, status));
+            continue;
+        }
+        lines.push(heading(label, status, rows.length, verdicts.length));
+        lines.push(...briefRows(rows, persona.persona.reasoning));
+    }
+    return lines;
+}
+/** The whole report, as one string whose last content line is the summary. */
+export function renderReport(options) {
+    return [
+        ...headerLines(options),
+        ...bodyLines(options),
+        '  ' + '─'.repeat(62),
+        '  ' + summaryLine(options.verdicts),
+        '',
+    ].join('\n');
+}
+//# sourceMappingURL=render.js.map

package/dist/engine/analysis/batwoman/run-window.js

@@ -0,0 +1,122 @@
+/**
+ * Turning one fetched window of run history into a verdict.
+ *
+ * Separated from the probes because it is the part that reasons about *time
+ * and evidence* rather than about artifact types: which runs postdate the
+ * merge, whether the window saw enough to justify a negative answer, and how
+ * a dormant workflow explains itself. Both the workflow probe and the
+ * workflow-script probe decide through this one function, so the two cannot
+ * drift apart in what they will claim.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { load } from 'js-yaml';
+import { describeTriggers } from './triggers.js';
+import { explain, } from './verdict.js';
+/** `2026-08-10`, the grain a human reasons about a run in. */
+export function day(when) {
+    return when.toISOString().slice(0, 10);
+}
+/** The most recent run, or undefined. Order from the port is not assumed. */
+function latest(runs) {
+    return [...runs].sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())[0];
+}
+/**
+ * The workflow's trigger clause, or null when the file cannot be read.
+ *
+ * Deliberately swallows every read and parse error. The trigger explanation
+ * and the run-history verdict come from different places and fail
+ * independently: a workflow deleted by the very PR under audit still has a run
+ * history worth reporting, and losing that verdict because its file is gone
+ * would be a self-inflicted abstention.
+ */
+function triggerClause(root, file) {
+    try {
+        const doc = load(readFileSync(join(root, file), 'utf8'));
+        if (typeof doc !== 'object' || doc === null)
+            return null;
+        const record = doc;
+        // `on` is read under both spellings. Under a YAML 1.1 resolver an
+        // unquoted `on:` becomes boolean true and the block vanishes; js-yaml
+        // 5.4.1 keeps it a string, so this is defence against a parser change
+        // rather than a bug being worked around.
+        return describeTriggers(record['on'] ?? record['true']);
+    }
+    catch {
+        return null;
+    }
+}
+/** The sentence a dormant workflow gets: the fact, then the cause. */
+function dormantExplanation(last, clause) {
+    const fact = last === undefined
+        ? 'It has no recorded runs at all.'
+        : `Last ran ${day(last.createdAt)}, before this fix merged.`;
+    // Without a clause the sentence stops at the fact. Saying less is the
+    // correct degradation; a guessed cause would be acted on.
+    return clause === null
+        ? fact
+        : `${fact} It is ${clause}, so it has not run since.`;
+}
+/**
+ * True when a *negative* answer from this window would be unfounded.
+ *
+ * **Narrower than the spec's wording, deliberately.** The spec asks the probe
+ * to abstain whenever the fetched page "does not reach back past `mergedAt`",
+ * reasoning that absence of a qualifying run would then be indistinguishable
+ * from truncation. That rationale does not survive contact with the API:
+ * `gh run list` returns runs newest-first (verified against this repo), so
+ * every run beyond the page is OLDER than every run in it. For a qualifying
+ * run to hide outside the window, the oldest fetched run would have to
+ * postdate the merge -- and that same condition puts a qualifying run *inside*
+ * the window, where the check above has already found it. A dropped-off page
+ * therefore cannot conceal a run after the merge.
+ *
+ * What remains genuinely blind is a window that is both empty and truncated:
+ * it reports nothing and admits there is more, which is an absence of evidence
+ * rather than evidence of absence. That case abstains.
+ *
+ * The `complete` flag is kept on {@link RunHistory} regardless. It costs one
+ * comparison, it is the honest description of what the port fetched, and it is
+ * what makes this argument checkable instead of assumed -- if the ordering
+ * guarantee ever changes, this is the one function that has to change with it.
+ */
+function windowIsBlind(history, _mergedAt) {
+    return !history.complete && history.runs.length === 0;
+}
+/** Decide one workflow from its run history. Shared with the script probe. */
+export function judgeRuns(file, history, ctx) {
+    const runs = history.runs;
+    const after = runs.filter((r) => r.createdAt > ctx.mergedAt);
+    const mostRecent = latest(after);
+    // Checked before truncation on purpose: a run after the merge is a positive
+    // finding, and nothing hidden further back could overturn it.
+    if (mostRecent !== undefined) {
+        return {
+            file,
+            status: 'exercised',
+            explanation: explain(`It has run ${after.length === 1 ? 'once' : `${after.length} times`} ` +
+                `since this fix merged, most recently on ${day(mostRecent.createdAt)}.`),
+            evidence: `${runs.length} recorded run(s) for ${file}; ${after.length} after ${day(ctx.mergedAt)}`,
+        };
+    }
+    if (windowIsBlind(history, ctx.mergedAt)) {
+        return {
+            file,
+            status: 'abstain',
+            explanation: explain('Its run history came back empty but incomplete, so nothing was ' +
+                'learned about whether it has run. This is not a claim that it ' +
+                'has not run.'),
+            evidence: `an empty but truncated run history for ${file}; nothing reaching back to ${day(ctx.mergedAt)}`,
+        };
+    }
+    const last = latest(runs);
+    return {
+        file,
+        status: 'not-exercised',
+        explanation: explain(dormantExplanation(last, triggerClause(ctx.root, file))),
+        evidence: last === undefined
+            ? `no recorded runs for ${file}`
+            : `${runs.length} recorded run(s) for ${file}, none after ${day(ctx.mergedAt)}`,
+    };
+}
+//# sourceMappingURL=run-window.js.map