paperlint 3.0.0 → 3.1.1

package/skills/paper-pipeline/scripts/pipeline-check.cli.test.mjs

@@ -0,0 +1,474 @@
+/**
+ * pipeline-check.mjs as a command — the banner every edit to a paper reprints (where the paper
+ * stands and the next move), the finding list under it, the warning for a scorecard that does not
+ * parse (a misspelled current template vs the retired single-table format), and the inputs from
+ * OUTSIDE the scorecard: the text's date (git or mtime), `reviews/`, and credentials in the env.
+ */
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { utimesSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { test } from "vitest";
+import { runNode, useTempDir, writeTree } from "../../../test/support.mjs";
+import { check, newestSourceDate, parseStatus } from "./pipeline-check.mjs";
+import { readdirSync } from "node:fs";
+import { scorecard } from "./fixtures/scorecard.mjs";
+
+const SCRIPT = join(
+  dirname(fileURLToPath(import.meta.url)),
+  "pipeline-check.mjs",
+);
+const root = useTempDir("pipeline-check-cli-");
+const TODAY = "2026-09-01";
+const at = (iso) => new Date(`${iso}T12:00:00Z`);
+// The temp paper sits outside any git repository, so the text's date is its mtime: pinned before
+// every date in the scorecard fixture, so a gate is stale only when a case makes it so.
+const TEXT_DATE = "2026-08-01";
+
+/** A paper directory: `files` go in as written, `mtimes` pin `{ path: iso }` after writing. */
+const paper = (name, card, { files = {}, mtimes = {} } = {}) => {
+  const dir = join(root, name);
+  writeTree(dir, {
+    ...(card === null ? {} : { "PIPELINE-STATUS.md": card }),
+    "paper.md": "## 1. Heading\n\nProse.\n",
+    ...files,
+  });
+  for (const [rel, iso] of Object.entries({
+    "paper.md": TEXT_DATE,
+    ...mtimes,
+  }))
+    utimesSync(join(dir, rel), at(iso), at(iso));
+  return dir;
+};
+const clean = (r) => ({
+  ...r,
+  stdout: r.stdout.replaceAll(root, "<root>"),
+  stderr: r.stderr.replaceAll(root, "<root>"),
+});
+const NO_TOKENS = { OSF_TOKEN: "", GITHUB_TOKEN: "" };
+const run = (name, args = [], env = {}) =>
+  clean(
+    runNode(SCRIPT, [join(root, name), `--today=${TODAY}`, ...args], {
+      env: { ...NO_TOKENS, ...env },
+    }),
+  );
+const json = (name, env) => {
+  const r = run(name, ["--json"], env);
+  assert.equal(r.status, 0, r.stderr);
+  return JSON.parse(r.stdout);
+};
+const card = (over = {}) => scorecard(over, TODAY);
+const NEXT_CLEAN =
+  "   ➡️ NEXT: no mechanical blocker — run paper-status for the measured picture (build page count, stale gates, owner-split) before deciding it is done";
+const PAGE_NOTE =
+  "   (page count comes from repro/build-submission.sh, never from this line)";
+
+test("no scorecard: nothing to say, exit 0", () => {
+  paper("none", null);
+  assert.deepEqual(run("none"), { status: 0, stdout: "", stderr: "" });
+});
+
+test("a clean scorecard: the banner, with the deadline counted down and no finding", () => {
+  paper("clean", card({ deadline: "2026-09-11" }));
+  assert.deepEqual(run("clean"), {
+    status: 0,
+    stderr: "",
+    stdout: [
+      "📊 clean — 2026-09-11 (T−10d) · 0 open finding(s)",
+      "   verdict row: Submit-ready — every gate green, artifact reproduces clean, nothing blocking.",
+      NEXT_CLEAN,
+      PAGE_NOTE,
+      "",
+    ].join("\n"),
+  });
+});
+
+test("findings: a passed deadline counts up, a missing verdict says so, every finding is listed", () => {
+  paper(
+    "late",
+    card({
+      deadline: "2026-08-20",
+      access: { status: "☐" },
+      cites: { date: "2026-07-15" },
+    }).replace(/^\*\*Readiness verdict:\*\*.*$/m, ""),
+  );
+  const stale =
+    "cites (skill) last ran 2026-07-15, the text changed 2026-08-01 — this ☑ is stale, not green";
+  const access =
+    "access (can you physically submit?) is ☐ with -12 day(s) to the deadline — profile moderation runs up to two weeks and there is no expedite route without an institutional email";
+  assert.deepEqual(run("late"), {
+    status: 0,
+    stderr: "",
+    stdout: [
+      "📊 late — 2026-08-20 (T+12d) · 2 open finding(s)",
+      "   verdict row: (none)",
+      `   ➡️ NEXT: ${stale}`,
+      PAGE_NOTE,
+      "⚠️ pipeline-check — 2 finding(s) in <root>/late/PIPELINE-STATUS.md:",
+      `   [stale-continuous] ${stale}`,
+      `   [submit-access] ${access}`,
+      "",
+    ].join("\n"),
+  });
+});
+
+test("no deadline in the header: the banner says so, and open access is flagged without a count", () => {
+  paper(
+    "undated",
+    card({ access: { status: "" } }).replace(/ · Deadline: \S+/, ""),
+  );
+  const r = run("undated");
+  assert.equal(r.status, 0);
+  assert.match(
+    r.stdout,
+    /^📊 undated — deadline not in the header · 1 open finding\(s\)$/m,
+  );
+  assert.match(
+    r.stdout,
+    /\[submit-access\] access \(can you physically submit\?\) is blank — turn it green in the first week, not the last$/m,
+  );
+});
+
+test("open access far from the deadline is not a finding yet", () => {
+  paper("early", card({ access: { status: "◐" } }));
+  assert.deepEqual(json("early"), []);
+});
+
+test("open access inside the moderation window is flagged even when the box is blank", () => {
+  paper("blank-near", card({ deadline: "2026-09-11", access: { status: "" } }));
+  assert.deepEqual(
+    json("blank-near").map((f) => f.msg),
+    [
+      "access (can you physically submit?) is blank with 10 day(s) to the deadline — profile moderation runs up to two weeks and there is no expedite route without an institutional email",
+    ],
+  );
+});
+
+test("a continuous check that is not ☑, or ☑ without a date, is not called stale here", () => {
+  // The undated ☑ is `pipeline/undated-continuous`'s finding, not this checker's.
+  paper(
+    "not-done",
+    card({ cites: { date: "" }, render: { status: "◐", date: "2020-01-01" } }),
+  );
+  assert.deepEqual(json("not-done"), []);
+});
+
+test("check() on its own: no sections and no directory is no finding", () => {
+  assert.deepEqual(check({ sections: {}, header: "" }, {}), []);
+});
+
+test("--json prints the findings and nothing else", () => {
+  paper("js", card({ render: { date: "2026-07-20" } }));
+  assert.deepEqual(json("js"), [
+    {
+      kind: "stale-continuous",
+      msg: "render (skill) last ran 2026-07-20, the text changed 2026-08-01 — this ☑ is stale, not green",
+    },
+  ]);
+});
+
+test("without arguments it reads the current directory and today's date", () => {
+  const dir = paper("cwd", card());
+  const r = clean(runNode(SCRIPT, ["--json"], { cwd: dir, env: NO_TOKENS }));
+  assert.deepEqual(r, { status: 0, stdout: "[]\n", stderr: "" });
+});
+
+test("a misspelled current template: the warning names the sections and headings it did find", () => {
+  paper("typo", card().replace("### LOOP", "### LOPO"));
+  const r = run("typo");
+  assert.equal(r.status, 0);
+  assert.equal(r.stdout, "");
+  assert.equal(
+    r.stderr,
+    [
+      "⚠️ <root>/typo/PIPELINE-STATUS.md: expected the four sections SETUP/LOOP/CONTINUOUS/GATES, found [SETUP, CONTINUOUS, GATES].",
+      '   Parsed 4 table(s), 4 of them with an id column; headings: "PIPELINE-STATUS — harness fixture", "SETUP", "LOPO", "CONTINUOUS", "GATES".',
+      "   The template is a format contract — see paper-pipeline/references/pipeline-status-template.md.",
+      "   Until it parses, these checks are silent, which is the failure mode they exist to prevent.",
+      "",
+    ].join("\n"),
+  );
+});
+
+test("the retired single-table format is named as such, not as a typo", () => {
+  paper(
+    "legacy",
+    "Deadline: 2026-08-06\n\n| # | Gate | Status |\n|---|------|--------|\n| 1 | cites | ☑ |\n",
+  );
+  const r = run("legacy");
+  assert.equal(r.status, 0);
+  assert.match(r.stderr, /found \[none\]\.\n/);
+  assert.match(
+    r.stderr,
+    /Parsed 1 table\(s\), 0 of them with an id column; headings: none\.\n/,
+  );
+  assert.match(
+    r.stderr,
+    /this is the pre-2026-08 single-table format \(first column `#`, a row number\)/,
+  );
+});
+
+test("a scorecard with no table at all is not called legacy", () => {
+  paper("prose", "# Status\n\nNothing tabulated yet.\n");
+  const r = run("prose");
+  assert.match(
+    r.stderr,
+    /Parsed 0 table\(s\), 0 of them with an id column; headings: "Status"\.\n/,
+  );
+  assert.doesNotMatch(r.stderr, /single-table format/);
+});
+
+test("reviews/: a worst section named twice is a repeat finding; no cold read is a finding", () => {
+  paper("reviews", card(), {
+    files: {
+      "reviews/2026-08-10-writing.md": "WORST-SECTION: Abstract\n",
+      "reviews/2026-08-12-grade-paper-writing.md":
+        "  WORST-SECTION: abstract \n",
+      // Unmarked: skipped rather than guessed at, so it neither makes nor breaks the repeat.
+      "reviews/2026-08-14-writing.md": "no marker here\n",
+      "reviews/2026-08-15-writing.txt": "WORST-SECTION: intro\n",
+    },
+  });
+  assert.deepEqual(
+    json("reviews").map((f) => f.kind),
+    ["repeat-finding", "no-cold-read"],
+  );
+});
+
+test("reviews/: two different worst sections are not a repeat", () => {
+  paper("mixed", card(), {
+    files: {
+      "reviews/a-writing.md": "WORST-SECTION: abstract\n",
+      "reviews/b-writing.md": "WORST-SECTION: intro\n",
+      "reviews/c-coldread.md": "read\n",
+    },
+    mtimes: { "reviews/c-coldread.md": "2026-08-20" },
+  });
+  assert.deepEqual(json("mixed"), []);
+});
+
+test("reviews/ as a file, and a report path that is a directory, are unreadable — not a crash", () => {
+  paper("reviews-file", card(), { files: { reviews: "not a folder\n" } });
+  assert.deepEqual(
+    json("reviews-file").map((f) => f.kind),
+    ["no-cold-read"],
+  );
+  paper("reviews-dir", card(), {
+    files: {
+      "reviews/a-writing.md/inner.txt": "x",
+      "reviews/b-writing.md": "WORST-SECTION: abstract\n",
+      "reviews/c-coldread.md": "read\n",
+    },
+    mtimes: { "reviews/c-coldread.md": "2026-08-20" },
+  });
+  assert.deepEqual(json("reviews-dir"), []);
+});
+
+test("reviews/: a cold read older than the text is stale, under either spelling", () => {
+  paper("stale-cr", card(), {
+    files: { "reviews/2026-07-01-cold-read.md": "read\n" },
+    mtimes: { "reviews/2026-07-01-cold-read.md": "2026-07-01" },
+  });
+  assert.deepEqual(json("stale-cr"), [
+    {
+      kind: "stale-cold-read",
+      msg: "the cold read ran 2026-07-01, the text changed 2026-08-01 — it describes prose that no longer exists",
+    },
+  ]);
+});
+
+test("a credential in the env un-parks the blocker it clears — unless the row already shows it done", () => {
+  paper(
+    "creds",
+    card({
+      harden: { status: "◐", result: "github release pending" },
+      panel: { status: "◐", result: "artifact hosted at osf.io/abc12" },
+    }),
+  );
+  assert.deepEqual(json("creds", { GITHUB_TOKEN: "t", OSF_TOKEN: "t" }), [
+    {
+      kind: "credential-available",
+      msg: "harden (repository work) is parked as open, but GITHUB_TOKEN is set in this environment — do it over the API yourself. Do not report this as waiting on the human.",
+    },
+  ]);
+  assert.deepEqual(json("creds"), []);
+});
+
+test("the text's date ignores dot-dirs, node_modules, repro, build outputs and anything past depth 3", () => {
+  const late = "2026-09-20"; // after every row date: walked, any of these would make the gates stale
+  const files = {
+    ".cache/paper.md": "x",
+    // eslint-disable-next-line port/js-install-path -- a fixture directory the walk must skip, not an install location
+    "node_modules/pkg/paper.md": "x",
+    "repro/main.tex": "x",
+    "build/main.tex": "x",
+    "a/b/c/d/deep.tex": "x",
+  };
+  paper("walk", card(), {
+    files,
+    mtimes: Object.fromEntries(Object.keys(files).map((f) => [f, late])),
+  });
+  assert.deepEqual(json("walk"), []);
+});
+
+test("a paper with no source text has no date, so nothing can be stale", () => {
+  const dir = paper("nosrc", card({ cites: { date: "2020-01-01" } }));
+  execFileSync("rm", [join(dir, "paper.md")]);
+  assert.deepEqual(json("nosrc"), []);
+});
+
+test("inside git: a committed file is dated by its commit, a dirty or ignored one by its mtime", () => {
+  // The paper is its own repository and the command runs from elsewhere (this package's repo):
+  // git has to be asked from where the file lives, or every paper outside the cwd's repository
+  // silently falls back to mtimes.
+  const dir = paper("repo", card({ cites: { date: "2026-08-20" } }), {
+    files: { "sec.tex": "a", "draft.md": "b", ".gitignore": "draft.md\n" },
+    mtimes: { "sec.tex": "2026-08-25", "draft.md": "2026-08-22" },
+  });
+  const git = (...a) =>
+    execFileSync("git", ["-c", "user.name=t", "-c", "user.email=t@t", ...a], {
+      cwd: dir,
+      env: {
+        ...process.env,
+        GIT_COMMITTER_DATE: "2026-08-02T12:00:00Z",
+        GIT_AUTHOR_DATE: "2026-08-02T12:00:00Z",
+      },
+      stdio: "ignore",
+    });
+  git("init", "-q");
+  git("add", "paper.md", ".gitignore", "PIPELINE-STATUS.md");
+  git("commit", "-qm", "init");
+  // A checkout rewrites mtimes; the commit date is what the text's date is.
+  utimesSync(join(dir, "paper.md"), at("2026-09-20"), at("2026-09-20"));
+  const stale = (changed) => [
+    `cites (skill) last ran 2026-08-20, the text changed ${changed} — this ☑ is stale, not green`,
+  ];
+  // sec.tex is untracked, i.e. dirty: its mtime (08-25) is the newest date.
+  assert.deepEqual(
+    json("repo").map((f) => f.msg),
+    stale("2026-08-25"),
+  );
+  execFileSync("rm", [join(dir, "sec.tex")]);
+  // paper.md by its commit (08-02, not its 09-20 mtime); draft.md is ignored — no status, no
+  // log — so by its mtime (08-22), which is now the newest.
+  assert.deepEqual(
+    json("repo").map((f) => f.msg),
+    stale("2026-08-22"),
+  );
+});
+
+test("parseStatus: a heading with no Latin word is no section; a short or id-less row is skipped", () => {
+  const parsed = parseStatus(
+    [
+      "## Итоги",
+      "| id | Work | Skill | Status |",
+      "|----|------|-------|--------|",
+      "| x | only | three |",
+      "| ** | a | b | ☑ |",
+      "",
+      "## SETUP",
+      "| id | Work | Skill | Status |",
+      "|----|------|-------|--------|",
+      "| idea | w | s | nothing recognisable |",
+    ].join("\n"),
+  );
+  assert.deepEqual(parsed.sections, {
+    SETUP: [
+      {
+        id: "idea",
+        name: "w",
+        skill: "s",
+        status: "",
+        date: null,
+        raw: "idea | w | s | nothing recognisable",
+        section: "SETUP",
+        heading: "SETUP",
+      },
+    ],
+  });
+  assert.deepEqual(parsed.shape, {
+    tables: 2,
+    scorecardTables: 2,
+    headings: ["Итоги", "SETUP"],
+  });
+});
+
+test("newestSourceDate: a subdirectory that cannot be listed is skipped, the rest still dated", () => {
+  const dir = paper("unlistable", card(), {
+    files: { "locked/late.tex": "x" },
+    mtimes: { "locked/late.tex": "2026-09-20" },
+  });
+  const readdir = (d) => {
+    if (d.endsWith("locked"))
+      throw Object.assign(new Error("EACCES: permission denied"), {
+        code: "EACCES",
+      });
+    return readdirSync(d, { withFileTypes: true });
+  };
+  assert.deepEqual(
+    [newestSourceDate(dir, { readdir }), newestSourceDate(dir)],
+    [TEXT_DATE, "2026-09-20"],
+  );
+});
+
+test("parseStatus reads a token stream that breaks markdown-it's shape without throwing", () => {
+  const T = (type, content) =>
+    content === undefined ? { type } : { type, content };
+  const tokens = [
+    // a heading whose inline token is missing
+    T("heading_open"),
+    T("paragraph_open"),
+    T("heading_open"),
+    T("inline", "SETUP"),
+    // a table with no thead, a cell before any row, a row closed that was never opened
+    T("table_open"),
+    T("td_open"),
+    T("inline", "stray"),
+    T("tr_close"),
+    T("table_close"),
+    // a scorecard table: a header cell with no inline, an empty row, then one real row — and no
+    // table_close at all, so the table runs to the end of the stream
+    T("table_open"),
+    T("thead_open"),
+    T("tr_open"),
+    T("th_open"),
+    T("inline", "id"),
+    T("th_open"),
+    T("th_close"),
+    T("tr_close"),
+    T("thead_close"),
+    T("tr_open"),
+    T("tr_close"),
+    T("tr_open"),
+    ...["idea", "w", "s", "☑"].flatMap((c) => [T("td_open"), T("inline", c)]),
+    T("tr_close"),
+  ];
+  const parsed = parseStatus("ignored", { parse: () => tokens });
+  assert.deepEqual(parsed.shape, {
+    tables: 2,
+    scorecardTables: 1,
+    headings: ["", "SETUP"],
+  });
+  assert.deepEqual(
+    parsed.sections.SETUP.map((r) => [r.id, r.name, r.skill, r.status]),
+    [["idea", "w", "s", "☑"]],
+  );
+});
+
+test("check(): rows built by another caller without their raw text are read as empty", () => {
+  const saved = process.env.GITHUB_TOKEN;
+  process.env.GITHUB_TOKEN = "t";
+  try {
+    assert.deepEqual(
+      check(
+        { sections: { GATES: [{ id: "g", status: "◐" }] }, header: "" },
+        {},
+      ),
+      [],
+    );
+  } finally {
+    if (saved === undefined) delete process.env.GITHUB_TOKEN;
+    else process.env.GITHUB_TOKEN = saved;
+  }
+});

package/skills/paper-pipeline/scripts/pipeline-check.harness.mjs

@@ -40,6 +40,7 @@ import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { consumerRoot } from "./consumer.mjs";
+import { scorecard as makeScorecard } from "./fixtures/scorecard.mjs";
 const HERE = dirname(fileURLToPath(import.meta.url));
 
 const ROOT = consumerRoot();
@@ -50,74 +51,12 @@ const tmp = realpathSync(mkdtempSync(join(tmpdir(), "pipecheck-harness-")));
 // has something real to compare against. Every clean row therefore carries today's date: hard-coding
 // a date would make this suite start failing on its own the following morning.
 const TODAY = new Date().toISOString().slice(0, 10);
-const FAR = "2027-12-31";
 
 const ENV = { ...process.env };
 delete ENV.OSF_TOKEN;
 delete ENV.GITHUB_TOKEN;
 
-/**
- * A scorecard with the four sections the template requires, all green. `over` replaces individual
- * cells: `{ cites: { date: "2020-01-01" } }`, `{ verdict: "…" }`, `{ deadline: "2026-08-18" }`,
- * `{ tail: "…" }` for anything appended after the last section, `{ preamble: "…" }` for anything
- * inserted BEFORE the first heading (the only way to plant a row under no heading at all).
- */
-function scorecard(over = {}) {
-  const r = (id, status = "☑", date = TODAY) => ({
-    id,
-    status,
-    date,
-    ...(over[id] ?? {}),
-  });
-  const row = (o, ...mid) =>
-    `| ${o.id} | work | ${o.skill ?? "skill"} | ${mid.length ? mid.join(" | ") + " | " : ""}${o.status} | ${o.date} | ${o.result ?? "result"} | — |`;
-  // The GATES `Requires` cell, canonical by default so the baseline is silent — `{ structure: {
-  // requires: "render" } }` plants a dropped edge. `harden` deliberately declares four of its five
-  // canonical inputs: the fifth (`priordelta`) has no row in this fixture, and the clean case asserts that the checker stays
-  // quiet about an edge there is nowhere to point at.
-  const req = (id, dflt) => over[id]?.requires ?? dflt;
-  const verdict =
-    over.verdict ??
-    "Submit-ready — every gate green, artifact reproduces clean, nothing blocking.";
-  return [
-    "# PIPELINE-STATUS — harness fixture",
-    `Venue: Fixture Workshop · Deadline: ${over.deadline ?? FAR} · Blind: double · State: drafting`,
-    "",
-    `**Readiness verdict:** ${verdict}`,
-    "",
-    over.preamble ?? "",
-    "",
-    "### SETUP",
-    "| id | Work | Skill | Status | Date | Result | Open |",
-    "|----|------|-------|--------|------|--------|------|",
-    row(r("idea")),
-    row(r("access")),
-    row(r("frame")),
-    "",
-    "### LOOP",
-    "| id | Work | Skill | Status | Date | Result | Open |",
-    "|----|------|-------|--------|------|--------|------|",
-    row(r("study")),
-    row(r("draft")),
-    row(r("arc")),
-    "",
-    "### CONTINUOUS",
-    "| id | Trigger | Skill | Status | Date | Result | Open |",
-    "|----|---------|-------|--------|------|--------|------|",
-    row(r("cites")),
-    row(r("render")),
-    "",
-    "### GATES",
-    "| id | Gate | Skill | Requires | Status | Date | Result | Open |",
-    "|----|------|-------|----------|--------|------|--------|------|",
-    row(r("structure"), req("structure", "render, arc")),
-    row(r("writing"), req("writing", "draft, arc, structure")),
-    row(r("panel"), req("panel", "structure, writing")),
-    row(r("harden"), req("harden", "panel, structure, writing, cites")),
-    "",
-    over.tail ?? "",
-  ].join("\n");
-}
+const scorecard = (over = {}) => makeScorecard(over, TODAY);
 
 /** Write a fixture and return the findings pipeline-check reports, verbatim. */
 function findings(name, over = {}, today = TODAY) {

package/skills/paper-pipeline/scripts/pipeline-check.mjs

@@ -106,7 +106,7 @@
  *     not an id — and is therefore not adopted; see the diagnostic in `main`.
  */
 import { readFileSync, readdirSync, statSync, existsSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { execFileSync } from "node:child_process";
 import MarkdownIt from "markdown-it";
 import {
@@ -238,7 +238,7 @@ function readTable(toks) {
  * read is still skipped (`continue`), just silently — the linter speaks about it, and to the
  * precision of a line.
  */
-export function parseStatus(text) {
+export function parseStatus(text, { parse = (t) => md.parse(t, {}) } = {}) {
   const sections = {};
   let verdict = "";
   let header = "";
@@ -249,7 +249,7 @@ export function parseStatus(text) {
   let section = null;
   let heading = "(before the first heading)";
 
-  const tokens = md.parse(currentPart(text), {});
+  const tokens = parse(currentPart(text));
   for (let i = 0; i < tokens.length; i++) {
     const t = tokens[i];
 
@@ -291,8 +291,9 @@ export function parseStatus(text) {
       const joined = c.join(" | ");
       const row = {
         id,
-        name: c[1] ?? "",
-        skill: c[2] ?? "",
+        // `c.length >= 4` above, and every cell is a string (readTable), so both exist.
+        name: c[1],
+        skill: c[2],
         // The `Requires` column is no longer read here: all three checks that ate it
         // (`gate-missing-input` · `gate-stale-input` · `unknown-input`) and the check of the
         // declaration itself (`undeclared-input`) moved into `eslint-rules/pipeline-status.mjs`.
@@ -349,15 +350,18 @@ const GENERATED_DIRS = new Set([
   "artifact-anon",
 ]);
 
-function newestSourceDate(dir) {
+export function newestSourceDate(
+  dir,
+  { readdir = (d) => readdirSync(d, { withFileTypes: true }) } = {},
+) {
   const sources = [];
   const walk = (d, depth) => {
     if (depth > 3) return;
     let entries;
     try {
-      entries = readdirSync(d, { withFileTypes: true });
+      entries = readdir(d);
     } catch {
-      return;
+      return; // a directory that cannot be listed (EACCES) holds no source this walk can date
     }
     for (const e of entries) {
       if (
@@ -378,11 +382,23 @@ function newestSourceDate(dir) {
   let newest = "";
   for (const p of sources) {
     let when; // no initializer: both branches below assign it (2026-08-28)
+    // Asked from the file's own directory: from the caller's cwd, a paper in another repository
+    // (or the cwd outside any) made git throw, and every date silently became an mtime.
+    const QUIET_GIT = {
+      cwd: dirname(p),
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    };
     try {
       // Dirty file: the edit is real and uncommitted, so mtime is the honest answer.
-      const dirty = execFileSync("git", ["status", "--porcelain", "--", p], {
-        encoding: "utf8",
-      }).trim();
+      // stderr is not the reader's: outside a repository git prints `fatal: … is outside
+      // repository` and throws, and the catch below already answers with the mtime. Inherited,
+      // that line reached the person's terminal under a banner that was otherwise correct.
+      const dirty = execFileSync(
+        "git",
+        ["status", "--porcelain", "--", p],
+        QUIET_GIT,
+      ).trim();
       // 🔴 EMPTY OUTPUT FROM `git log` IS NOT A DATE. The command exits 0 and prints NOTHING when
       // a path has no history: a shallow clone (`actions/checkout` defaults to `fetch-depth: 1`), a
       // file outside git, a file inside `node_modules`. Previously that empty value went on as
@@ -398,16 +414,18 @@ function newestSourceDate(dir) {
       // 34784079821).
       const logged = dirty
         ? ""
-        : execFileSync("git", ["log", "-1", "--format=%cs", "--", p], {
-            encoding: "utf8",
-          }).trim();
+        : execFileSync(
+            "git",
+            ["log", "-1", "--format=%cs", "--", p],
+            QUIET_GIT,
+          ).trim();
       when = logged || new Date(statSync(p).mtimeMs).toISOString().slice(0, 10);
     } catch {
       when = new Date(statSync(p).mtimeMs).toISOString().slice(0, 10); // no git here: fall back
     }
     if (when > newest) newest = when;
   }
-  return newest || null;
+  return newest; // non-empty: every source above got a date
 }
 
 // ── checks ───────────────────────────────────────────────────────────────────
@@ -556,12 +574,10 @@ export function check({ sections, header }, { sourceDate, today, dir }) {
     // `done` is checked against the row TEXT, not the row's status box: a multi-axis gate like
     // harden stays ⚠ for reasons that have nothing to do with this credential, and firing on its
     // status would mean nagging about an upload that already happened.
-    const row = [...all.values()].find(
-      (r) =>
-        what.re.test(r.raw ?? "") &&
-        !DONE.has(r.status) &&
-        !what.done.test(r.raw ?? ""),
-    );
+    const row = [...all.values()].find((r) => {
+      const text = r.raw ?? ""; // a row built by another caller may carry no raw text
+      return what.re.test(text) && !DONE.has(r.status) && !what.done.test(text);
+    });
     if (row) {
       add(
         "credential-available",