canary-test-cli 7.2.0 → 8.0.0

package/agents/skills/lib/parse-args.mjs

@@ -19,6 +19,10 @@
 // `test/skill-cli-conformance.test.ts` discovers every SKILL.md declaring
 // `cli:` and asserts the module exports the `CLI_SPEC` it passed here, so a
 // sixth hand-rolled copy fails CI instead of quietly starting the cycle again.
+//
+// The parse is split into one small helper per decision (#906): the single
+// 155-line closure it replaced measured cyclomatic complexity 42, and every
+// branch of it is pinned end to end in `test/parse-args.test.ts`.
 
 /** Exit code argparse reserves for usage errors; the whole family follows it. */
 export const EXIT_USAGE = 2;
@@ -42,6 +46,191 @@ function nullProtoMap(entries) {
   return Object.assign(Object.create(null), entries);
 }
 
+function expectedOneArgument(flag) {
+  return `argument ${flag}: expected one argument`;
+}
+
+/**
+ * Fail loudly at construction on a spec that cannot be satisfied -- a rename
+ * that leaves a stale default or a required flag behind is otherwise silent.
+ */
+function assertSpecSatisfiable(config) {
+  const { booleans, values, defaults, required, VALUES } = config;
+  const declaredKeys = new Set([
+    ...Object.values(booleans),
+    ...Object.values(values).map((v) => v.key),
+  ]);
+  for (const key of Object.keys(defaults)) {
+    if (!declaredKeys.has(key)) {
+      throw new Error(`createParser: defaults names unknown key '${key}'`);
+    }
+  }
+  for (const flag of required) {
+    if (VALUES[flag] === undefined) {
+      throw new Error(`createParser: required names undeclared flag '${flag}'`);
+    }
+  }
+}
+
+/** Booleans start false, value flags start at their default or null. */
+function initialOpts({ booleans, values, defaults }) {
+  const opts = Object.create(null);
+  for (const key of Object.values(booleans)) opts[key] = false;
+  for (const { key } of Object.values(values)) {
+    opts[key] = key in defaults ? defaults[key] : null;
+  }
+  Object.assign(opts, defaults);
+  return opts;
+}
+
+/** Split `--flag=value` once, up front, so both spellings share one path. */
+function splitInlineValue(arg) {
+  const eq = arg.startsWith('--') ? arg.indexOf('=') : -1;
+  if (eq === -1) return { flag: arg, inline: null };
+  return { flag: arg.slice(0, eq), inline: arg.slice(eq + 1) };
+}
+
+/**
+ * A leading '-' normally means "the next flag, not my value" -- but a
+ * well-formed integer is a legitimate value for an int flag, so `--seed -5`
+ * and `--seed=-5` stay the same command.
+ */
+function cannotBeValue(def, next) {
+  if (next === undefined) return true;
+  return next.startsWith('-') && !(def.type === 'int' && INT_RE.test(next));
+}
+
+/** The raw value text and how many extra argv tokens it used, or an error. */
+function readRawValue(flag, def, inline, next) {
+  if (inline !== null) return { raw: inline, consumed: 0 };
+  if (cannotBeValue(def, next)) return { error: expectedOneArgument(flag) };
+  return { raw: next, consumed: 1 };
+}
+
+/** Validate an int value's syntax AND its exactness. */
+function parseIntValue(flag, raw) {
+  // Validate the VALUE, not just its presence: a flag whose purpose is
+  // determinism must not decay to a default when its value is junk.
+  if (!INT_RE.test(raw)) {
+    return { error: `argument ${flag}: invalid int value: '${raw}'` };
+  }
+  // Syntactically an integer is not enough: Number() silently rounds past
+  // 2^53-1, so `--seed 9007199254740993` would RUN with ...992 -- the value
+  // used differing from the value asked for, which is the exact class of lie
+  // a determinism flag must not tell.
+  const parsed = Number(raw);
+  if (!Number.isSafeInteger(parsed)) {
+    return { error: `argument ${flag}: integer out of safe range: '${raw}'` };
+  }
+  return { value: parsed };
+}
+
+function coerceValue(flag, def, raw) {
+  // Empty is the missing-value case wearing a disguise. `--repo=` is typed by
+  // nobody, but `--repo "$UNSET_VAR"` expands to `--repo ''` in any shell, and
+  // an accepted empty path silently retargets writes at the process CWD.
+  if (raw === '') return { error: expectedOneArgument(flag) };
+  if (def.type === 'int') return parseIntValue(flag, raw);
+  return { value: raw };
+}
+
+/** Store a value flag's value; the outcome says how many tokens it took. */
+function takeValue(state, flag, inline, index) {
+  const def = state.VALUES[flag];
+  const read = readRawValue(flag, def, inline, state.argv[index + 1]);
+  if (read.error !== undefined) return read;
+  const coerced = coerceValue(flag, def, read.raw);
+  if (coerced.error !== undefined) return coerced;
+  state.opts[def.key] = coerced.value;
+  return { consumed: read.consumed };
+}
+
+/** A lone `-` is a positional, as argparse treats it. */
+function isPositional(state, arg) {
+  if (!state.positionals) return false;
+  return arg === '-' || !arg.startsWith('-');
+}
+
+/** A token that is neither help nor `--`: a flag, a positional, or junk. */
+function readOptionToken(state, arg, index) {
+  const { flag, inline } = splitInlineValue(arg);
+  if (state.BOOLEANS[flag] !== undefined && inline === null) {
+    state.opts[state.BOOLEANS[flag]] = true;
+    return { consumed: 0 };
+  }
+  if (state.VALUES[flag] !== undefined) {
+    return takeValue(state, flag, inline, index);
+  }
+  if (isPositional(state, arg)) {
+    state.found.push(arg);
+    return { consumed: 0 };
+  }
+  return { error: `unrecognized arguments: ${arg}` };
+}
+
+function endOptions(state) {
+  if (!state.positionals) return { error: 'unrecognized arguments: --' };
+  state.endOfOptions = true;
+  return { consumed: 0 };
+}
+
+/**
+ * One token's outcome: `{consumed}` to keep scanning, or `{help}` / `{error}`
+ * to stop.
+ */
+function readToken(state, index) {
+  const arg = state.argv[index];
+  if (state.endOfOptions) {
+    state.found.push(arg);
+    return { consumed: 0 };
+  }
+  // Help short-circuits everything, including the required-flag check --
+  // otherwise `--help` reports the arguments it is being asked to explain as
+  // missing.
+  if (arg === '-h' || arg === '--help') return { help: true };
+  if (arg === '--') return endOptions(state);
+  return readOptionToken(state, arg, index);
+}
+
+/** Scan argv; returns the stopping outcome, or null when argv ran out. */
+function scanTokens(state) {
+  for (let i = 0; i < state.argv.length; i += 1) {
+    const outcome = readToken(state, i);
+    if (outcome.consumed === undefined) return outcome;
+    i += outcome.consumed;
+  }
+  return null;
+}
+
+function missingRequired({ required, VALUES }, opts) {
+  return required.filter((flag) => {
+    const value = opts[VALUES[flag].key];
+    return value === null || value === undefined;
+  });
+}
+
+function parseArgv(config, argv) {
+  const opts = initialOpts(config);
+  const found = [];
+  const result = { opts, positionals: found, help: false, error: null };
+  const state = { ...config, argv, opts, found, endOfOptions: false };
+
+  const stop = scanTokens(state);
+  if (stop !== null) return Object.assign(result, stop);
+
+  const missing = missingRequired(config, opts);
+  if (missing.length) {
+    result.error = `the following arguments are required: ${missing.join(', ')}`;
+    return result;
+  }
+
+  const { positionals } = config;
+  if (positionals && !found.length && positionals.defaults) {
+    found.push(...positionals.defaults);
+  }
+  return result;
+}
+
 /**
  * Build a parser from a declarative spec.
  *
@@ -69,146 +258,18 @@ export function createParser(spec) {
 
   if (!prog) throw new Error('createParser: spec.prog is required');
 
-  const BOOLEANS = nullProtoMap(booleans);
-  const VALUES = nullProtoMap(values);
-
-  // Fail loudly at construction on a spec that cannot be satisfied -- a rename
-  // that leaves a stale default or a required flag behind is otherwise silent.
-  const declaredKeys = new Set([
-    ...Object.values(booleans),
-    ...Object.values(values).map((v) => v.key),
-  ]);
-  for (const key of Object.keys(defaults)) {
-    if (!declaredKeys.has(key)) {
-      throw new Error(`createParser: defaults names unknown key '${key}'`);
-    }
-  }
-  for (const flag of required) {
-    if (VALUES[flag] === undefined) {
-      throw new Error(`createParser: required names undeclared flag '${flag}'`);
-    }
-  }
+  const config = {
+    booleans,
+    values,
+    defaults,
+    required,
+    positionals,
+    BOOLEANS: nullProtoMap(booleans),
+    VALUES: nullProtoMap(values),
+  };
+  assertSpecSatisfiable(config);
 
   return function parse(argv = []) {
-    const opts = Object.create(null);
-    for (const key of Object.values(booleans)) opts[key] = false;
-    for (const { key } of Object.values(values)) {
-      opts[key] = key in defaults ? defaults[key] : null;
-    }
-    Object.assign(opts, defaults);
-
-    const found = [];
-    const result = { opts, positionals: found, help: false, error: null };
-    const fail = (message) => {
-      result.error = message;
-      return result;
-    };
-
-    let endOfOptions = false;
-
-    for (let i = 0; i < argv.length; i += 1) {
-      const arg = argv[i];
-
-      if (endOfOptions) {
-        found.push(arg);
-        continue;
-      }
-
-      // Help short-circuits everything, including the required-flag check
-      // below -- otherwise `--help` reports the arguments it is being asked to
-      // explain as missing.
-      if (arg === '-h' || arg === '--help') {
-        result.help = true;
-        return result;
-      }
-
-      if (arg === '--') {
-        if (!positionals) return fail('unrecognized arguments: --');
-        endOfOptions = true;
-        continue;
-      }
-
-      // Split `--flag=value` once, up front, so both spellings share one path.
-      const eq = arg.startsWith('--') ? arg.indexOf('=') : -1;
-      const flag = eq === -1 ? arg : arg.slice(0, eq);
-      const inline = eq === -1 ? null : arg.slice(eq + 1);
-
-      if (BOOLEANS[flag] !== undefined && inline === null) {
-        opts[BOOLEANS[flag]] = true;
-        continue;
-      }
-
-      const def = VALUES[flag];
-      if (def !== undefined) {
-        let raw;
-        if (inline !== null) {
-          raw = inline;
-        } else {
-          const next = argv[i + 1];
-          // A leading '-' normally means "the next flag, not my value" -- but a
-          // well-formed integer is a legitimate value for an int flag, so
-          // `--seed -5` and `--seed=-5` stay the same command.
-          const looksLikeFlag =
-            next !== undefined &&
-            next.startsWith('-') &&
-            !(def.type === 'int' && INT_RE.test(next));
-          if (next === undefined || looksLikeFlag) {
-            return fail(`argument ${flag}: expected one argument`);
-          }
-          raw = next;
-          i += 1;
-        }
-        // Empty is the missing-value case wearing a disguise. `--repo=` is
-        // typed by nobody, but `--repo "$UNSET_VAR"` expands to `--repo ''` in
-        // any shell, and an accepted empty path silently retargets writes at
-        // the process CWD.
-        if (raw === '') return fail(`argument ${flag}: expected one argument`);
-        if (def.type === 'int') {
-          // Validate the VALUE, not just its presence: a flag whose purpose is
-          // determinism must not decay to a default when its value is junk.
-          if (!INT_RE.test(raw)) {
-            return fail(`argument ${flag}: invalid int value: '${raw}'`);
-          }
-          // Syntactically an integer is not enough: Number() silently rounds
-          // past 2^53-1, so `--seed 9007199254740993` would RUN with ...992 --
-          // the value used differing from the value asked for, which is the
-          // exact class of lie a determinism flag must not tell.
-          const parsed = Number(raw);
-          if (!Number.isSafeInteger(parsed)) {
-            return fail(
-              `argument ${flag}: integer out of safe range: '${raw}'`,
-            );
-          }
-          opts[def.key] = parsed;
-        } else {
-          opts[def.key] = raw;
-        }
-        continue;
-      }
-
-      // A lone `-` is a positional, as argparse treats it.
-      if (positionals && (arg === '-' || !arg.startsWith('-'))) {
-        found.push(arg);
-        continue;
-      }
-
-      return fail(`unrecognized arguments: ${arg}`);
-    }
-
-    const missing = required.filter((flag) => {
-      const value = opts[VALUES[flag].key];
-      return value === null || value === undefined;
-    });
-    if (missing.length) {
-      return fail(
-        `the following arguments are required: ${missing.join(', ')}`,
-      );
-    }
-
-    if (positionals && !found.length && positionals.defaults) {
-      found.push(...positionals.defaults);
-    }
-
-    return result;
+    return parseArgv(config, argv);
   };
 }

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

@@ -0,0 +1,39 @@
+/**
+ * One issue, audited end to end (spec Phase 4).
+ *
+ * The composition every surface shares: resolve the change that closed the
+ * issue, probe each file it touched, and hand back the verdicts with the
+ * header they belong to. It lives here rather than in the CLI so that the
+ * order of operations -- and the rule that the changed-file set is the
+ * denominator -- is stated once, in the analysis layer, where the Phase 5 CI
+ * wrapper can reuse it without going through argv.
+ *
+ * **The two failure classes are deliberately different.** A closure that will
+ * not resolve throws: without it there is no changed-file set, so there is no
+ * denominator and nothing honest to report. A run history that will not read
+ * does not throw: the denominator is known, and "could not tell" is a verdict
+ * worth printing per file. Collapsing the second into the first would trade a
+ * report full of abstentions for no report at all.
+ */
+import { resolveClosure as defaultResolveClosure } from './closure.js';
+import { ghRunHistory } from './gh-history.js';
+import { shippedProbes } from './probes.js';
+import { probeAll } from './registry.js';
+/**
+ * Audit `issue` in `repo`, reading the working tree at `root` for static
+ * resolution (which workflow calls a script, what an `on:` block says).
+ */
+export async function auditIssue(issue, repo, root, deps = {}) {
+    const resolve = deps.resolveClosure ?? defaultResolveClosure;
+    const history = deps.runHistory ?? ((r) => ghRunHistory(r));
+    const closure = await resolve(issue, repo);
+    const verdicts = await probeAll(shippedProbes(), closure.files, {
+        mergedAt: closure.header.mergedAt,
+        repo,
+        runs: history(repo),
+        root,
+        deleted: closure.deleted,
+    });
+    return { closure, verdicts };
+}
+//# sourceMappingURL=audit.js.map

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

@@ -0,0 +1,159 @@
+/**
+ * Resolving an issue number to the change that closed it (spec Phase 4).
+ *
+ * GitHub closes an issue on a keyword match in a PR body. That is the fact
+ * batwoman exists to question, and this module is where the questioning starts:
+ * it finds the PR the keyword pointed at, when it merged, and every file it
+ * touched -- the denominator the whole report is measured against.
+ *
+ * **Nothing here ever degrades to an empty answer.** An issue with no merged
+ * closing PR, an unreachable `gh`, unparseable output, and a merged PR that
+ * reports no files at all are all thrown. An empty changed-file set would
+ * render as a clean report over a denominator of zero, which is a pass over
+ * nothing presented as a pass -- the exact defect batwoman detects, committed
+ * by batwoman.
+ */
+import { defaultSubprocess, } from '../../core/workflow-discovery.js';
+/** How long to wait on one `gh` call, in seconds. */
+const GH_TIMEOUT_SECONDS = 30;
+/** Run `gh`, or throw with the reason. Never returns a degraded result. */
+function gh(subprocess, args, what) {
+    // A throwing runner (a missing `gh`) propagates untouched: its message names
+    // the real cause, and the caller reports that rather than a guess.
+    const result = subprocess([...args], { timeout: GH_TIMEOUT_SECONDS });
+    if (result.returncode !== 0) {
+        throw new Error(`${what} failed (exit ${result.returncode}): ` +
+            `${result.stderr.trim() || 'no stderr'}`);
+    }
+    try {
+        return JSON.parse(result.stdout);
+    }
+    catch {
+        // Not treated as "nothing found". Unreadable output means the question
+        // went unanswered, and an unanswered question is not an empty answer.
+        throw new Error(`${what} returned unparseable JSON`);
+    }
+}
+/** The PR numbers GitHub records as having closed the issue. */
+function closingPrNumbers(issue, doc) {
+    const refs = doc
+        ?.closedByPullRequestsReferences;
+    const numbers = Array.isArray(refs)
+        ? refs
+            .map((r) => r?.number)
+            .filter((n) => typeof n === 'number')
+        : [];
+    if (numbers.length === 0) {
+        throw new Error(`issue ${issue} has no closing pull request, so there is no change to ` +
+            'audit. It may have been closed by hand.');
+    }
+    return numbers;
+}
+/** One PR's merge facts, or null when it never merged. */
+function readPr(subprocess, repo, number) {
+    const doc = gh(subprocess, [
+        'gh',
+        'pr',
+        'view',
+        '--repo',
+        repo,
+        String(number),
+        '--json',
+        'number,mergedAt,mergeCommit,title',
+    ], `gh pr view ${number}`);
+    if (typeof doc.mergedAt !== 'string')
+        return null;
+    const mergedAt = new Date(doc.mergedAt);
+    if (Number.isNaN(mergedAt.getTime()))
+        return null;
+    const oid = doc.mergeCommit?.oid;
+    return {
+        number,
+        mergedAt,
+        mergeSha: typeof oid === 'string' ? oid : '(unknown)',
+        subject: typeof doc.title === 'string' ? doc.title : '(no subject)',
+    };
+}
+/** The changed paths and the deleted subset, from the files endpoint. */
+function readFiles(subprocess, repo, number) {
+    const payload = gh(subprocess, [
+        'gh',
+        'api',
+        `repos/${repo}/pulls/${number}/files`,
+        '--paginate',
+        '--slurp',
+    ], `gh api pulls/${number}/files`);
+    if (!Array.isArray(payload)) {
+        throw new Error(`gh api pulls/${number}/files did not return a list`);
+    }
+    // `--paginate --slurp` yields an array of PAGES, each an array of rows --
+    // verified against the live endpoint, where a single page still arrives
+    // wrapped. `--jq` cannot do the flattening here: gh rejects `--slurp`
+    // together with `--jq`, which a fixture-only test cannot discover because
+    // the fixture never runs gh. One level is flattened, and an already-flat
+    // list is accepted so the shape is not load-bearing.
+    const rows = payload.every((page) => Array.isArray(page))
+        ? payload.flat()
+        : payload;
+    const files = [];
+    const deleted = new Set();
+    for (const row of rows) {
+        if (typeof row?.filename !== 'string')
+            continue;
+        files.push(row.filename);
+        // `status` is the only trustworthy deletion signal. An additions count of
+        // zero cannot mean deleted: a file gutted to an empty stub looks identical
+        // and is very much still there to run.
+        if (row.status === 'removed')
+            deleted.add(row.filename);
+    }
+    if (files.length === 0) {
+        throw new Error(`pull request ${number} reports no changed files, which cannot be ` +
+            'right for a merged change. Refusing to report over an empty ' +
+            'denominator.');
+    }
+    return { files, deleted };
+}
+/**
+ * Resolve `issue` to the merged change that closed it.
+ *
+ * When more than one PR is recorded as closing the issue -- GitHub permits it
+ * -- the most recently merged one wins. Picking by array order would make the
+ * report depend on the order GitHub happened to return, and the latest merge
+ * is the one whose code is actually standing in the tree.
+ */
+export async function resolveClosure(issue, repo, subprocess = defaultSubprocess) {
+    const doc = gh(subprocess, [
+        'gh',
+        'issue',
+        'view',
+        '--repo',
+        repo,
+        String(issue),
+        '--json',
+        'number,closedByPullRequestsReferences',
+    ], `gh issue view ${issue}`);
+    const candidates = closingPrNumbers(issue, doc);
+    const merged = candidates
+        .map((n) => readPr(subprocess, repo, n))
+        .filter((pr) => pr !== null)
+        .sort((a, b) => b.mergedAt.getTime() - a.mergedAt.getTime());
+    const chosen = merged[0];
+    if (chosen === undefined) {
+        throw new Error(`issue ${issue} is closed, but its closing pull request ` +
+            `(${candidates.join(', ')}) was not merged, so nothing shipped to audit.`);
+    }
+    const { files, deleted } = readFiles(subprocess, repo, chosen.number);
+    return {
+        header: {
+            issue,
+            mergeSha: chosen.mergeSha,
+            mergeSubject: chosen.subject,
+            mergedAt: chosen.mergedAt,
+        },
+        pullRequest: chosen.number,
+        files,
+        deleted,
+    };
+}
+//# sourceMappingURL=closure.js.map

package/dist/engine/analysis/batwoman/gh-history.js

@@ -0,0 +1,119 @@
+/**
+ * `RunHistoryPort` over the `gh` CLI (spec Phase 3, criterion 4).
+ *
+ * This is batwoman's only outward call, and therefore the only place where
+ * "I could not find out" can be mistaken for "it did not happen". Every
+ * failure path here is loud: a missing `gh`, a non-zero exit, and output that
+ * will not parse all throw, because the registry turns a throw into `abstain`
+ * and an abstention is the honest report. The one thing this module must never
+ * do is return an empty history for a question it failed to ask -- that would
+ * read downstream as "this workflow has never run", which is the false green
+ * batwoman was built to catch.
+ *
+ * The subprocess is injected through the same {@link SubprocessRun} seam
+ * `ticket-updater.ts` uses, so tests never shell out.
+ */
+import { defaultSubprocess, } from '../../core/workflow-discovery.js';
+/**
+ * How many runs to request per workflow.
+ *
+ * Explicit on purpose. `gh run list` defaults to 20 (the spec says 30; the CLI
+ * says otherwise) and reports nothing about the window it used, so a repo with
+ * a busy workflow would answer from a window of days and say so nowhere.
+ * Naming the number here makes the window a stated fact, and a page that fills
+ * to exactly this many rows is what {@link RunHistory.complete} reports as
+ * truncated.
+ */
+export const GH_RUN_LIMIT = 100;
+/** How long to wait on one `gh` call, in seconds. */
+const GH_TIMEOUT_SECONDS = 30;
+/**
+ * One row to a {@link WorkflowRun}, or null when it cannot be placed in time.
+ *
+ * A row with no usable `createdAt` is dropped rather than defaulted: a run
+ * with a guessed timestamp could land on either side of the merge and decide
+ * the verdict. Dropping the row loses one piece of evidence; keeping it with
+ * an invented date would manufacture one.
+ */
+function toRun(row) {
+    if (typeof row.createdAt !== 'string')
+        return null;
+    const createdAt = new Date(row.createdAt);
+    if (Number.isNaN(createdAt.getTime()))
+        return null;
+    return {
+        createdAt,
+        conclusion: typeof row.conclusion === 'string' ? row.conclusion : null,
+    };
+}
+/** The argv for one workflow's history. Kept in one place so tests can pin it. */
+function ghArgs(repo, workflowPath) {
+    return [
+        'gh',
+        'run',
+        'list',
+        '--repo',
+        repo,
+        '--workflow',
+        workflowPath,
+        '--limit',
+        String(GH_RUN_LIMIT),
+        '--json',
+        'createdAt,conclusion',
+    ];
+}
+/**
+ * A `RunHistoryPort` that reads real run history through `gh`.
+ *
+ * @param repo `owner/name`, passed explicitly so the port does not depend on
+ *   the process's working directory.
+ * @param subprocess injected for tests; defaults to the shared `spawnSync`
+ *   runner.
+ */
+export function ghRunHistory(repo, subprocess = defaultSubprocess) {
+    return {
+        // `async` so that a synchronous failure below -- a missing `gh` throws
+        // straight out of spawnSync -- reaches the caller as a REJECTED promise
+        // rather than as a throw during port construction. The registry catches
+        // rejections to record an abstention; a synchronous throw would escape it.
+        async runsForWorkflow(workflowPath) {
+            return fetchHistory(repo, workflowPath, subprocess);
+        },
+    };
+}
+function fetchHistory(repo, workflowPath, subprocess) {
+    // A throwing runner (a missing `gh` is the common one) is left to propagate
+    // untouched: its message names the real cause, and the registry will record
+    // the abstention with that message attached.
+    const result = subprocess(ghArgs(repo, workflowPath), {
+        timeout: GH_TIMEOUT_SECONDS,
+    });
+    if (result.returncode !== 0) {
+        throw new Error(`gh run list failed for ${workflowPath} (exit ${result.returncode}): ` +
+            `${result.stderr.trim() || 'no stderr'}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(result.stdout);
+    }
+    catch {
+        // Deliberately not treated as "no runs". Unreadable output means the
+        // question went unanswered, and an unanswered question is an abstention.
+        throw new Error(`gh run list returned unparseable JSON for ${workflowPath}`);
+    }
+    if (!Array.isArray(parsed)) {
+        throw new Error(`gh run list returned ${typeof parsed}, not a list, for ${workflowPath}`);
+    }
+    const runs = parsed
+        .map((row) => toRun((row ?? {})))
+        .filter((run) => run !== null);
+    return {
+        runs,
+        // Measured against the ROWS gh returned, not against the runs that
+        // survived parsing. A dropped malformed row still proves the page was
+        // full, and counting the survivors instead would report a truncated
+        // window as complete -- turning a dropped row into a false verdict.
+        complete: parsed.length < GH_RUN_LIMIT,
+    };
+}
+//# sourceMappingURL=gh-history.js.map