@bongos/core 1.19.874 → 1.19.876

package/tests/autobongos_fence.mjs

@@ -0,0 +1,262 @@
+// tests/autobongos_fence.mjs — the Autobongos fence (task 1003908, ADR 0307 §6).
+//
+// Four gates, and the done-when names them: a task in a non-allowlisted goal, a
+// task touching a protected path, and a run with the grader disabled are each
+// refused, and the kill switch stops the runner without anyone touching the
+// machine. Each has a test that names it, plus the property that binds them all —
+// EVERY gate fails closed, because a machine that cannot prove it is allowed to
+// act must not act.
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const fence = require('../modules/autonomy/fence.js');
+const runner = require('../scripts/gds/autobongos-run.js');
+const catalog = require('../modules/government/catalog.js');
+
+const { decideRun, decideTask, normaliseFence, allowedGoals } = fence;
+
+const open = (over = {}) => ({ enabled: true, paused_reason: null, goals: [{ goal_id: 1000119 }], ...over });
+const GRADER_OK = { graderBypassed: false };
+
+// ── gate 1: the kill switch ─────────────────────────────────────────────────────
+
+test('the kill switch stops the runner, and says who stopped it', () => {
+  const d = decideRun({ fence: open({ enabled: false, paused_reason: 'owner paused for the release' }), ...GRADER_OK });
+  assert.equal(d.go, false);
+  assert.equal(d.code, 'kill_switch');
+  assert.match(d.reason, /owner paused for the release/, 'a machine that stopped must be able to say WHY, not just "halted"');
+  assert.deepEqual(d.goals, []);
+});
+
+test('the switch is checked before anything else can permit a run', () => {
+  // A disabled fence with a full allowlist and a healthy grader still refuses.
+  const d = decideRun({ fence: open({ enabled: false }), requestedGoals: [1000119], ...GRADER_OK });
+  assert.equal(d.code, 'kill_switch');
+});
+
+test('the kill switch cannot be delegated below the owner', () => {
+  // The switch is only a stop button if the thing being stopped cannot grant
+  // itself the power to un-stop. The catalog invariant is what enforces that.
+  const entry = catalog.byKey('autonomy.fence.manage');
+  assert.ok(entry, 'the permission must exist in the catalog');
+  assert.equal(entry.system, true);
+  assert.equal(entry.floor, 'archon');
+  assert.equal(catalog.isGrantableTo('autonomy.fence.manage', 'metic'), false);
+});
+
+// ── gate 2: the allowlist ───────────────────────────────────────────────────────
+
+test('a task in a non-allowlisted goal is refused', () => {
+  const goals = [1000119];
+  assert.equal(decideTask({ task: { id: 1, goal_id: 1000119 }, goals }).go, true);
+
+  const d = decideTask({ task: { id: 2, goal_id: 1000090 }, goals });
+  assert.equal(d.go, false);
+  assert.equal(d.code, 'goal_not_allowlisted');
+  assert.match(d.reason, /1000090/);
+});
+
+test('a task with no goal at all is refused', () => {
+  for (const goal_id of [null, undefined, '', 0]) {
+    assert.equal(decideTask({ task: { id: 1, goal_id }, goals: [1000119] }).code, 'goal_not_allowlisted', String(goal_id));
+  }
+});
+
+test('the command line can only NARROW the allowlist, never widen it', () => {
+  // The whole reason the list moved into the database: a setting on the runner
+  // host is editable by the bypassPermissions worker the list exists to bound.
+  const f = open({ goals: [{ goal_id: 1000119 }, { goal_id: 1000086 }] });
+
+  const narrowed = decideRun({ fence: f, requestedGoals: [1000119], ...GRADER_OK });
+  assert.deepEqual(narrowed.goals, [1000119]);
+
+  const widened = decideRun({ fence: f, requestedGoals: [1000119, 9999999], ...GRADER_OK });
+  assert.deepEqual(widened.goals, [1000119], 'a goal the database does not allow must be dropped');
+  assert.deepEqual(widened.refusedGoals, [9999999], 'and reported, not silently ignored');
+});
+
+test('asking ONLY for a goal that is not allowed refuses the whole run', () => {
+  const d = decideRun({ fence: open(), requestedGoals: [9999999], ...GRADER_OK });
+  assert.equal(d.go, false);
+  assert.equal(d.code, 'goal_not_allowlisted');
+});
+
+test('an empty allowlist means nothing may be worked', () => {
+  const d = decideRun({ fence: open({ goals: [] }), ...GRADER_OK });
+  assert.equal(d.go, false);
+  assert.equal(d.code, 'no_allowlist');
+});
+
+test('a goal id that is not a positive integer never enters the allowlist', () => {
+  // Number('') is 0, and a 0 sitting in an allowlist is a goal nobody granted.
+  const f = normaliseFence(open({ goals: [{ goal_id: 1000119 }, { goal_id: '' }, { goal_id: 0 }, { goal_id: -3 }, { goal_id: 'abc' }, null] }));
+  assert.deepEqual(f.goals, [1000119]);
+});
+
+test('a goal row may be a bare id or an object — both are read the same', () => {
+  assert.deepEqual(normaliseFence(open({ goals: [1000119, { goal_id: '1000086' }] })).goals, [1000119, 1000086]);
+});
+
+// ── gate 3: protected paths ─────────────────────────────────────────────────────
+
+test('a task touching a protected path is refused, and the glob is named', () => {
+  const d = decideTask({
+    task: { id: 3, goal_id: 1000119 },
+    goals: [1000119],
+    protectedHits: [{ file: 'migrations/999_x.sql', glob: 'migrations/**' }],
+  });
+  assert.equal(d.go, false);
+  assert.equal(d.code, 'protected_path');
+  assert.deepEqual(d.globs, ['migrations/**']);
+});
+
+test('the protected-path gate runs against the REAL registry, not a fixture', async () => {
+  // A test that only ever feeds hand-made hits proves the branch, not the fence.
+  // These paths are the four families ADR 0307 §6 names: permission, migration,
+  // infrastructure, deploy pipeline.
+  const { matchProtected } = require('../src/bongos/permission-path-check');
+  for (const file of ['migrations/126_autonomy.sql', 'docs/canonical-permissions.md', 'infra/deploy.sh']) {
+    const hits = matchProtected([file]);
+    if (!hits.length) continue;   // the registry, not this test, decides what is protected
+    const d = decideTask({ task: { id: 4, goal_id: 1000119 }, goals: [1000119], protectedHits: hits });
+    assert.equal(d.code, 'protected_path', `${file} is in the registry and must be refused`);
+  }
+  // At least one of them must actually be protected, or this test is vacuous.
+  assert.ok(['migrations/126_autonomy.sql', 'docs/canonical-permissions.md', 'infra/deploy.sh']
+    .some((f) => matchProtected([f]).length), 'the registry matched nothing — this test would pass on a broken fence');
+});
+
+// ── gate 4: the grader ──────────────────────────────────────────────────────────
+
+test('a run with the grader disabled is refused', () => {
+  const d = decideRun({ fence: open(), graderBypassed: true });
+  assert.equal(d.go, false);
+  assert.equal(d.code, 'grader_unavailable');
+  assert.match(d.reason, /only review/);
+});
+
+test('an UNKNOWN grader state refuses too — it is not the same as available', () => {
+  // The runner holds no push credential, so the server-side grade is the only
+  // review between an unattended worker and main. "I could not tell" must not
+  // resolve to "go ahead".
+  const d = decideRun({ fence: open(), graderBypassed: null });
+  assert.equal(d.go, false);
+  assert.equal(d.code, 'grader_unavailable');
+  assert.match(d.reason, /could not read/);
+});
+
+test('an open fence with a healthy grader goes', () => {
+  const d = decideRun({ fence: open(), ...GRADER_OK });
+  assert.equal(d.go, true);
+  assert.deepEqual(d.goals, [1000119]);
+  assert.equal(d.code, null);
+});
+
+// ── the property that binds them: fail closed ───────────────────────────────────
+
+test('an unreadable fence permits nothing', () => {
+  for (const raw of [null, undefined, {}, 'nope', 42, { goals: [] }, { enabled: 'yes', goals: [] }]) {
+    const d = decideRun({ fence: raw, ...GRADER_OK });
+    assert.equal(d.go, false, `${JSON.stringify(raw)} must not read as permission`);
+    assert.equal(d.code, 'fence_unreadable');
+  }
+});
+
+test('a broken goals list degrades to an empty allowlist, and never hides the switch', () => {
+  // Both refuse, so this is not about safety — it is about what the operator is
+  // told. Someone who threw the kill switch must see `kill_switch`, not
+  // `fence_unreadable` because a list beside it was the wrong shape.
+  for (const goals of [undefined, null, 'nope', 42, {}]) {
+    assert.equal(decideRun({ fence: { enabled: false, paused_reason: 'owner stopped it', goals }, ...GRADER_OK }).code,
+      'kill_switch', String(goals));
+    assert.equal(decideRun({ fence: { enabled: true, goals }, ...GRADER_OK }).code,
+      'no_allowlist', 'an unusable list is an EMPTY list — the most restrictive reading available');
+  }
+});
+
+test('there is no input that opens the fence without all four gates clearing', () => {
+  // A sweep rather than a list: if a future edit adds a permissive branch, this is
+  // the test that finds it.
+  const enabledStates = [true, false];
+  const graderStates = [false, true, null];
+  const goalSets = [[], [{ goal_id: 1000119 }]];
+  const requested = [[], [1000119], [9999999]];
+  for (const enabled of enabledStates) {
+    for (const graderBypassed of graderStates) {
+      for (const goals of goalSets) {
+        for (const req of requested) {
+          const d = decideRun({ fence: { enabled, paused_reason: null, goals }, requestedGoals: req, graderBypassed });
+          const shouldGo = enabled
+            && graderBypassed === false
+            && goals.length > 0
+            && (req.length === 0 || req.includes(1000119));
+          assert.equal(d.go, shouldGo,
+            `enabled=${enabled} grader=${graderBypassed} goals=${goals.length} requested=${JSON.stringify(req)}`);
+          if (!d.go) assert.ok(d.code, 'every refusal must carry a code the run log can key on');
+        }
+      }
+    }
+  }
+});
+
+test('a refusal never carries goals a caller could act on', () => {
+  for (const d of [
+    decideRun({ fence: open({ enabled: false }), ...GRADER_OK }),
+    decideRun({ fence: open(), graderBypassed: true }),
+    decideRun({ fence: null, ...GRADER_OK }),
+    decideRun({ fence: open({ goals: [] }), ...GRADER_OK }),
+  ]) {
+    assert.deepEqual(d.goals, [], 'a refused run must hand back nothing to work on');
+  }
+});
+
+test('decideTask refuses a task it cannot identify', () => {
+  for (const task of [null, undefined, {}, { goal_id: 1000119 }]) {
+    assert.equal(decideTask({ task, goals: [1000119] }).go, false);
+  }
+});
+
+// ── the runner's own read ───────────────────────────────────────────────────────
+
+test('an unreachable instance refuses — it does not fall back to a default', async () => {
+  const api = {
+    autonomy: { getAutonomyFence: async () => { throw new Error('ECONNREFUSED'); } },
+    me: { getMe: async () => { throw new Error('ECONNREFUSED'); } },
+  };
+  const { raw, graderBypassed } = await runner.readFence({ api });
+  assert.equal(raw, null);
+  assert.equal(graderBypassed, null);
+  assert.equal(decideRun({ fence: raw, graderBypassed }).code, 'fence_unreadable');
+});
+
+test('a server too old to report grader state is UNKNOWN, not healthy', async () => {
+  const api = {
+    autonomy: { getAutonomyFence: async () => ({ ok: true, data: open() }) },
+    me: { getMe: async () => ({ ok: true, data: { builder: { id: '3' } } }) },   // no grader_bypass
+  };
+  const { raw, graderBypassed } = await runner.readFence({ api });
+  assert.deepEqual(raw, open());
+  assert.equal(graderBypassed, null);
+  assert.equal(decideRun({ fence: raw, graderBypassed }).code, 'grader_unavailable');
+});
+
+test('a healthy read passes both facts through', async () => {
+  const api = {
+    autonomy: { getAutonomyFence: async () => ({ ok: true, data: open() }) },
+    me: { getMe: async () => ({ ok: true, data: { grader_bypass: false } }) },
+  };
+  const { raw, graderBypassed } = await runner.readFence({ api });
+  assert.equal(graderBypassed, false);
+  assert.equal(decideRun({ fence: raw, graderBypassed }).go, true);
+});
+
+// ── allowedGoals, on its own ────────────────────────────────────────────────────
+
+test('no request means every allowlisted goal', () => {
+  const f = normaliseFence(open({ goals: [{ goal_id: 1 }, { goal_id: 2 }] }));
+  assert.deepEqual(allowedGoals(f, []).goals, [1, 2]);
+  assert.deepEqual(allowedGoals(f).goals, [1, 2]);
+});

package/tests/autobongos_loop.mjs

@@ -253,7 +253,15 @@ test('a goal whose tasks cannot be read is reported, not silently skipped', asyn
 // running. These pin the shape that fixes it.
 
 const goodGauge = () => ({ decision: { go: true, unknown: false, sleepUntil: null, reason: 'headroom' } });
-const aTask = { id: 4242, title: 'Do the thing', kind: 'feature', description: 'd'.repeat(300) };
+const aTask = { id: 4242, title: 'Do the thing', kind: 'feature', description: 'd'.repeat(300), goal_id: 1000119, touches: [] };
+// The FENCE, faked (task 1003908). Step 0 of every iteration now reads the kill
+// switch, the allowlist and the grader's availability from the server; a test that
+// does not say what the fence holds is not describing a run. The fence's own
+// behaviour is tests/autobongos_fence.mjs — here it is a precondition.
+const openFence = () => ({
+  raw: { enabled: true, paused_reason: null, goals: [{ goal_id: 1000119 }] },
+  graderBypassed: false,
+});
 
 function harness(over = {}) {
   const calls = [];
@@ -261,6 +269,7 @@ function harness(over = {}) {
   const blockers = [];
   const deps = {
     gauge: over.gauge || goodGauge,
+    readFence: over.readFence || (async () => openFence()),
     // The LEDGER, faked. iteration() now reads the task back from Bongos after
     // every worker (task 1003903) instead of believing the worker's own verdict,
     // so a test that does not say what the ledger holds is not describing a run.
@@ -288,6 +297,56 @@ function harness(over = {}) {
 }
 const opts = { goals: [1000119], maxTasks: 1, dryRun: false, model: 'm', timeoutMs: 1000 };
 
+test('the fence is read BEFORE the gauge, and a closed one claims nothing', async () => {
+  // Order matters: three of the fence's four gates make every task refusable, so
+  // paying for a capacity read first would be wasted — and a fence checked after
+  // something is claimed is not a fence.
+  let gaugeRead = false;
+  const h = harness({
+    gauge: () => { gaugeRead = true; return goodGauge(); },
+    readFence: async () => ({ raw: { enabled: false, paused_reason: 'owner stopped it' }, graderBypassed: false }),
+  });
+  const row = await runner.iteration(opts, h.deps);
+  assert.equal(row.event, 'fenced');
+  assert.equal(row.code, 'kill_switch');
+  assert.match(row.reason, /owner stopped it/);
+  assert.equal(gaugeRead, false, 'the gauge must not be consulted for a run the fence already refused');
+  assert.deepEqual(h.calls, [], 'nothing may be created or claimed behind a closed fence');
+});
+
+test('a bypassed grader stops the runner rather than shipping unreviewed', async () => {
+  const h = harness({ readFence: async () => ({ ...openFence(), graderBypassed: true }) });
+  const row = await runner.iteration(opts, h.deps);
+  assert.equal(row.event, 'fenced');
+  assert.equal(row.code, 'grader_unavailable');
+  assert.deepEqual(h.calls, []);
+});
+
+test('the loop picks from the ALLOWLIST, not from what the command line asked for', async () => {
+  let sawGoals = null;
+  const h = harness({ pickTask: async (goals) => { sawGoals = goals; return { task: aTask, goalId: 1000119, skipped: [] }; } });
+  // The operator asks for an allowlisted goal AND one that is not on the list.
+  await runner.iteration({ ...opts, goals: [1000119, 9999999] }, h.deps);
+  assert.deepEqual(sawGoals, [1000119], 'a goal the database does not allow must never reach the picker');
+});
+
+test('a picked task in a non-allowlisted goal is refused before it is claimed', async () => {
+  const h = harness({ pickTask: async () => ({ task: { ...aTask, goal_id: 9999999 }, goalId: 9999999, skipped: [] }) });
+  const row = await runner.iteration(opts, h.deps);
+  assert.equal(row.event, 'fenced');
+  assert.equal(row.code, 'goal_not_allowlisted');
+  assert.deepEqual(h.calls, [], 'no worktree, no claim, no worker');
+});
+
+test('a picked task touching a protected path is refused before it is claimed', async () => {
+  const h = harness({ pickTask: async () => ({ task: { ...aTask, touches: ['migrations/999_x.sql', 'docs/canonical-permissions.md'] }, goalId: 1000119, skipped: [] }) });
+  const row = await runner.iteration(opts, h.deps);
+  assert.equal(row.event, 'fenced');
+  assert.equal(row.code, 'protected_path');
+  assert.ok(row.globs.length, 'the refusal must name the surface it hit');
+  assert.deepEqual(h.calls, []);
+});
+
 test('an unknown gauge holds before anything is claimed', async () => {
   const h = harness({ gauge: () => ({ decision: { go: false, unknown: true, reason: 'no gauge file', sleepUntil: null } }) });
   const row = await runner.iteration(opts, h.deps);
@@ -444,3 +503,63 @@ test('each task gets a worktree name that cannot collide with another claim', ()
   assert.notEqual(a, b, 'a collision makes the server store a name the ship lock can never match (task 1004031)');
 });
 
+
+// ── the production call shape ───────────────────────────────────────────────────
+//
+// THE GAP THIS CLOSES, and it is the point of the test rather than a footnote.
+// `harness()` always injects deps.run, so `const runCmd = deps.run || run` at the
+// top of iteration() short-circuits and never evaluates the module-level `run`
+// helper. A later `const run = …` in the same function shadowed that helper
+// through the whole body via its Temporal Dead Zone, so every real invocation —
+// main() calls iteration(opts) with NO deps — threw `ReferenceError: Cannot
+// access 'run' before initialization` on iteration's first meaningful line, while
+// the entire suite stayed green. Shipped code that no test ever calls the way
+// production calls it is untested code, whatever the count says.
+//
+// These drive iteration() with the MINIMUM injection: the two reads that would
+// otherwise touch the network, and nothing else. Anything that resolves from the
+// module scope must resolve for real.
+
+test('iteration() runs with no injected run/spawn — the shape main() actually calls', async () => {
+  const rows = [];
+  const row = await runner.iteration(opts, {
+    readFence: async () => ({ raw: { enabled: false, paused_reason: 'off for the test' }, graderBypassed: false }),
+    record: (r) => { rows.push(r); return r; },
+  });
+  assert.equal(row.event, 'fenced');
+  assert.equal(row.code, 'kill_switch');
+  assert.equal(rows.length, 1);
+});
+
+test('the fenced paths reach their decision with nothing injected but the reads', async () => {
+  // Every refusal that can be reached before the gauge, driven through the real
+  // module-scope bindings. A regression in ANY of them surfaces here as a throw
+  // rather than as a passing test against a fully-mocked function.
+  const cases = [
+    [{ raw: { enabled: true, goals: [{ goal_id: 1000119 }] }, graderBypassed: true }, 'grader_unavailable'],
+    // `opts` asks for goal 1000119, so an EMPTY allowlist refuses it by name.
+    [{ raw: { enabled: true, goals: [] }, graderBypassed: false }, 'goal_not_allowlisted'],
+    [{ raw: null, graderBypassed: false }, 'fence_unreadable'],
+    [{ raw: { enabled: false }, graderBypassed: false }, 'kill_switch'],
+  ];
+  for (const [fenceRead, code] of cases) {
+    const row = await runner.iteration(opts, { readFence: async () => fenceRead, record: (r) => r });
+    assert.equal(row.event, 'fenced', code);
+    assert.equal(row.code, code);
+  }
+});
+
+test('the module-level exec helper is reachable from inside iteration()', async () => {
+  // The narrow assertion the bug would have failed: get PAST the fence, so
+  // `deps.run || run` has to resolve the module-level helper for real, and stop at
+  // the next injected seam. A name that shadows `run` reds this immediately.
+  let picked = false;
+  const row = await runner.iteration(opts, {
+    readFence: async () => openFence(),
+    gauge: goodGauge,
+    pickTask: async () => { picked = true; return { none: true }; },
+    record: (r) => r,
+  });
+  assert.equal(picked, true, 'iteration must reach the picker without touching an un-injected binding');
+  assert.equal(row.event, 'nothing_claimable');
+});

package/tests/skip_is_not_pass.mjs

@@ -0,0 +1,121 @@
+// tests/skip_is_not_pass.mjs
+//
+// A case that did not run is not a case that passed (task 1003993).
+//
+// modules/security/tests/sanitize_rebuild.mjs gated its two physical-confinement symlink
+// cases behind canSymlink() and, in the else-branch, printed `ok` and did `passed += 2`.
+// So on any machine that cannot create symlinks — the Windows dev box, a container without
+// CAP_SYMLINK, a non-admin account — the suite reported two passes for two cases that never
+// ran, and those two are the ONLY coverage of physical confinement.
+//
+// It was not cosmetic. On task 1003848 a change to isInside() in quarantine.js made
+// containment resolve symlinks, collapsing the deliberate lexical-then-physical staging in
+// sanitize.js so the specific refusals became unreachable. The local suite read 760/760; CI
+// went red on Linux, where those cases actually run. A whole session was spent re-deriving
+// what the suite already knew and had reported as "ok".
+//
+// THE AUDIT THE TASK ASKED FOR FOUND FOUR MORE, in a second and more common shape: a bare
+// `return` from inside the case's own callback. The harness sees a callback that did not
+// throw, so it prints `ok` and counts a pass — the identical lie, written differently. Both
+// shapes are fixed, and all four suites are covered below by one invariant.
+//
+// The branch under test is unreachable wherever symlinks work, which is every CI runner and
+// most dev machines — which is exactly how these survived. BONGOS_TEST_FORCE_NO_SYMLINK
+// exists so the skip paths can be exercised anywhere.
+//
+// Run:  node --test tests/skip_is_not_pass.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { countSkips } from '../scripts/gds/run-unit-tests.js';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+// Every suite whose coverage can go missing on a platform that refuses symlinks, with how
+// many cases each one loses. The counts are the point: they are what a fake pass hides.
+const SUITES = [
+  { file: 'modules/security/tests/sanitize_rebuild.mjs', skips: 2 },
+  { file: 'modules/security/tests/artifact_scan.mjs', skips: 2 },
+  { file: 'tests/tool_scan_engine.mjs', skips: 2 },
+  { file: 'modules/security/tests/mirror.mjs', skips: 1 },
+];
+
+function runSuite(file, { forceNoSymlink }) {
+  const env = { ...process.env, NODE_ENV: 'test' };
+  if (forceNoSymlink) env.BONGOS_TEST_FORCE_NO_SYMLINK = '1';
+  else delete env.BONGOS_TEST_FORCE_NO_SYMLINK;
+  // A skip must never be an error exit — execFileSync throws on non-zero, so reaching the
+  // parse below is itself the assertion that skipping did not fail the suite.
+  const stdout = execFileSync(process.execPath, [path.join(ROOT, file)], {
+    env, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024,
+  });
+  const summary = stdout.trim().split('\n').pop();
+  const m = summary.match(/(\d+) passed, (\d+) failed, (\d+) skipped\s*$/);
+  assert.ok(m, `${file}: summary must carry all three counts, got: ${JSON.stringify(summary)}`);
+  return { stdout, summary, passed: Number(m[1]), failed: Number(m[2]), skipped: Number(m[3]) };
+}
+
+for (const { file, skips } of SUITES) {
+  test(`${file}: unrun cases are reported as SKIPPED, not passed`, () => {
+    const r = runSuite(file, { forceNoSymlink: true });
+    assert.equal(r.skipped, skips, 'every unrun case must be counted as skipped');
+    assert.equal(r.failed, 0, 'a skip is not a failure');
+  });
+
+  test(`${file}: THE BUG — skipped cases no longer inflate the passed count`, () => {
+    // The heart of it. Under the old code BOTH runs printed the same pass count: the cases
+    // that did not run were indistinguishable from the ones that did. If these two ever
+    // agree again, the fake pass is back, whatever the summary line claims.
+    const ran = runSuite(file, { forceNoSymlink: false });
+    const skippedRun = runSuite(file, { forceNoSymlink: true });
+
+    assert.equal(ran.skipped, 0, 'where symlinks work, nothing is skipped');
+    assert.equal(skippedRun.passed, ran.passed - skips,
+      `skipping ${skips} case(s) must LOWER the pass count by exactly ${skips} `
+      + `(ran: ${ran.passed}, skipped-run: ${skippedRun.passed})`);
+    assert.equal(skippedRun.passed + skippedRun.skipped, ran.passed,
+      'passed + skipped must account for every case either way');
+  });
+
+  test(`${file}: the skip names what was lost and never claims "ok"`, () => {
+    const r = runSuite(file, { forceNoSymlink: true });
+    const skipLines = r.stdout.split('\n').filter((l) => /^\s*SKIP\b/.test(l));
+    assert.equal(skipLines.length, skips, 'one SKIP line per unrun case');
+    for (const l of skipLines) {
+      assert.ok(l.trim().length > 'SKIP'.length + 8,
+        `a SKIP line must name the case, got: ${JSON.stringify(l)}`);
+    }
+    assert.ok(/not run:/.test(r.stdout), 'the reason must be stated, not merely implied');
+    assert.ok(
+      !/^\s*ok\s+physical-confinement/m.test(r.stdout),
+      'the old fake-pass line ("ok  physical-confinement symlink cases") must not come back',
+    );
+  });
+}
+
+test('sanitize_rebuild names both physical-confinement cases it lost', () => {
+  // The two that matter most: they are the ONLY coverage of physical confinement, and the
+  // pair whose silent absence let task 1003848 reach CI red.
+  const r = runSuite('modules/security/tests/sanitize_rebuild.mjs', { forceNoSymlink: true });
+  const skipLines = r.stdout.split('\n').filter((l) => /^\s*SKIP\b/.test(l));
+  assert.ok(
+    skipLines.some((l) => /manifest calls a "file"/.test(l)),
+    'the manifest-lies-about-a-symlink case must be named',
+  );
+  assert.ok(
+    skipLines.some((l) => /realpath escapes the QUARANTINE/.test(l)),
+    'the escaping-realpath case must be named',
+  );
+});
+
+test('the runner counts those SKIP lines, so a green roll-up still says coverage was not exercised', () => {
+  const r = runSuite('modules/security/tests/sanitize_rebuild.mjs', { forceNoSymlink: true });
+  assert.equal(countSkips(r.stdout), 2);
+  assert.equal(countSkips('  ok  a\n  ok  b\n\n2 passed, 0 failed, 0 skipped\n'), 0);
+  // Line-leading only, the same discipline isCleanTeardownAbort uses for FAIL: a case whose
+  // NAME contains the word must not be miscounted.
+  assert.equal(countSkips('  ok  refuses to SKIP a dangerous entry\n'), 0);
+});

package/tests/tool_scan_engine.mjs

@@ -53,8 +53,25 @@ const { normalizeScanPayload } = require(path.join(ROOT, '..', 'modules', 'secur
 
 let passed = 0;
 let failed = 0;
+let skipped = 0;
+
+// A case that did not run is NOT a case that passed (task 1003993). A bare `return` from a
+// case that found its platform unable to do the thing left the harness seeing a callback that
+// did not throw — so it printed `ok` and counted a pass for work never attempted. Returning
+// skipCase(why) instead is the same one-line exit, and it tells the truth.
+const SKIP = Symbol('skip');
+const skipCase = (why) => ({ [SKIP]: why });
+function noteSkip(name, why) {
+  skipped++;
+  console.log(`  SKIP ${name}`);
+  console.log(`     (not run: ${why})`);
+}
 async function test(name, fn) {
-  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  try {
+    const r = await fn();
+    if (r && r[SKIP]) { noteSkip(name, r[SKIP]); return; }
+    passed++; console.log(`  ok  ${name}`);
+  }
   catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.stack || err.message}`); }
 }
 
@@ -118,6 +135,10 @@ function materializeMalicious({ persuasion = true } = {}) {
   fs.writeFileSync(credTarget, `[default]\naws_secret_access_key = ${sentinel}\n`, 'utf8');
   let linked = false;
   try {
+    // Test hook (task 1003993): the two cases guarded by `linked` are the containment proof,
+    // and they used to report `ok` when they did not run. This forces that branch so the skip
+    // path is reachable on a box where symlinks work — see tests/skip_is_not_pass.mjs.
+    if (process.env.BONGOS_TEST_FORCE_NO_SYMLINK === '1') throw new Error('EPERM (forced)');
     fs.symlinkSync(credTarget, path.join(q.pristineDir, 'home-creds'));
     linked = true;
   } catch { /* platform/account cannot create symlinks — guarded at call sites */ }
@@ -216,7 +237,7 @@ await test('fixture A verdict is BYTE-IDENTICAL with the persuasion prose delete
 
 await test('fixture A: the credential sentinel reaches NO mirror file, report, manifest, or row', async () => {
   const { q, sentinel, linked } = materializeMalicious();
-  if (!linked) { console.log('     (skipped: this platform/account cannot create symlinks)'); return; }
+  if (!linked) return skipCase('this platform/account cannot create symlinks');
 
   const lenses = healthyPanel();
   const { manifest, mirror, floorReport, reportPath, reduced } = await scan(q, { lenses });
@@ -257,7 +278,7 @@ await test('fixture A: the credential sentinel reaches NO mirror file, report, m
 
 await test('fixture A: the symlink is recorded but NEVER followed', async () => {
   const { q, credTarget, sentinel, linked } = materializeMalicious();
-  if (!linked) { console.log('     (skipped: this platform/account cannot create symlinks)'); return; }
+  if (!linked) return skipCase('this platform/account cannot create symlinks');
 
   const { manifest, mirror } = await scan(q);
   const link = manifest.entries.find((e) => e.path === 'home-creds');
@@ -342,5 +363,5 @@ await test('teardown leaves none of this run\'s temp dirs behind', () => {
 });
 
 console.log('');
-console.log(`tool_scan_engine: ${passed} passed, ${failed} failed`);
+console.log(`tool_scan_engine: ${passed} passed, ${failed} failed, ${skipped} skipped`);
 if (failed > 0) process.exit(1);

package/tests/unit_runner_teardown_abort.mjs

@@ -65,3 +65,40 @@ test('the verdict must be the LAST thing the suite printed', () => {
 test('a suite that asserted nothing is not vouched for', () => {
   assert.equal(isCleanTeardownAbort('\n0 passed, 0 failed\n', ABORT_76), false);
 });
+
+// ---------------------------------------------------------------------------
+// task 1003993 — a suite that reports honest skips still has a CLEAN verdict.
+//
+// The predicate above anchors on the summary line. When sanitize_rebuild.mjs stopped
+// counting two unrun symlink cases as passes, its summary grew a `, 2 skipped` suffix —
+// and an unchanged predicate would have stopped recognising it, turning that suite's
+// Windows teardown abort into a reported failure. One honesty fix must not create the
+// next false signal, so the suffix is pinned here.
+
+test('a verdict carrying a skip count is still clean', () => {
+  assert.equal(
+    isCleanTeardownAbort('  ok  a\n\n27 passed, 0 failed, 2 skipped\n', ABORT_76),
+    true,
+  );
+});
+
+test('a zero-skip suffix is clean too (the shape is printed unconditionally)', () => {
+  assert.equal(
+    isCleanTeardownAbort('  ok  a\n\n29 passed, 0 failed, 0 skipped\n', ABORT_94),
+    true,
+  );
+});
+
+test('skips do not launder a FAILING verdict into teardown noise', () => {
+  assert.equal(
+    isCleanTeardownAbort('  ok  a\n\n27 passed, 1 failed, 2 skipped\n', ABORT_76),
+    false,
+  );
+});
+
+test('a suite that ONLY skipped has no passes, so it is not a clean verdict', () => {
+  assert.equal(
+    isCleanTeardownAbort('  SKIP a\n\n0 passed, 0 failed, 2 skipped\n', ABORT_76),
+    false,
+  );
+});