@bongos/core 1.19.757 → 1.19.759

package/.bongos-core.json

@@ -2,11 +2,11 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.757",
-  "core_contract": "1.19.757",
-  "source_commit": "cc213a1bab1fc07008953502c035d32a98ced469",
+  "core_version": "1.19.759",
+  "core_contract": "1.19.759",
+  "source_commit": "707e9f0b5bf49699402632ba77c655817675f27c",
   "source_ref": "HEAD",
-  "built_at": "2026-09-16T02:31:57.888Z",
+  "built_at": "2026-09-16T03:03:00.033Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 483,
@@ -17,7 +17,7 @@
     "gate": "passed"
   },
   "file_count": 2623,
-  "tree_sha256": "6dfa78abe36908cd3c7762f36e1145d5ca9a22362b4825d6eb8c240e05a01815",
+  "tree_sha256": "72ddc6e8bfc5b6eb4aa5ab50108bbe35d4639bb91cad6318c0d6359b3c86ceec",
   "files": [
     {
       "path": ".claude/skills/ask-for-help/SKILL.md",
@@ -2512,7 +2512,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "c415a541beec31293c9fe17473fce5706b0c043818a3da9d2c092d6a36892a12"
+      "sha256": "1c38ce9a7932e516d69df1e3deaf499f2a8e10ef545e8d4621919eef11a14b8a"
     },
     {
       "path": "docs/modules-contract.md",
@@ -5757,7 +5757,7 @@
     {
       "path": "modules/lifecycle/ship-card.js",
       "mode": "0000644",
-      "sha256": "c0e5a079c586e689d569d764526be5d99808262c9773ef17902e2416047494ab"
+      "sha256": "0822f317a777c624880b86a02f9c63680fead1fdab79b13ba308801bed04a036"
     },
     {
       "path": "modules/lifecycle/ship-preflight.js",
@@ -7567,12 +7567,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "93d77133102c1137fe1e2772f30fabcd7e4630aece1c1ec238db81580f23f634"
+      "sha256": "d3aebc78f2bcf902f69e9f27bb7375410de5851af241dbaebf7aefe729465f69"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "eb18ccfda9df0b09d536acaff0fdb18df77860d53a35cfa65b41cc1aa70e361c"
+      "sha256": "83cc5d9eb22a0201d8a6bca2a74392b23eb9713aa78a651200552a3e2710b273"
     },
     {
       "path": "public-docs/index.html",
@@ -9382,7 +9382,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "9798743d1dae3c952b257d48b1ee56341bf0a946504ebb6be66fd88f1a8cddcd"
+      "sha256": "8ec75227e0ef1df2b932e943d085151cbb47133212aae42c86b425fb664a3c4c"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -10882,7 +10882,7 @@
     {
       "path": "tests/government_parity.mjs",
       "mode": "0000644",
-      "sha256": "0c619508691d41f41b0fbbb1d6939ba9ac7fde2ef4ec08ae7622bfa70bfbf624"
+      "sha256": "0d2df586d3ee58990b611799334e21f59ad69292285a787e776c16ef11c64625"
     },
     {
       "path": "tests/government_principals.mjs",
@@ -12587,7 +12587,7 @@
     {
       "path": "tests/ship_card.mjs",
       "mode": "0000644",
-      "sha256": "aa56710e7655349b64c5decad5d47ed5df1e1cbaeed40d2c33084a9dbe634899"
+      "sha256": "67acdeb4d84a312af063c8a152724a5e81dfe7beb7d1d0b9bee2d942cc0bebd0"
     },
     {
       "path": "tests/ship_card_injection.mjs",

package/docs/module-api-changelog.md

@@ -1988,5 +1988,9 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.755 with no explicit bump. run 35047623582. (task 1002620)
   1.19.757 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.19.756 with no explicit bump. run 35048307666. (task 1002620)
+  1.19.758 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.757 with no explicit bump. run 35049006030. (task 1002620)
+  1.19.759 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.758 with no explicit bump. run 35050268139. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/modules/lifecycle/ship-card.js

@@ -88,6 +88,39 @@ function stageFor(postGradeStatus) {
   return 'failed';
 }
 
+// Did the grade fail to HAPPEN, rather than fail? (task 1002892)
+//
+// stageFor() collapses every non-shipped, non-confirmed outcome into 'failed',
+// whose one presentation is red / "Needs fixes" / "grade failed". An OUTAGE lands
+// there too, and then the card tells a builder their code was rejected when in
+// fact nothing judged it: on task 1002459 a logged-out CLI killed all four panel
+// workers and the builder got a 0/10 "grade failed" card with an EMPTY issues[],
+// then went looking for code problems that did not exist. ship.js has always said
+// this correctly in its CLI text ("GRADER UNAVAILABLE ... NOT a quality
+// rejection") and the server excludes unavailable panels from its aggregates —
+// only the card lagged.
+//
+// Returns the outage kind or null. Pure, and reads ONLY the signals the server
+// already sets, so the card never re-derives a verdict of its own:
+//   'panel'   — the whole panel never produced a signal (#943). Unambiguous.
+//   'cq_lens' — the gating code_quality lens alone went dark (task 1003318). This
+//               one carries a guard: it is only an outage while no lens raised a
+//               blocker/major. A dark lens beside a real finding is a rejection
+//               with a missing axis, and must keep the ordinary red card.
+//
+// The twin of this predicate is formatGradeOutcome in scripts/gds/ship-grade-steps.js,
+// which decides the same two shapes for the CLI text. Change one, look at the other.
+function gradeUnavailability(grade) {
+  const g = grade || {};
+  const s = g.signals || {};
+  if (s.panel_outcome === 'unavailable') return 'panel';
+  const issues = Array.isArray(g.issues) ? g.issues : [];
+  const substantive = issues.some((i) => i && (i.severity === 'blocker' || i.severity === 'major'));
+  const scores = g.rubric_scores || {};
+  if (s.cq_lens_unavailable === true && scores.code_quality === null && !substantive) return 'cq_lens';
+  return null;
+}
+
 // The one canonical journey every card draws, in order. Each node conjugates to
 // three forms — done (past participle), active (present continuous), future (bare
 // verb) — so the same stage reads 'built' / 'building' / 'build' depending on
@@ -103,6 +136,9 @@ const FORMS = Object.freeze({
   ship: { done: 'shipped', active: 'shipping', future: 'ship' },
 });
 const GRADE_FAILED = 'grade failed';
+// task 1002892: the confirm node's word when the grade did not RUN. Two words, so
+// the " → " joint logic that already keeps 'grade failed' intact covers it too.
+const NOT_GRADED = 'not graded';
 
 // The journey, mapped: one entry per PIPELINE node, conjugated + classified by
 // position relative to the current node (`cfg.at`). Both renderers consume this
@@ -118,7 +154,10 @@ function trailSteps(cfg) {
     const f = FORMS[key];
     if (i < at) return { word: f.done, state: 'done', checked: true, bold: false };
     if (i === at) {
-      if (cfg.currentKind === 'failed') return { word: GRADE_FAILED, state: 'current', checked: false, bold: true };
+      // task 1002892: the same node reads 'not graded' when the grade never ran.
+      // cfg.trailWord is set only by the outage override in buildCardModel; every
+      // other caller leaves it undefined and gets GRADE_FAILED exactly as before.
+      if (cfg.currentKind === 'failed') return { word: cfg.trailWord || GRADE_FAILED, state: 'current', checked: false, bold: true };
       if (cfg.currentKind === 'done') return { word: f.done, state: 'current', checked: true, bold: true };
       return { word: f.active, state: 'current', checked: false, bold: true }; // 'active'
     }
@@ -279,9 +318,24 @@ function buildCardModel(input = {}) {
   const landBailed = !!(stage === 'confirmed' && land && land.ok === false && !land.pending && land.reason);
   // A bailed land is not "confirmed — landing". Recolor the banner to match the
   // truth; the underlying STAGES entry is left untouched (it's frozen + shared).
+  // task 1002892: an outage is not a rejection. Same shape as landBailed above —
+  // recolor a copy, never mutate the frozen shared STAGES entry — and equally
+  // absent-signal-safe: a grade carrying no outage signals yields null here, so
+  // every pre-existing caller renders exactly as it did before.
+  // `input.grade`, not the `grade` local below — that is declared after this line.
+  const outage = stage === 'failed' ? gradeUnavailability(input.grade) : null;
   const cfg = landBailed
     ? { ...baseCfg, tone: 'warning', icon: 'ti-alert-triangle', statusWord: 'Not landed', headline: (id) => `Task #${id} confirmed — NOT landed` }
-    : baseCfg;
+    : outage
+      ? {
+        ...baseCfg,
+        tone: 'warning',
+        icon: 'ti-cloud-off',
+        statusWord: 'Could not grade',
+        headline: (id) => `Task #${id} — could not grade`,
+        trailWord: NOT_GRADED,
+      }
+      : baseCfg;
   const brand = input.brand || safeBrand();
   const taskId = input.taskId;
   const grade = input.grade || {};
@@ -319,7 +373,15 @@ function buildCardModel(input = {}) {
     // Grade: pass · panel N/N | skipped | fail · N issues
     let gradeText = null;
     let gradeCls = 'cc-good';
-    if (stage === 'failed') {
+    if (outage) {
+      // task 1002892: recoloring the banner alone was not enough — the Grade row
+      // and its HTML chip still read a red 'fail' right beside the amber "Could
+      // not grade", which is the same rejection signal this change exists to
+      // remove, just one line lower. There is no score to report when nothing
+      // ran, so say that instead of reporting a verdict.
+      gradeText = 'not graded';
+      gradeCls = '';
+    } else if (stage === 'failed') {
       gradeText = issues.length ? `fail · ${issues.length} issue${issues.length === 1 ? '' : 's'}` : 'fail';
       gradeCls = 'cc-bad';
     } else if (grade.skipped) {
@@ -411,9 +473,17 @@ function buildCardModel(input = {}) {
 
   // task 1002541: a bail knows the precise recovery command (re-run the ship,
   // re-auth, pass --db-only…), which beats the stage's generic '/merge-mode'.
+  // task 1002892: 'Fix & re-grade' is wrong advice after an outage — there is
+  // nothing to fix, and telling a builder otherwise is what sent one hunting
+  // through a diff for findings that were never produced. Retry instead. For a
+  // total panel outage the CLI's diagnostic also points at /grader-health, but the
+  // card gets ONE action, and re-running the grade is the step that either works
+  // or reproduces the outage with its reason.
   const action = (landBailed && land.nextStep)
     ? { kind: 'prompt', label: 'Land it', cmd: land.nextStep }
-    : nextActionFor(stage, { taskId, discipline: input.discipline, sandboxUrl: input.sandboxUrl });
+    : outage
+      ? { kind: 'prompt', label: 'Try grading again', cmd: `node scripts/gds/ship.js ${taskId} --regrade` }
+      : nextActionFor(stage, { taskId, discipline: input.discipline, sandboxUrl: input.sandboxUrl });
 
   return {
     stage, cfg, brand, taskId,
@@ -724,7 +794,7 @@ function emitCard(model, taskId, { log = console.log, widgetsEnabled = true } =
 }
 
 module.exports = {
-  STAGES, TONE, stageFor, buildCardModel, renderMonospaceCard, renderCardHtml, emitCard,
+  STAGES, TONE, stageFor, gradeUnavailability, buildCardModel, renderMonospaceCard, renderCardHtml, emitCard,
   // task 1001730 — the guaranteed one-line confirmation (pure; every stage pinned).
   confirmLine,
   // task 1003155 — the one-line sanitizer + the whole-line cap, exported so the

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.757",
+  "version": "1.19.759",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.757",
+      "version": "1.19.759",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.757",
+  "version": "1.19.759",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/src/module-api.js

@@ -71,7 +71,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.757'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.759'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/government_parity.mjs

@@ -237,6 +237,166 @@ test('B0: every guards note that names a concrete route names one that EXISTS',
     `guards notes point at routes that do not exist — fix the note (or the route), never ignore it:\n  ${dangling.join('\n  ')}`);
 });
 
+// ═══ B0b — a guards note naming a PAGE GATE names a live one, for its own atom ══
+//
+// task 1002878, from idea 1000625 (and independently from the BV1.R107 ship grade's
+// hacker worker). B0 above pins a note that names a ROUTE. A note that names a page
+// GATE was checked by nothing at all, and the `guards` field is the route-to-atom map
+// every migration is instructed to read as authoritative.
+//
+// WHAT WENT WRONG ONCE. page.view.builder's note read 'authenticated hall pages
+// (requireNonXenosPage / requireBuilderPage)'. Those two gates never admitted the same
+// people: requireBuilderPage enforces page.view.public (floor xenos), requireNonXenosPage
+// enforced page.view.builder (floor thetes). Migrating requireBuilderPage onto
+// page.view.builder on the strength of that note would have locked every Xenos out of
+// Work, Settings, pair, atlas, goals, roadmap and task-detail. R107 caught it by hand and
+// used the right atom, so no lockout ever shipped — but the note stayed wrong, and the
+// next reader had no reason to distrust it.
+//
+// This check would have failed on that note the day it was written: requireBuilderPage
+// enforces page.view.public, not page.view.builder, so the pair disagrees mechanically.
+//
+// IT ALSO CATCHES THE STALE HALF. Task 1003450 has since deleted requireNonXenosPage
+// along with /not-ready. A note still naming a gate that no longer exists reads as
+// authoritative and resolves to nothing; an unknown gate name is therefore a failure
+// here, not a skip — failing open is how the first version of this problem survived.
+//
+// PARSED FROM SOURCE, NOT IMPORTED. PAGE_GATES is internal to auth.js's page-gate
+// dispatcher and deliberately unexported. Exporting it so a test could read it would
+// widen the surface of a PROTECTED file (src/bongos/auth.js, group authz) for a test's
+// convenience — the same trade tests/government_protected_surfaces.mjs declines for
+// HARD_FLOOR_GLOBS, and for the same reason.
+// PURE, and split out from the live assertion deliberately. Today's catalog is CORRECT
+// (task 1003450 fixed the one bad note), so a check that only asserts "no problems
+// against the real tree" passes without ever executing the branches that find one — a
+// capture-group swap could make it vacuous forever and nothing would say so. The module's
+// own precedent for a load-bearing invariant is government_ownership_scope.mjs F5–F8,
+// which loads a MUTATED copy to prove each assert actually fires; these two functions are
+// what let this do the same, in the negative tests below.
+function parsePageGates(src) {
+  const block = src.match(/const PAGE_GATES = Object\.freeze\(\{([\s\S]*?)\n\}\);/);
+  if (!block) return null; // caller decides whether an absent table is fatal
+  const out = new Map();
+  // Each entry's own object literal is bounded by [^}]* so the scan cannot run past a
+  // gate that lacks a `permission` key and silently adopt the NEXT gate's. `permission`
+  // is then found ANYWHERE inside that literal rather than assumed to come first —
+  // requireProjectCuratePage already carries a second key, and key order in an object
+  // literal is not a contract anyone maintains.
+  for (const m of block[1].matchAll(/(require[A-Za-z]*Page):\s*Object\.freeze\(\{([^}]*)\}\)/g)) {
+    const perm = m[2].match(/permission:\s*'([^']+)'/);
+    if (perm) out.set(m[1], perm[1]);
+  }
+  return out;
+}
+
+// Any require*Page identifier mentioned anywhere in a guards note, prose included —
+// which is the whole point, since B0's route regex only ever looked at the leading
+// `METHOD /path` and prose went entirely unchecked.
+const PAGE_GATE_RE = /\b(require[A-Za-z]*Page)\b/g;
+
+// The comparison itself. Returns every disagreement plus how many notes participated,
+// so the caller can tell "nothing is wrong" from "nothing was looked at".
+function guardGateProblems(gates, permissions) {
+  const problems = [];
+  let named = 0;
+  for (const p of permissions) {
+    for (const [, gate] of String(p.guards || '').matchAll(PAGE_GATE_RE)) {
+      named += 1;
+      if (!gates.has(gate)) {
+        problems.push(`${p.key}: names '${gate}', which is not a gate in PAGE_GATES — `
+          + 'either the gate was deleted and the note was left behind, or the name is a typo.');
+        continue;
+      }
+      if (gates.get(gate) !== p.key) {
+        problems.push(`${p.key}: names '${gate}', but that gate enforces '${gates.get(gate)}'. `
+          + 'A guards note is the route-to-atom map a migration reads as authoritative, so a '
+          + 'gate listed against the wrong atom is an instruction to gate the wrong audience.');
+      }
+    }
+  }
+  return { problems, named };
+}
+
+test('B0b: a guards note naming a page gate names a live one, for its own atom', () => {
+  const gates = parsePageGates(fs.readFileSync(path.join(ROOT, 'src', 'bongos', 'auth.js'), 'utf8'));
+  assert.ok(gates, 'could not find the PAGE_GATES table in src/bongos/auth.js — if it '
+    + 'moved or changed shape, teach this test the new one rather than deleting it: it is '
+    + 'the only thing checking that a guards note names a gate that agrees with it.');
+  assert.ok(gates.size >= 4,
+    `fixture sanity: parsed ${gates.size} page gate(s) out of auth.js's PAGE_GATES, and the `
+    + 'table has held at least four since task 1003450 removed the two dead ones. A parse '
+    + 'returning few or none makes every assertion below vacuous.');
+
+  const { problems, named } = guardGateProblems(gates, FLOORED);
+  assert.ok(named >= 1,
+    'fixture sanity: no guards note named a page gate at all. One does today '
+    + '(page.view.government → requireGovernmentPage), so either the note was removed — in '
+    + 'which case delete this floor deliberately — or PAGE_GATE_RE has stopped matching and '
+    + 'this test is now checking nothing.');
+  assert.deepEqual(problems, [],
+    `guards notes disagree with the page gates they name:\n  ${problems.join('\n  ')}`);
+});
+
+// ── B0b negative fixtures — proof the check above can actually FAIL ───────────────
+// The real catalog is correct, so B0b passing proves only that it found no problem, not
+// that it can find one. These replay the HISTORICAL defect verbatim against a synthetic
+// pair, which is the repeatable form of the throwaway probe that was run by hand.
+
+const GATES_FIXTURE = new Map([
+  ['requireBuilderPage', 'page.view.public'],
+  ['requireGovernmentPage', 'page.view.government'],
+]);
+
+test('B0b catches the original defect: a gate listed against the WRONG atom', () => {
+  // page.view.builder's note as it actually stood — requireBuilderPage enforces
+  // page.view.public, so migrating on the strength of it would have locked every Xenos
+  // out of Work, Settings, pair, atlas, goals, roadmap and task-detail.
+  const { problems, named } = guardGateProblems(GATES_FIXTURE, [
+    { key: 'page.view.builder', guards: 'authenticated hall pages (requireBuilderPage)' },
+  ]);
+  assert.equal(named, 1);
+  assert.equal(problems.length, 1);
+  assert.match(problems[0], /names 'requireBuilderPage', but that gate enforces 'page\.view\.public'/);
+});
+
+test('B0b catches a note left pointing at a DELETED gate', () => {
+  // requireNonXenosPage went with /not-ready in task 1003450. A note outliving its gate
+  // reads as authoritative and resolves to nothing, so an unknown name must FAIL here
+  // rather than skip — failing open is how the original problem survived unnoticed.
+  const { problems } = guardGateProblems(GATES_FIXTURE, [
+    { key: 'page.view.builder', guards: 'authenticated hall pages (requireNonXenosPage)' },
+  ]);
+  assert.equal(problems.length, 1);
+  assert.match(problems[0], /names 'requireNonXenosPage', which is not a gate in PAGE_GATES/);
+});
+
+test('B0b stays silent on a note whose gate agrees with it, and on notes naming none', () => {
+  // The permissive half, asserted as deliberately as the strict ones: a correct note and
+  // a prose-only note must BOTH pass, or the check would just be noise someone disables.
+  const { problems, named } = guardGateProblems(GATES_FIXTURE, [
+    { key: 'page.view.government', guards: 'the government pages — /watch (requireGovernmentPage)' },
+    { key: 'page.view.builder', guards: 'nothing in the core today — seeded and attachable' },
+  ]);
+  assert.deepEqual(problems, []);
+  assert.equal(named, 1, 'only the note naming a gate participates');
+});
+
+test('parsePageGates reads permission wherever it sits, and never borrows a sibling gate\'s', () => {
+  // The nit the grade raised: the old inner regex assumed `permission` came first in a
+  // gate's literal. It does today; key order is not a contract. A gate with no permission
+  // key at all must be DROPPED, never silently given the next gate's.
+  const gates = parsePageGates([
+    'const PAGE_GATES = Object.freeze({',
+    "  requireSecondKeyPage: Object.freeze({ deniedTo: '/builders', permission: 'a.b' }),",
+    "  requireNoPermissionPage: Object.freeze({ deniedTo: '/builders' }),",
+    "  requireNormalPage: Object.freeze({ permission: 'c.d', deniedTo: '/builders' }),",
+    '});',
+  ].join('\n'));
+  assert.equal(gates.get('requireSecondKeyPage'), 'a.b', 'permission declared second still reads');
+  assert.equal(gates.has('requireNoPermissionPage'), false, 'a gate with no permission is dropped');
+  assert.equal(gates.get('requireNormalPage'), 'c.d', 'and it did not inherit a sibling\'s');
+});
+
 // ONE-DIRECTIONAL, and deliberately so. A floor STRICTER than the route middleware
 // is legitimate and common: the wall lives in the handler (task.confirm.grade_bypass
 // on an any-builder POST /tasks/:id/confirm; goal.manage.own's owner|manager check;

package/tests/ship_card.mjs

@@ -437,5 +437,100 @@ test('the ship + claim skills both instruct relaying [otb-confirm]', () => {
   }
 });
 
+// ---- grader OUTAGE vs quality rejection (task 1002892) ----
+//
+// stageFor() collapses every non-shipped outcome into 'failed', whose one
+// presentation was red / 'Needs fixes' / 'grade failed'. An outage landed there
+// too, so the card told a builder their code was REJECTED when nothing had judged
+// it — on task 1002459 a logged-out CLI killed all four workers and the builder
+// got a 0/10 card with an EMPTY issues[] and went hunting for defects that did not
+// exist. These pin that an outage now reads as 'could not grade', in amber, with a
+// retry — and, just as importantly, that a REAL failing grade is untouched.
+
+const failedInput = (grade) => ({
+  postGradeStatus: 'completed', taskId: 1266, title: 'T', valueSummary: 'v',
+  fileCount: 1, added: 1, removed: 0, grade, credits: {}, usage: {}, brand: BRAND,
+});
+const PANEL_OUTAGE = { passed: false, issues: [], signals: { panel_outcome: 'unavailable' } };
+
+test('outage: a total panel outage reads as could-not-grade, not needs-fixes', () => {
+  const m = card.buildCardModel(failedInput(PANEL_OUTAGE));
+  assert.equal(m.stage, 'failed', 'the STAGE is unchanged — only its presentation moves');
+  assert.equal(m.cfg.statusWord, 'Could not grade');
+  assert.equal(m.cfg.tone, 'warning', 'amber, not danger — nothing was rejected');
+  assert.match(m.cfg.headline(1266), /could not grade/);
+});
+
+test('outage: the next action is a retry, not Fix & re-grade', () => {
+  const m = card.buildCardModel(failedInput(PANEL_OUTAGE));
+  assert.equal(m.action.label, 'Try grading again');
+  assert.doesNotMatch(m.action.label, /Fix/, 'there is nothing to fix after an outage');
+});
+
+test('outage: the trail says not graded, not grade failed', () => {
+  const m = card.buildCardModel(failedInput(PANEL_OUTAGE));
+  const words = card.trailSteps(m.cfg).map((s) => s.word);
+  assert.ok(words.includes('not graded'), 'trail was ' + words.join(' -> '));
+  assert.ok(!words.includes('grade failed'));
+});
+
+test('outage: the Grade row and its chip say not graded, never a red fail', () => {
+  // Recoloring the banner alone left 'fail' in red one line below it, which is the
+  // same rejection signal in a smaller font. Both render paths read the same two
+  // values, so both are pinned here.
+  const m = card.buildCardModel(failedInput(PANEL_OUTAGE));
+  assert.equal(row(m, 'Grade'), 'not graded');
+  const chip = m.facts.find((f) => f.label === 'grade');
+  assert.equal(chip.value, 'not graded');
+  assert.notEqual(chip.cls, 'cc-bad', 'the grade chip must not be painted as a failure');
+  assert.doesNotMatch(card.renderMonospaceCard(m), /\bfail\b/, 'the word fail must not appear on an outage card');
+});
+
+test('outage with issues present still reports no grade, not a count', () => {
+  // An outage can carry incidental non-substantive issues; 'fail · 2 issues' would
+  // still be a verdict nothing produced.
+  const m = card.buildCardModel(failedInput({
+    passed: false,
+    issues: [{ severity: 'nit', summary: 'a' }, { severity: 'minor', summary: 'b' }],
+    signals: { panel_outcome: 'unavailable' },
+  }));
+  assert.equal(row(m, 'Grade'), 'not graded');
+});
+
+test('a REAL failing grade is untouched — still red, still Needs fixes', () => {
+  const m = card.buildCardModel(failedInput({ passed: false, issues: [{ severity: 'major', summary: 'x' }], signals: {} }));
+  assert.equal(m.cfg.statusWord, 'Needs fixes');
+  assert.equal(m.cfg.tone, 'danger');
+  assert.equal(m.action.label, 'Fix & re-grade');
+  assert.ok(card.trailSteps(m.cfg).map((s) => s.word).includes('grade failed'));
+  assert.equal(row(m, 'Grade'), 'fail · 1 issue', 'a real rejection still reports its verdict and count');
+});
+
+test('a grade carrying NO signals renders exactly as before (every old caller)', () => {
+  const m = card.buildCardModel(failedInput({ passed: false, issues: [] }));
+  assert.equal(m.cfg.statusWord, 'Needs fixes');
+  assert.equal(m.cfg.tone, 'danger');
+});
+
+test('gradeUnavailability: a cq-lens outage counts, but NOT beside a real finding', () => {
+  const cq = { cq_lens_unavailable: true };
+  assert.equal(card.gradeUnavailability({ signals: cq, rubric_scores: { code_quality: null }, issues: [] }), 'cq_lens');
+  assert.equal(
+    card.gradeUnavailability({ signals: cq, rubric_scores: { code_quality: null }, issues: [{ severity: 'blocker', summary: 'x' }] }),
+    null,
+    'a dark lens beside a blocker is a rejection with a missing axis, not an outage');
+  assert.equal(card.gradeUnavailability({ signals: cq, rubric_scores: { code_quality: 7 }, issues: [] }), null,
+    'a scored cq axis means the lens ran');
+  assert.equal(card.gradeUnavailability({}), null);
+  assert.equal(card.gradeUnavailability(null), null);
+});
+
+test('outage presentation never leaks onto a shipped or confirmed card', () => {
+  for (const status of ['shipped', 'confirmed']) {
+    const m = card.buildCardModel({ ...shippedInput, postGradeStatus: status, grade: { passed: true, issues: [], signals: { panel_outcome: 'unavailable' } } });
+    assert.notEqual(m.cfg.statusWord, 'Could not grade', status + ' must be unaffected');
+  }
+});
+
 console.log(`\nship_card: ${passed} passed, ${failed} failed`);
 process.exit(failed ? 1 : 0);