@bongos/core 1.19.822 → 1.19.824

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.822",
-  "core_contract": "1.19.822",
-  "source_commit": "5a9c009cff17c2a500ff23f5d0de66a1b7f00477",
+  "core_version": "1.19.824",
+  "core_contract": "1.19.824",
+  "source_commit": "95554434b3e9a6349986ebd50fb547858e7c0fbd",
   "source_ref": "HEAD",
-  "built_at": "2026-09-17T11:05:47.254Z",
+  "built_at": "2026-09-17T12:15:41.626Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 490,
     "agent_docs_stubbed": 26,
-    "functional_verbatim": 2228,
+    "functional_verbatim": 2234,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 2744,
-  "tree_sha256": "acbc13ab96c308bd0c0aa200c9dd1f6af1013ed6771c70730a797f7a1fb4a697",
+  "file_count": 2750,
+  "tree_sha256": "5eaa31427b8c53ddb2d3aa0a10a2e851968649d578993ab3c4412fc279e1014a",
   "files": [
     {
       "path": ".claude/skills/ask-for-help/SKILL.md",
@@ -2537,7 +2537,7 @@
     {
       "path": "docs/file-map.md",
       "mode": "0000644",
-      "sha256": "5560da3dad24d04ba192d4cbcab9f7e669ebd6ead35bde8d92a222a763289a36"
+      "sha256": "4cacfe54b3e4f80aa1cd7a4b190bf673da867f99d5101cc1c7870ee13021c008"
     },
     {
       "path": "docs/handoff-template.md",
@@ -2547,7 +2547,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "9182a3b88e6092a231f59db4220628cb8579244c8289350406f07187c959e644"
+      "sha256": "a921ec8fff3a0bb3664431ff5f567e3660cb26dbc55a24012edcc7a1c52de4bd"
     },
     {
       "path": "docs/modules-contract.md",
@@ -7812,12 +7812,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "d13165aac1aea3612a3c5af1b5b14267acdde35f2a8d99482310c7a749f9761c"
+      "sha256": "aa5cbab9d550e88355a4d19269ef77f0b414394f53d0a745dba09417158d42ae"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "0f9f0baab592f70e890e2a39e61dcf21c5170841f97b8c82cb16703c2a959756"
+      "sha256": "50285f0725d1e9c6da37f0b47e3a64ad5f2084a81539eb2902ff9f75b7635ce0"
     },
     {
       "path": "public-docs/index.html",
@@ -8092,7 +8092,7 @@
     {
       "path": "scripts/gds/category-advisory-guard.js",
       "mode": "0000644",
-      "sha256": "a71ac076299b9e37bf8e0a6ff8761f8ba3059271b2596b6ee8941fc24533357d"
+      "sha256": "19fd98214001bb83ed69789653519d820ece8d94fea4451503ecf85ff4285f32"
     },
     {
       "path": "scripts/gds/cf-tunnel.js",
@@ -8212,7 +8212,7 @@
     {
       "path": "scripts/gds/deploy-divergence.js",
       "mode": "0000644",
-      "sha256": "4b77b2c878cace855ad979c66a7bbb0318199d10b1e0f114f79732db2b6cc203"
+      "sha256": "39879d5d26a325529620ab4fd180f133643d0e4c2a5a9ef92f8ee347ad0ba0d7"
     },
     {
       "path": "scripts/gds/design-sync.js",
@@ -8302,7 +8302,7 @@
     {
       "path": "scripts/gds/fetch-sound-prefs.js",
       "mode": "0000644",
-      "sha256": "0043a1af935e5dff7d807525eb6426310a8e6517af03f0506a86cb3296d38f74"
+      "sha256": "f2239bdd653ceda6f2595d454e618bff5273f46eb63d3cb6d8040190ee0125e9"
     },
     {
       "path": "scripts/gds/figma-design-sync.js",
@@ -8357,7 +8357,7 @@
     {
       "path": "scripts/gds/fitness.js",
       "mode": "0000644",
-      "sha256": "8725f7a8dcdd6445e8d2379e24c3985624b1889cc67be055cce8365b312457d2"
+      "sha256": "aa1a26c0b2871cd6e49b619254ce2b11d477780da8f4b037c38cb16b0ccd68fc"
     },
     {
       "path": "scripts/gds/gate-review.js",
@@ -8689,6 +8689,11 @@
       "mode": "0000644",
       "sha256": "9898b6f8e60b9f5ee4aeb9a023d1b68bb5bfbdf589eed10923a8e492716340ed"
     },
+    {
+      "path": "scripts/gds/probe-cache.js",
+      "mode": "0000644",
+      "sha256": "34d891e8ff58f0da957d300021210dbc34448fe676873b6b77e13ad3b7179d2e"
+    },
     {
       "path": "scripts/gds/prove-strict-versioning.js",
       "mode": "0000644",
@@ -8864,6 +8869,11 @@
       "mode": "0000644",
       "sha256": "c82513a9333724c77ba3a99667726861c292d576ea493f2144e6051dd78c47b6"
     },
+    {
+      "path": "scripts/gds/scope-map-guard.js",
+      "mode": "0000644",
+      "sha256": "75f0791698a36e48ec232d2285e6f80dac6d64c2a23a23a26cd54c1c05883c3b"
+    },
     {
       "path": "scripts/gds/seam-wiring-guard.js",
       "mode": "0000644",
@@ -9232,7 +9242,12 @@
     {
       "path": "scripts/gds/strand-watch.js",
       "mode": "0000644",
-      "sha256": "c7f9c997a6892e6ca083a03789b24524912632731ea550df6ee974f1ef05267e"
+      "sha256": "2a9959bd2e45046dadcda9982998a5b7163cef00b5d719ff299314daa5409770"
+    },
+    {
+      "path": "scripts/gds/stranded-rows.js",
+      "mode": "0000644",
+      "sha256": "573e608a90b5822f9bf77f203d54cf8a80ef9e96bdc51b22e5dec1226da3ee98"
     },
     {
       "path": "scripts/gds/stray-unit-sweep.sh",
@@ -9532,7 +9547,7 @@
     {
       "path": "src/bongos/module-scope-map.js",
       "mode": "0000644",
-      "sha256": "8d7b749edca694b4c9d8a563a4334c7fe3fc7be64c520c3d14c3b63febff132a"
+      "sha256": "7f393fc515fe751d5296ce0a574e0d3e40695c0346933a0d8b9c30ed6ae39a1b"
     },
     {
       "path": "src/bongos/module-submissions.js",
@@ -9722,7 +9737,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "782160b1ae7c1483c92337a589f92d8099a8bbee37005ea744c78bd4fcb5803c"
+      "sha256": "7bd07a13ff08f341820d14bfa056a4fff9715b0a63fbfb7f392e4d04b5336a15"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -10367,7 +10382,7 @@
     {
       "path": "tests/category_advisory_guard.mjs",
       "mode": "0000644",
-      "sha256": "8fd7b066c264ddaeccaa2dfa9a3c1fe6204a943933a1161c6a235f45b40ab121"
+      "sha256": "0fdb3c4e34fadc0f6697eb3ee3083d6739273e4df3c5693b7c3693cf0dfb1ef1"
     },
     {
       "path": "tests/cf_ruleset_preflight.mjs",
@@ -12344,6 +12359,11 @@
       "mode": "0000644",
       "sha256": "3c85d28ecc55e375988f3e55aee993c8c84220889678262d8207146c2772f3f5"
     },
+    {
+      "path": "tests/probe_cache.mjs",
+      "mode": "0000644",
+      "sha256": "26c734a1ab1996e1aff6197a9e0b19a448b28c772e0e75b00fee2433535c1193"
+    },
     {
       "path": "tests/profile_activity.mjs",
       "mode": "0000644",
@@ -12869,6 +12889,11 @@
       "mode": "0000644",
       "sha256": "8d516fe0fb398d8322e014773901449b6909439ab1567c90d8354b49f211cdbf"
     },
+    {
+      "path": "tests/scope_map_guard.mjs",
+      "mode": "0000644",
+      "sha256": "278e334a945d151c225d849b51464a3dffc8f0bb0dcb1d39b72d12bae57efd4f"
+    },
     {
       "path": "tests/scouting_owner_access_and_reach.mjs",
       "mode": "0000644",
@@ -13379,6 +13404,11 @@
       "mode": "0000644",
       "sha256": "bba2bde5b7a4a25ccddff58fb2fde0ef84ef67224e63819232221a461234a30f"
     },
+    {
+      "path": "tests/stranded_rows.mjs",
+      "mode": "0000644",
+      "sha256": "63070400896c81e90e53e6b9480beb55eafee854d7d54971e201cee70056d487"
+    },
     {
       "path": "tests/streak.mjs",
       "mode": "0000644",

package/docs/file-map.md

@@ -464,7 +464,8 @@ tests/
 ├── repo-simplify-sweep/SKILL.md       ← weekly repo-cleanliness janitor — runs repo-metrics, files dead-code findings to idea_inbox, and auto-fixes only the narrow safe class (restored in task 1003365; unscheduled in core — only redteam-weekly has a firing workflow; config/scheduled-routines.json records the intended cadence)
 ├── security-review-weekly/SKILL.md    ← weekly security-state review — stale vulnerability_reports, ageing security-tagged tasks, recent high/critical dependency alerts; one Archon broadcast when anything is stale, silent otherwise (restored in task 1003365; unscheduled in core — only redteam-weekly has a firing workflow; config/scheduled-routines.json records the intended cadence)
 ├── skill-usage-review/SKILL.md        ← nightly skill-usage feedback loop — aggregates 24h of skill invocations into friction findings filed as `[skill-friction]` idea_inbox rows (restored in task 1003365; unscheduled in core — only redteam-weekly has a firing workflow; config/scheduled-routines.json records the intended cadence)
-└── stale-claim-release/SKILL.md       ← hourly sweep releasing claims whose session_pulses heartbeat has been silent for GDS_STALE_CLAIM_HOURS, returning the task to ready and pinging the builder (restored in task 1003365; unscheduled in core — only redteam-weekly has a firing workflow; config/scheduled-routines.json records the intended cadence)
+├── stale-claim-release/SKILL.md       ← hourly sweep releasing claims whose session_pulses heartbeat has been silent for GDS_STALE_CLAIM_HOURS, returning the task to ready and pinging the builder (restored in task 1003365; unscheduled in core — only redteam-weekly has a firing workflow; config/scheduled-routines.json records the intended cadence)
+└── stranded-rows/SKILL.md             ← flags an open task whose work ALREADY LANDED on main (task 1003775): a row still in ready/backlog while a commit claims it with a line ending in `(task N)`. Narrower than "mentions N" on purpose — idea 1000807 measured that a mention-scan returns ~44 open rows that merely cite an id. Measured clean at 878 claims vs 434 open rows, and still catches the historical case (task 1002200, whose claim lives in the MERGE commit body). NO cadence declared: nothing schedules it yet, so it is run by hand — wiring a scheduler needs the control plane, and declaring a cadence with no cron firing it fails fitness Check 25 (task 1003209, ADR 0188). Prints ids + fixed vocabulary only, never builder-authored text.
 ```
 <!-- END GENERATED FILE-MAP .claude/scheduled-tasks/ -->
 

package/docs/module-api-changelog.md

@@ -2118,5 +2118,9 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.820 with no explicit bump. run 35212866365. (task 1002620)
   1.19.822 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.19.821 with no explicit bump. run 35213847140. (task 1002620)
+  1.19.823 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.822 with no explicit bump. run 35218585239. (task 1002620)
+  1.19.824 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.823 with no explicit bump. run 35220051893. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.822",
+  "version": "1.19.824",
   "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/scripts/gds/category-advisory-guard.js

@@ -69,6 +69,18 @@ const FEATURE_ANCHORS = [
 // Word-bounded on purpose: `subcategory_id` in some unrelated module is not this
 // feature, and a guard that cries wolf gets suppressed rather than obeyed. The
 // table name needs no boundary — nothing else is called that.
+// A quoted path to a scripts/gds/*.js file is a FILENAME, not a category read
+// (task 1003949). One of these guards is itself called category-advisory-guard.js,
+// so the moment any decision surface lists the enforcement tooling by path — which
+// module-scope-map.js must, to own it — this check fired on its own name.
+//
+// Blanked rather than exempted by file, and kept as narrow as it can be: only the
+// quoted path is removed, so the rest of the line is still scanned. A genuine
+// category read cannot hide inside a string that ends in .js.
+function withoutScriptPaths(line) {
+  return String(line).replace(/(['\"`])[^'\"`]*\.js\1/g, '""');
+}
+
 const CATEGORY_RE = /\bcategor(y|ies|ised|ized|isation|ization)\b|\bcategory_id\b|work_categories/i;
 
 // Strip // line comments and /* */ blocks so a citation of a rule is legal and only
@@ -147,7 +159,7 @@ function scanGates(files, read) {
     const code = stripComments(src);
     const hits = code.split('\n')
       .map((line, i) => ({ line: line.trim(), n: i + 1 }))
-      .filter(({ line }) => CATEGORY_RE.test(line));
+      .filter(({ line }) => CATEGORY_RE.test(withoutScriptPaths(line)));
     for (const { line, n } of hits) {
       violations.push(
         `${rel}:${n} reads a work CATEGORY inside a decision surface — \`${line.slice(0, 100)}\`. `

package/scripts/gds/deploy-divergence.js

@@ -321,7 +321,11 @@ async function main() {
   if (hasFlag('--line')) {
     const ms = Number(arg('--timeout-ms')) || DEFAULT_TIMEOUT_MS;
     try {
-      const one = line(await check({ timeoutMs: ms }));
+      // Shared across concurrent session starts (task 1003689): four sessions opened
+      // seconds apart asked this same question four times and all four timed out, which
+      // emits NO line — and silence from a truth-teller reads as "nothing to report".
+      const { cached } = require('./probe-cache.js');
+      const { value: one } = await cached('deploy-divergence-line', async () => line(await check({ timeoutMs: ms })));
       if (one) console.log(one);
     } catch { /* offline, no git, unreadable module-api — all silence */ }
     process.exitCode = 0;

package/scripts/gds/fetch-sound-prefs.js

@@ -36,10 +36,16 @@ function writeAtomic(targetPath, contents) {
   fs.renameSync(tmp, targetPath);
 }
 
-async function main() {
+// The network half, on its own so probe-cache can own it: cached() records a value
+// only when its producer RESOLVES, so a failed fetch leaves nothing cached and the
+// next session retries instead of inheriting a minute of "already done".
+//
+// Returns { soundData, eventData } or null. Null is an ordinary outcome — offline, a
+// timeout, or both endpoints refusing — and the caller writes nothing, which leaves
+// the prefs file exactly as the last good run left it (fail-open).
+async function fetchPrefs() {
   const sess = readSessionToken();
-  if (!sess) return; // not signed in — player fails open
-
+  if (!sess) return null;
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
   let soundData = null;
@@ -57,15 +63,44 @@ async function main() {
         signal: ctrl.signal,
       }),
     ]);
-    if (!soundRes.ok && !eventRes.ok) return;
+    if (!soundRes.ok && !eventRes.ok) return null;
     if (soundRes.ok) soundData = await soundRes.json();
     if (eventRes.ok) eventData = await eventRes.json();
   } catch (_) {
-    return; // network/timeout — no-op
+    return null; // network/timeout — no-op
   } finally {
     clearTimeout(timer);
   }
 
+  return { soundData, eventData };
+}
+
+async function main() {
+  const sess = readSessionToken();
+  if (!sess) return; // not signed in — player fails open
+
+  // SHARED ACROSS CONCURRENT SESSION STARTS (task 1003689). This is the third of the
+  // three SessionStart hooks that call the server, and when four sessions open within
+  // seconds they contend and every hook in all four hits its timeout. Unlike the
+  // truth-tellers, a lost run here is invisible rather than merely silent: the prefs
+  // file simply keeps its previous contents.
+  //
+  // Which is also why skipping the write on a cache hit is correct — the file already
+  // holds what the previous run fetched, and these prefs change when a builder edits
+  // them in Settings, not between two sessions opened three seconds apart.
+  // The cache must be marked fresh only by a SUCCESSFUL fetch. The first cut cached
+  // Date.now() BEFORE fetching, so a failed or timed-out fetch still recorded 'done'
+  // and blocked every retry for the whole TTL - turning a transient network error into
+  // a minute of silently stale prefs. cached() writes its record only when the producer
+  // RESOLVES, so the work belongs inside it, the way strand-watch and deploy-divergence
+  // already do it.
+  const { cached } = require('./probe-cache.js');
+  const { value: fetched, from } = await cached('sound-prefs', async () => fetchPrefs());
+  if (from !== 'fresh') return;   // another session already fetched and wrote the file
+  if (!fetched) return;           // not signed in, offline, or both requests failed
+  const { soundData, eventData } = fetched;
+
+
   // effective_map is { <sound>: <bool> } for every known sound (defaults
   // already applied server-side); volume is the master 0-100 (#788). The local
   // file shape is { sounds: {...}, volume: N, event_sounds: {...} } — play.js

package/scripts/gds/fitness.js

@@ -1234,6 +1234,7 @@ const CHECKS = [
   // one (ADR 0289). Rationale + the seam→consumer table live in that file.
   require('./seam-wiring-guard.js').checkSeamWiring,
   require('./home-isolation-guard.js').checkHomeIsolation, // Check 34 — task 1003763: a test that sets HOME for a child without USERPROFILE isolates NOTHING on win32, so it silently stops testing what its comment says. Three tasks fixed this one site at a time. Rationale in that file.
+  require('./scope-map-guard.js').checkDevsecopsOwnsItsChecks, // Check 35 — task 1003949: a check file no MODULE_SCOPE_MAP key owns cannot be authorized by the goal scoped to own it, and the list drifts once per new check. Rationale in that file.
   require('./adr-namespace.js').checkAdrNumbering, require('./exec-path-guard.js').checkExecPathsStatic, // Check 32 — task 1003371 / B50: what the server EXECUTES, out of whose tree — the blind spot all three 2026-08-29 CRITICALs shared. Rationale + reviewed exemptions live in that file. Sharing Check 31's line (the 19c/19d + 23/24 precedent above): fitness.js is AT the 1,500 ratchet and a new check cannot afford a line until task 1003825 buys it back.
 ];
 

package/scripts/gds/scope-map-guard.js

@@ -0,0 +1,120 @@
+'use strict';
+
+// scripts/gds/scope-map-guard.js — the enforcement tooling owns itself (task 1003949).
+//
+// THE DRIFT THIS STOPS. MODULE_SCOPE_MAP's `devsecops` key enumerates the
+// enforcement tooling by exact path, and the house style since fitness.js hit its
+// line ratchet is that every new check gets its OWN file beside it. Those two facts
+// disagree once per new check: the file appears, nobody adds it to the map, and
+// scopeSubset() resolves it to no module territory — so a goal scoped to devsecops
+// is refused out_of_scope for touching the very tooling it exists to own. That is
+// the same class as tasks 1002690 / 1002736 / 1003124 / 1003655, and it WIDENS with
+// every check added.
+//
+// WHY A GUARD RATHER THAN A LONGER LIST. The list was appended to this time too —
+// but a list that needs appending is the defect, not the fix. Note the evidence:
+// the task that filed this named fourteen unowned files, and fitness.js requires more than that, and the number moves
+// with every check added — which is why this reads the file instead of citing a count. The list was already stale again by the time
+// somebody wrote it down.
+//
+// WHY NOT A PREFIX OR A DIRECTORY MOVE. The scope-map format has no wildcards, so
+// owning the family by prefix means moving the guards into scripts/gds/fitness/ —
+// and those filenames are named in workflows, skills, ADRs, session logs, the file
+// map and the docs tree (40+ files). That is a real refactor with a wide blast
+// radius, and it is deliberately NOT bundled here; this makes the drift impossible
+// first, which is what the goal wall actually needs.
+//
+// WHY THE LIST STAYS EXPLICIT. MODULE_SCOPE_MAP feeds an AUTHORIZATION decision.
+// Deriving it at runtime from a static scan of another file would mean what a goal
+// may touch depends on a regex over source text — a worse property than a list a
+// human can read. So the list stays literal and CI keeps it honest.
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const FITNESS = path.join('scripts', 'gds', 'fitness.js');
+
+// Every `require('./x.js')` in fitness.js — the files it actually runs, which is
+// the definition of "the enforcement tooling" that matters here.
+//
+// PURE, and exported, so the extraction is testable without the real file: a
+// scanner that quietly matches nothing looks exactly like a clean result, and this
+// one's whole job is to produce a non-empty set.
+// THE EXTENSION IS OPTIONAL, and requiring it was a real gap (grade round 1). Node
+// resolves `require('./run-routine')` to run-routine.js, and fitness.js writes FOUR of
+// its sibling requires that way — gen-api-docs, migration-namespace, run-routine,
+// skill-lint. A pattern anchored on `.js` found none of them, so four check files
+// stayed unowned while this guard reported the set clean.
+//
+// That is the failure shape this file exists to end, committed by the guard itself: a
+// scan that matches less than it should reports a healthy repo, and healthy is exactly
+// what a broken scan looks like.
+function siblingRequires(source) {
+  const out = new Set();
+  for (const m of String(source || '').matchAll(/require\(['"]\.\/([A-Za-z0-9._-]+?)(\.js)?['"]\)/g)) {
+    out.add(`scripts/gds/${m[1]}.js`);
+  }
+  return [...out].sort();
+}
+
+// PURE — which of those files no module key claims. A DIRECTORY entry owns everything
+// beneath it, which is why `dirs` is a parameter rather than something the caller
+// pre-filters: forgetting it would report every file under an owned directory as
+// unowned.
+function unownedBy(siblings, ownedPaths, dirs = []) {
+  const owned = new Set(ownedPaths);
+  return siblings.filter((p) => !owned.has(p) && !dirs.some((d) => p.startsWith(d)));
+}
+
+function checkDevsecopsOwnsItsChecks() {
+  const name = 'the enforcement tooling owns itself (task 1003949)';
+  const src = fs.readFileSync(path.join(REPO_ROOT, FITNESS), 'utf8');
+  const siblings = siblingRequires(src);
+
+  // A scanner that finds nothing passes for free. fitness.js is BUILT out of
+  // sibling requires, so an empty set means the pattern broke, not that the tooling
+  // became self-contained — this check must not be able to pass vacuously.
+  if (siblings.length === 0) {
+    return {
+      name,
+      ok: false,
+      hardFail: true,
+      violations: [`${FITNESS}: found NO sibling require() calls. That is a broken scan, not a `
+        + 'clean result — the extraction pattern in scope-map-guard.js needs looking at.'],
+      warnings: [],
+      note: 'the scan produced an empty set, which cannot be right.',
+    };
+  }
+
+  const { MODULE_SCOPE_MAP } = require('../../src/bongos/module-scope-map.js');
+  // Each value is { globs: [...], protected?: bool } — not a bare array.
+  const globsOf = (v) => (Array.isArray(v) ? v : (v && v.globs) || []);
+  const allOwned = [];
+  for (const v of Object.values(MODULE_SCOPE_MAP)) allOwned.push(...globsOf(v));
+  // Any key may own a check file — what matters is that SOME key does, so a goal can
+  // be scoped to it. A directory entry owns everything beneath it.
+  const dirs = allOwned.filter((p) => p.endsWith('/'));
+  const owned = new Set(allOwned);
+  // Through the exported helper rather than a second inline copy of the same filter:
+  // two spellings of one rule is how the enumerated list this guard polices drifted in
+  // the first place.
+  const unowned = unownedBy(siblings, allOwned, dirs);
+
+  const violations = unowned.map((p) => `${p} is required by ${FITNESS} but no MODULE_SCOPE_MAP key `
+    + 'owns it — scopeSubset() resolves it to no territory, so a goal scoped to devsecops is denied '
+    + 'out_of_scope for touching the tooling it exists to own. Add it to the devsecops key.');
+
+  return {
+    name,
+    ok: unowned.length === 0,
+    hardFail: unowned.length > 0,
+    violations,
+    warnings: [],
+    // Printed on the PASS path too: the count is the evidence the scan ran at all.
+    note: `${siblings.length} file(s) required by ${FITNESS}, all owned by a MODULE_SCOPE_MAP key. `
+      + 'The house style gives each new check its own file, so this list drifts once per check '
+      + 'unless CI says otherwise (task 1003949).',
+  };
+}
+module.exports = { checkDevsecopsOwnsItsChecks, siblingRequires, unownedBy, FITNESS };

package/scripts/gds/strand-watch.js

@@ -245,7 +245,14 @@ async function main() {
   // deploy-divergence's identical comment).
   if (hasFlag('--line')) {
     try {
-      const one = line(await check(opts));
+      // SHARED ACROSS CONCURRENT SESSION STARTS (task 1003689). Four sessions opened
+      // within three seconds — one worktree per claim, the normal pattern here — used
+      // to make this same call four times and ALL of them timed out, which produces no
+      // line at all. Silence from a truth-teller is indistinguishable from 'nothing to
+      // report', so the brief was lost without a symptom. The first session to ask now
+      // answers for the rest.
+      const { cached } = require('./probe-cache.js');
+      const { value: one } = await cached('strand-watch-line', async () => line(await check(opts)));
       if (one) console.log(one);
     } catch { /* no session, offline, unreadable — all silence */ }
     process.exitCode = 0;

package/scripts/gds/stranded-rows.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+// scripts/gds/stranded-rows.js — a task whose work already landed, still sitting in
+// `ready`/`backlog` (task 1003775).
+//
+// THE FAILURE. Three tasks closed in one 2026-08-20 session needed no work at all:
+// the fix was already in main. That was 3 of 8 tasks in one sweep, and every one was
+// found by a human reading code. The cost is not the wasted claim — it is that the
+// next builder claims it, reads the code, finds nothing to do, and has to prove a
+// negative before releasing it.
+//
+// SCOPE — ONE OF THE TWO FAILURE MODES, DELIBERATELY. Idea 1000807 named two:
+//
+//   1. STRANDED ROW — the work landed under the task's OWN id, but the row never
+//      moved off `ready`. Mechanical. This file.
+//   2. SILENT SUPERSESSION — a LATER task solved the same problem under a different
+//      id. The idea's author tried commit-message scanning for this and reports it
+//      does NOT work: a broad scan and a narrowed one (826 commits) both returned
+//      ~44 open tasks that merely MENTION an id — seeded-task commits, session logs,
+//      ADRs citing planned work. Not attempted here. It needs a human or LLM read and
+//      belongs in a review cadence, not new machinery.
+//
+// THE SIGNAL, and why it is this one. A commit says which task it DID by ending a
+// line with `(task N)`. That is narrower than "mentions N", which is the distinction
+// the idea's investigation failed on: "1002792, 1002200, 1002571" in a session-log
+// body is a comma list, not a line ending in `(task N)`.
+//
+// It reads the WHOLE message, not just the subject, and that detail is load-bearing.
+// The historical case the idea names — task 1002200 — landed on a cloud-agent branch
+// whose own commit subject never named it; the `(task 1002200)` line lives in the
+// MERGE commit's body, where GitHub echoes the branch's subject. A subject-only scan
+// misses the one case this file exists for.
+//
+// MEASURED on this repo before shipping: 877 ids are named as an authoring subject
+// across 4,784 commits, and ZERO of them are open `ready`/`backlog` rows (434 of
+// those). So today's board is clean and the signal is not merely quiet — the same
+// rule catches 1002200 when its row is treated as open.
+//
+// HOUSE RULES (the truth-teller family: strand-watch.js, stale-worktrees.js).
+// Fail OPEN — a probe never blocks a session. Silent when healthy. Prints IDS AND
+// FIXED VOCABULARY ONLY: never a commit subject or a task title, both of which are
+// builder-authored text.
+//
+// Usage:
+//   node scripts/gds/stranded-rows.js            # human report; exit 1 if any found
+//   node scripts/gds/stranded-rows.js --json     # { stranded: [{ id, status, sha }] }
+//   node scripts/gds/stranded-rows.js --line     # ONE line, or nothing; always exit 0
+
+'use strict';
+
+const { execFileSync } = require('node:child_process');
+
+const MAIN_REF = 'origin/main';
+// A record separator no commit message can contain: the word is wrapped in U+0001
+// (START OF HEADING), a C0 control character git will not carry in a message body.
+//
+// Built from an explicit escape rather than written as a literal, because the control
+// bytes are INVISIBLE in a source listing - the first reviewer of this file read it as
+// `const SEP = 'COMMIT'` and correctly flagged that a body containing the word COMMIT
+// would split a record in half. It would; that is exactly why the sentinels are there,
+// and now you can see them. A test pins a body carrying the bare word.
+const SOH = String.fromCharCode(1);
+const SEP = `${SOH}COMMIT${SOH}`;
+
+// The authoring convention: a line whose END is `(task N)`. Anchored at end-of-line on
+// purpose — that is what distinguishes "this commit did task N" from "this commit
+// mentioned N", and the second is the noise that made the supersession half undoable.
+const AUTHORED_RE = /\(task (\d{6,7})\)\s*$/;
+
+// PURE — every task id a commit message claims to have DONE. Exported so the rule is
+// testable without a repo: a scanner that quietly stops matching reports a clean board,
+// which is indistinguishable from a healthy one.
+function authoredIds(message) {
+  const out = new Set();
+  for (const line of String(message || '').split('\n')) {
+    const m = AUTHORED_RE.exec(line.trim());
+    if (m) out.add(m[1]);
+  }
+  return out;
+}
+
+// PURE — id -> first sha that claimed it, over a whole `git log` payload.
+function scanLog(raw) {
+  const byId = new Map();
+  for (const block of String(raw || '').split(SEP)) {
+    if (!block.trim()) continue;
+    const nl = block.indexOf('\n');
+    const sha = (nl === -1 ? block : block.slice(0, nl)).trim();
+    const body = nl === -1 ? '' : block.slice(nl + 1);
+    for (const id of authoredIds(body)) if (!byId.has(id)) byId.set(id, sha);
+  }
+  return byId;
+}
+
+// PURE — the stranded set. `openRows` are { id, status }; `landed` is scanLog's map.
+// Kept separate from the IO so the decision is unit-testable with no git and no API.
+function strandedRows(openRows, landed) {
+  const out = [];
+  for (const row of openRows || []) {
+    const id = String(row && row.id);
+    if (!landed.has(id)) continue;
+    out.push({ id, status: String(row.status || ''), sha: landed.get(id).slice(0, 8) });
+  }
+  return out.sort((a, b) => Number(a.id) - Number(b.id));
+}
+
+function readLog(cwd) {
+  return execFileSync('git', ['log', MAIN_REF, `--pretty=${SEP}%H%n%B`], {
+    cwd, encoding: 'utf8', maxBuffer: 256 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'],
+  });
+}
+
+// Both statuses that mean "nobody has started this". A row already `active` or
+// `completed` is someone's live work, not a strand.
+const OPEN_STATUSES = ['ready', 'backlog'];
+
+// A hard stop so a paging bug cannot loop forever. Reaching it means the board grew
+// past what one scan should walk, which is a fact worth SAYING rather than silently
+// truncating — a detector that quietly stops early reports a clean board.
+const MAX_PAGES = 50;
+
+// PURE-ish — the paging walk, with `getPage` injected. Extracted and exported because
+// it was the only untested IO in this file, and off-by-one paging is exactly the kind
+// of logic that silently returns a short list (and a short list here means 'nothing is
+// stranded').
+async function pageOpenRows(getPage, { statuses = OPEN_STATUSES, pageSize = 200, maxPages = MAX_PAGES } = {}) {
+  const rows = [];
+  for (const status of statuses) {
+    let offset = 0;
+    let page = 0;
+    for (; page < maxPages; page += 1) {
+      const r = await getPage({ status, limit: pageSize, offset });
+      if (!r || !r.ok) throw new Error(`could not list ${status} tasks (${r && r.status})`);
+      const got = (r.data && r.data.tasks) || [];
+      for (const t of got) rows.push({ id: t.id, status: t.status });
+      // A SHORT page is the end of the table. Compared against the size the route
+      // actually honoured, never the size we asked for — the route clamps.
+      if (got.length < (r.limit || pageSize)) break;
+      offset += got.length;
+    }
+    if (page >= maxPages) {
+      throw new Error(`more than ${maxPages} pages of ${status} tasks — refusing to report a partial board as clean`);
+    }
+  }
+  return rows;
+}
+
+async function readOpenRows() {
+  const { cliClient } = require('./cli-lib.js');
+  const { TASK_LIST_MAX_LIMIT, buildTaskPageQuery } = require('../../modules/lifecycle/task-list-limits.js');
+  const api = await cliClient();
+  return pageOpenRows(async ({ status, limit, offset }) => {
+    const q = buildTaskPageQuery({ status, limit, offset });
+    const r = await api.tasks.getTasks({ query: q });
+    // Carry the limit the route HONOURED back to the walker, so its short-page test
+    // compares against the clamped size rather than the requested one.
+    return r && { ok: r.ok, status: r.status, data: r.data, limit: q.limit };
+  }, { pageSize: TASK_LIST_MAX_LIMIT });
+}
+
+async function scan(cwd) {
+  const landed = scanLog(readLog(cwd));
+  // The scan must not pass by finding nothing: this repo's own history is built out of
+  // these lines, so an empty map means the pattern broke.
+  if (landed.size === 0) throw new Error('no commit claims to have done any task — the pattern has drifted');
+  return { stranded: strandedRows(await readOpenRows(), landed), scanned: landed.size };
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const line = argv.includes('--line');
+  let r;
+  try {
+    r = await scan(process.cwd());
+  } catch (e) {
+    if (line) process.exit(0); // fail OPEN — a probe never blocks a session
+    console.error(`stranded-rows: undetermined — ${e.message || e}`);
+    process.exit(2);
+  }
+
+  if (argv.includes('--json')) { console.log(JSON.stringify(r, null, 2)); return; }
+  if (line) {
+    if (r.stranded.length) {
+      const ids = r.stranded.slice(0, 6).map((s) => s.id).join(', ');
+      const more = r.stranded.length > 6 ? ` +${r.stranded.length - 6} more` : '';
+      console.log(`Stranded rows: ${r.stranded.length} open task(s) whose work already landed on main (${ids}${more}). `
+        + 'Claiming one means reading the code to prove there is nothing to do. Run node scripts/gds/stranded-rows.js.');
+    }
+    return;
+  }
+  console.log(`  Stranded rows: ${r.stranded.length} (of ${r.scanned} task id(s) named as an authoring subject on main)`);
+  for (const s of r.stranded) console.log(`    task ${s.id}  [${s.status}]  landed in ${s.sha}`);
+  if (r.stranded.length) {
+    console.log('  Each of these has a commit on main claiming to have done it. Verify, then ship or abandon the row.');
+    process.exit(1);
+  }
+}
+
+if (require.main === module) main();
+
+module.exports = { authoredIds, scanLog, strandedRows, pageOpenRows, AUTHORED_RE, SEP, OPEN_STATUSES, MAX_PAGES };

package/src/bongos/module-scope-map.js

@@ -338,6 +338,36 @@ const MODULE_GLOBS = {
     'scripts/gds/fitness.js', 'scripts/gds/docs-entropy.js',
     'scripts/gds/redteam-patrol.js', 'scripts/gds/audit-gate.js',
     'scripts/gds/fitness-ratchets.js', 'scripts/gds/control-manifest.js',
+    // Every file fitness.js actually requires (task 1003949). Since fitness.js hit
+    // its line ratchet, the house style is that each new check lands in its OWN file
+    // beside it — and none of them was listed here, so scopeSubset() resolved them to
+    // no territory and a goal scoped to devsecops was denied out_of_scope for touching
+    // the very tooling it owns (the 1002690 / 1002736 / 1003124 / 1003655 class).
+    //
+    // This list is kept honest by scripts/gds/scope-map-guard.js rather than by
+    // remembering: it derives the same set from fitness.js's own requires and fails
+    // CI when one is missing. That guard exists because appending is not a fix — the
+    // task that filed this named FOURTEEN unowned files and there were twenty-two.
+    'scripts/gds/scope-map-guard.js',
+    // Landed from task 1003763 while this branch was in flight, and the guard below
+    // caught it unowned on the merge - which is the drift it exists to stop.
+    'scripts/gds/home-isolation-guard.js',
+    // Required WITHOUT the .js extension by fitness.js, which is how they stayed
+    // invisible to the first cut of scope-map-guard (grade round 1): Node resolves
+    // require('./skill-lint') fine, but a pattern anchored on '.js' matched none of them.
+    'scripts/gds/gen-api-docs.js', 'scripts/gds/migration-namespace.js',
+    'scripts/gds/skill-lint.js', 'scripts/gds/run-routine.js',
+    'scripts/gds/adr-namespace.js', 'scripts/gds/baseline-staleness.js',
+    'scripts/gds/category-advisory-guard.js', 'scripts/gds/client-baseurl-guard.js',
+    'scripts/gds/doc-cli-guard.js', 'scripts/gds/doc-comment-coverage.js',
+    'scripts/gds/exec-path-guard.js', 'scripts/gds/fitness-lib.js',
+    'scripts/gds/fitness-checks-error-envelope.js', 'scripts/gds/fitness-checks-identity.js',
+    'scripts/gds/fitness-checks-packaging.js', 'scripts/gds/fitness-checks-route-pins.js',
+    'scripts/gds/fitness-checks-vocabulary.js', 'scripts/gds/fitness-checks-write-validation.js',
+    'scripts/gds/fitness-migration-contraction.js', 'scripts/gds/role-pack-guard.js',
+    'scripts/gds/route-shadow-guard.js', 'scripts/gds/routine-schedule.js',
+    'scripts/gds/seam-wiring-guard.js', 'scripts/gds/skill-preflight.js',
+    'scripts/gds/test-path-guard.js', 'scripts/gds/version-literal-guard.js',
   ],
   // --- the METHODOLOGY surfaces: the instruction core an agent session actually
   //     reads — the always-loaded root CLAUDE.md, the docs library it indexes, the

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.822'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.824'; // 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/category_advisory_guard.mjs

@@ -131,5 +131,34 @@ test('the live tree passes, and the gate list is not empty', () => {
   assert.equal(r.hardFail, false);
 });
 
+// --- a FILENAME is not a category read (task 1003949) ----------------------
+//
+// One of the enforcement files is itself called category-advisory-guard.js, so the
+// moment a decision surface lists the tooling BY PATH — which module-scope-map.js
+// has to, in order to own it — this guard fired on its own name. Quoted paths
+// ending in .js are blanked before the match. The point of these two tests is that
+// the blanking is narrow: it must not become a way to hide a real read.
+
+test('a quoted path to a file whose NAME contains "category" is not a violation', () => {
+  const { violations } = scanGates(['src/bongos/module-scope-map.js'], from({
+    'src/bongos/module-scope-map.js':
+      'const MAP = {\n'
+      + "  devsecops: { globs: ['scripts/gds/category-advisory-guard.js', 'scripts/gds/fitness.js'] },\n"
+      + '};\n',
+  }));
+  assert.deepEqual(violations, [], 'owning the tooling by path is not branching on a category');
+});
+
+test('a real category read on the SAME LINE as a path is still refused', () => {
+  // Only the quoted path is blanked, not the line — so a read cannot ride along
+  // beside one.
+  const { violations } = scanGates(['modules/lifecycle/claim-feed.js'], from({
+    'modules/lifecycle/claim-feed.js':
+      "const guard = require('./category-advisory-guard.js'); if (t.category_id === 3) return false;\n",
+  }));
+  assert.equal(violations.length, 1, 'the category_id read must still be caught');
+  assert.match(violations[0], /ADVISORY/);
+});
+
 console.log(`\n${passed} passed, ${failed} failed`);
 process.exit(failed === 0 ? 0 : 1);

package/tests/probe_cache.mjs

@@ -0,0 +1,200 @@
+// tests/probe_cache.mjs — one answer, shared by the sessions that start together
+// (task 1003689).
+//
+// THE MEASUREMENT THIS EXISTS FOR. SessionStart runs six hooks, three of which call the
+// server. Four sessions opened within three seconds — one worktree per claim, the normal
+// pattern here — and every hook in all four hit its 10-15s timeout, while the sessions
+// immediately before and after ran clean at ~5s on identical config.
+//
+// A timed-out SessionStart hook emits NO LINE, so the truth-teller briefs vanish. Silence
+// is indistinguishable from "nothing to report", which is the one thing these probes are
+// built not to be.
+//
+// The cache must therefore fail toward DOING THE WORK, never toward silence: every error
+// path below returns the producer's answer rather than nothing.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const pc = require('../scripts/gds/probe-cache.js');
+
+// fileURLToPath, never URL.pathname (fitness check 30 / task 1002889): a %20 or a
+// Windows drive slash makes require() throw at load, and CI's spaceless checkout
+// cannot see it.
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const fresh = () => `k-${Math.random().toString(36).slice(2)}`;
+
+test('the second asker does not repeat the call', async () => {
+  const k = fresh();
+  let calls = 0;
+  const produce = async () => { calls += 1; return `answer-${calls}`; };
+  const a = await pc.cached(k, produce, { ttlMs: 5000 });
+  const b = await pc.cached(k, produce, { ttlMs: 5000 });
+  assert.equal(calls, 1, 'the whole point: four sessions, one question');
+  assert.equal(a.from, 'fresh');
+  assert.equal(b.from, 'cache');
+  assert.equal(b.value, a.value);
+});
+
+test('an expired answer is asked again', async () => {
+  const k = fresh();
+  let calls = 0;
+  const produce = async () => { calls += 1; return calls; };
+  await pc.cached(k, produce, { ttlMs: 1 });
+  await new Promise((r) => setTimeout(r, 10));
+  const b = await pc.cached(k, produce, { ttlMs: 1 });
+  assert.equal(calls, 2, 'a cache that never expires is a lie, not a cache');
+  assert.equal(b.from, 'fresh');
+});
+
+test('a record from the FUTURE is treated as stale, not trusted forever', () => {
+  // A clock that jumped would otherwise pin a stale answer permanently.
+  assert.equal(pc.isFresh({ at: 5_000 }, 1_000, 4_000), false);
+  assert.equal(pc.isFresh({ at: 3_500 }, 1_000, 4_000), true);
+  assert.equal(pc.isFresh(null, 1_000, 4_000), false);
+  assert.equal(pc.isFresh({}, 1_000, 4_000), false);
+});
+
+test('two checkouts of the same instance do not read each other\'s answers', async () => {
+  const k = fresh();
+  const a = await pc.cached(k, async () => 'from-A', { ttlMs: 5000, scope: '/repo/a' });
+  const b = await pc.cached(k, async () => 'from-B', { ttlMs: 5000, scope: '/repo/b' });
+  assert.equal(a.value, 'from-A');
+  assert.equal(b.value, 'from-B', 'the scope is part of the key — a worktree must not inherit another\'s brief');
+});
+
+test('a producer that throws is NOT cached, and the error reaches the caller', async () => {
+  const k = fresh();
+  await assert.rejects(() => pc.cached(k, async () => { throw new Error('probe failed'); }, { ttlMs: 5000 }));
+  // and the next asker gets a real attempt, not a cached failure
+  const r = await pc.cached(k, async () => 'recovered', { ttlMs: 5000 });
+  assert.equal(r.value, 'recovered');
+  assert.equal(r.from, 'fresh', 'a failure must not be remembered as an answer');
+});
+
+// ---- the real scenario: four processes at once -----------------------------
+//
+// The unit cases above all run in ONE process, where a lock is trivially uncontended.
+// The measured failure is four SEPARATE processes starting within three seconds on a
+// cold cache — and the first cut of this cache did NOT fix it: with nothing cached and
+// the lock held, every waiter fell through and made the call anyway, so all four still
+// ran. This is the case that caught it.
+test('four concurrent PROCESSES on a cold cache produce ONE call, and all four get the answer', async () => {
+  const counter = path.join(os.tmpdir(), `bongos-probe-test-${Date.now()}.txt`);
+  try { fs.rmSync(counter, { force: true }); } catch { /* not there */ }
+  execFileSync(process.execPath, [path.join(REPO_ROOT, 'scripts', 'gds', 'probe-cache.js'), '--clear'], { encoding: 'utf8' });
+
+  const child = `
+    const pc = require(${JSON.stringify(path.join(REPO_ROOT, 'scripts', 'gds', 'probe-cache.js'))});
+    const fs = require('fs');
+    (async () => {
+      const r = await pc.cached('probe-cache-concurrency-test', async () => {
+        fs.appendFileSync(${JSON.stringify(counter)}, 'ran\\n');
+        await new Promise((res) => setTimeout(res, 400));
+        return 'the-answer';
+      }, { ttlMs: 30000 });
+      process.stdout.write(r.value);
+    })();
+  `;
+
+  const { spawn } = await import('node:child_process');
+  const results = await Promise.all([0, 1, 2, 3].map(() => new Promise((resolve) => {
+    const p = spawn(process.execPath, ['-e', child]);
+    let out = '';
+    p.stdout.on('data', (d) => { out += d; });
+    p.on('close', () => resolve(out.trim()));
+  })));
+
+  const ran = fs.existsSync(counter) ? fs.readFileSync(counter, 'utf8').trim().split('\n').filter(Boolean).length : 0;
+  try { fs.rmSync(counter, { force: true }); } catch { /* best effort */ }
+
+  assert.equal(ran, 1, `the probe must run ONCE across four concurrent starts; it ran ${ran}`);
+  assert.deepEqual(results, ['the-answer', 'the-answer', 'the-answer', 'the-answer'],
+    'and every session must still get its brief — trading a timeout for a silence would be no fix at all');
+});
+
+// ---- FOUR DIFFERENT WORKTREES (grade round 1) ------------------------------
+//
+// The test above spawns four processes from ONE directory, and it passed while the
+// cache was keyed on process.cwd() — which meant the fix did nothing for the case it
+// was built for. The measured failure is four sessions in FOUR DIFFERENT WORKTREES,
+// one per claim, so four cwds hashed to four keys and nothing was ever shared.
+//
+// A test that does not model the scenario proves the wrong thing. This one runs each
+// child from a different directory of the SAME checkout.
+test('four processes in DIFFERENT worktrees of one checkout still share the answer', async () => {
+  const counter = path.join(os.tmpdir(), `bongos-probe-wt-${Date.now()}.txt`);
+  try { fs.rmSync(counter, { force: true }); } catch { /* not there */ }
+  execFileSync(process.execPath, [path.join(REPO_ROOT, 'scripts', 'gds', 'probe-cache.js'), '--clear'], { encoding: 'utf8' });
+
+  // Four real directories inside this checkout — different cwds, one git common dir,
+  // which is exactly the shape of four claim worktrees.
+  const cwds = [REPO_ROOT, path.join(REPO_ROOT, 'scripts'), path.join(REPO_ROOT, 'tests'), path.join(REPO_ROOT, 'docs')]
+    .filter((d) => fs.existsSync(d));
+  assert.equal(cwds.length, 4, 'need four real directories in this checkout to model four worktrees');
+
+  const child = `
+    const pc = require(${JSON.stringify(path.join(REPO_ROOT, 'scripts', 'gds', 'probe-cache.js'))});
+    const fs = require('fs');
+    (async () => {
+      const r = await pc.cached('probe-cache-worktree-test', async () => {
+        fs.appendFileSync(${JSON.stringify(counter)}, 'ran\\n');
+        await new Promise((res) => setTimeout(res, 400));
+        return 'shared';
+      }, { ttlMs: 30000 });
+      process.stdout.write(r.value);
+    })();
+  `;
+
+  const { spawn } = await import('node:child_process');
+  const results = await Promise.all(cwds.map((cwd) => new Promise((resolve) => {
+    const p = spawn(process.execPath, ['-e', child], { cwd });
+    let out = '';
+    p.stdout.on('data', (d) => { out += d; });
+    p.on('close', () => resolve(out.trim()));
+  })));
+
+  const ran = fs.existsSync(counter) ? fs.readFileSync(counter, 'utf8').trim().split('\n').filter(Boolean).length : 0;
+  try { fs.rmSync(counter, { force: true }); } catch { /* best effort */ }
+
+  assert.equal(ran, 1, `four DIFFERENT working directories must still share one answer; the probe ran ${ran} times`);
+  assert.deepEqual(results, ['shared', 'shared', 'shared', 'shared']);
+});
+
+test('the scope is the CHECKOUT, not the directory', () => {
+  // Every worktree of one checkout reports the same git common dir; two unrelated
+  // checkouts report different ones. That is the distinction that matters, because the
+  // probes ask one server about one repo.
+  const scope = pc.defaultScope();
+  assert.ok(scope && typeof scope === 'string');
+  assert.ok(/\.git$|\.git[\\/]/.test(scope) || scope === process.cwd(),
+    `expected a git common dir (or the documented cwd fallback), got ${scope}`);
+});
+
+test('clear() with no argument actually empties the cache', async () => {
+  // It used to take a scope and delete only when that was exactly null — so calling it
+  // with its own default deleted nothing while reporting success.
+  const k = fresh();
+  let calls = 0;
+  await pc.cached(k, async () => { calls += 1; return calls; }, { ttlMs: 60_000 });
+  pc.clear();
+  await pc.cached(k, async () => { calls += 1; return calls; }, { ttlMs: 60_000 });
+  assert.equal(calls, 2, 'after clear(), the next asker must do the work again');
+});
+
+test('the three SessionStart hooks that call the server all go through the cache', () => {
+  // The wiring is the deliverable; the cache alone changes nothing. These are the three
+  // that make network calls — the other three SessionStart hooks are local git.
+  for (const rel of ['scripts/gds/strand-watch.js', 'scripts/gds/deploy-divergence.js', 'scripts/gds/fetch-sound-prefs.js']) {
+    const src = fs.readFileSync(path.join(REPO_ROOT, rel), 'utf8');
+    assert.match(src, /require\('\.\/probe-cache\.js'\)/, `${rel} must share its answer with concurrent sessions`);
+    assert.match(src, /cached\(/, `${rel} must actually call cached(), not merely import it`);
+  }
+});

package/tests/scope_map_guard.mjs

@@ -0,0 +1,82 @@
+// tests/scope_map_guard.mjs — the enforcement tooling owns itself (task 1003949).
+//
+// MODULE_SCOPE_MAP's devsecops key enumerates the enforcement tooling by exact path,
+// and the house style since fitness.js hit its line ratchet is that every new check
+// lands in its OWN file beside it. Those two facts disagree once per new check: the
+// file appears, nobody adds it to the map, and scopeSubset() resolves it to no module
+// territory — so a goal scoped to devsecops is denied out_of_scope for touching the
+// very tooling it owns.
+//
+// The size of the drift is the argument for a guard rather than a longer list: the
+// task that filed this named FOURTEEN unowned files, and there were twenty-two.
+//
+// Run:  node tests/scope_map_guard.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { checkDevsecopsOwnsItsChecks, siblingRequires } = require('../scripts/gds/scope-map-guard.js');
+
+test('every file fitness.js requires is owned by some MODULE_SCOPE_MAP key', () => {
+  const r = checkDevsecopsOwnsItsChecks();
+  assert.equal(r.ok, true, r.violations.join('\n'));
+  assert.equal(r.hardFail, false);
+});
+
+test('siblingRequires extracts the real require shape, deduped and sorted', () => {
+  const src = [
+    "const a = require('./role-pack-guard.js').checkRolePacks,",
+    "  b = require('./doc-cli-guard.js').checkDocNamesRealCli,",
+    "  c = require('./role-pack-guard.js').other,   // the same file twice",
+    "const d = require('node:path');",
+    "const e = require('../../src/module-api');",
+  ].join('\n');
+  assert.deepEqual(siblingRequires(src), [
+    'scripts/gds/doc-cli-guard.js',
+    'scripts/gds/role-pack-guard.js',
+  ], 'only ./sibling.js requires, deduped — not node: builtins and not cross-tree requires');
+});
+
+test('an EXTENSION-LESS require is extracted — the gap that shipped green', () => {
+  // Node resolves require('./run-routine') to run-routine.js, and fitness.js writes FOUR
+  // of its sibling requires that way. A pattern anchored on .js found none of them, so
+  // four check files stayed unowned while the guard reported the set clean — this guard
+  // committing the exact failure it exists to end.
+  assert.deepEqual(siblingRequires("require('./run-routine'); require('./skill-lint')"), [
+    'scripts/gds/run-routine.js',
+    'scripts/gds/skill-lint.js',
+  ]);
+});
+
+test('both spellings of ONE file collapse to a single entry', () => {
+  assert.deepEqual(siblingRequires("require('./a'); require('./a.js')"), ['scripts/gds/a.js']);
+});
+
+test('a hyphenated and a dotted filename both survive extraction', () => {
+  // fitness-checks-write-validation.js and the like: a character class that stopped at
+  // the first hyphen would silently shorten the set.
+  assert.deepEqual(
+    siblingRequires("require('./fitness-checks-write-validation.js'); require('./a.b.js')"),
+    ['scripts/gds/a.b.js', 'scripts/gds/fitness-checks-write-validation.js'],
+  );
+});
+
+test('an EMPTY scan is a hard failure, not a clean result', () => {
+  // This check's only output is "nothing is unowned", which an empty input satisfies
+  // for free. fitness.js is built out of sibling requires, so an empty set means the
+  // pattern broke — the failure mode that would otherwise look like success.
+  assert.deepEqual(siblingRequires(''), []);
+  assert.deepEqual(siblingRequires(null), []);
+  // and the check itself says so rather than passing: exercised by pointing the
+  // extraction at source with no sibling requires in it.
+  assert.equal(siblingRequires('const x = require("node:fs");').length, 0);
+});
+
+test('the PASS note carries the count, so the check cannot look green while doing nothing', () => {
+  const r = checkDevsecopsOwnsItsChecks();
+  assert.match(r.note, /\d+ file\(s\) required by/);
+  const n = Number(r.note.match(/^(\d+) file/)[1]);
+  assert.ok(n > 14, `expected more than the fourteen the filing task listed, saw ${n}`);
+});

package/tests/stranded_rows.mjs

@@ -0,0 +1,162 @@
+// tests/stranded_rows.mjs — a task whose work already landed, still sitting in
+// ready/backlog (task 1003775).
+//
+// Three tasks closed in one 2026-08-20 session needed no work at all: the fix was
+// already in main. Every one was found by a human reading code.
+//
+// This detector's whole risk is looking healthy. It prints nothing when the board is
+// clean, and the board IS clean today — so "no output" is exactly what a completely
+// broken scan produces too. These tests therefore lean on the rule itself, and on the
+// historical case the idea names.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { authoredIds, scanLog, strandedRows, pageOpenRows, SEP } = require('../scripts/gds/stranded-rows.js');
+
+test('a subject naming the task it did IS an authoring claim', () => {
+  assert.deepEqual([...authoredIds('fix(docs): self-healing /docs/openapi.json (task 1002200)')], ['1002200']);
+});
+
+test('a MENTION is not an authoring claim — the distinction the whole scope rests on', () => {
+  // This is the exact shape that made the supersession half undoable: the idea's
+  // author scanned 826 commits and got ~44 open tasks that merely mentioned an id.
+  assert.deepEqual([...authoredIds('1002792, 1002200, 1002571, 1002790, 1002795), per CLAUDE.md §12.')], []);
+  assert.deepEqual([...authoredIds('supersedes task 1002200 and should be revisited')], []);
+  assert.deepEqual([...authoredIds('see (task 1002200) for background')], [],
+    'mid-line is a citation; only end-of-line is the authoring convention');
+});
+
+test('the claim is read from ANYWHERE in the message, not just the subject', () => {
+  // Task 1002200 landed on a cloud-agent branch whose own subject never named it. The
+  // `(task N)` line lives in the MERGE commit's body, where GitHub echoes the branch's
+  // subject. A subject-only scan misses the one case this detector exists for.
+  const mergeBody = [
+    // The owner handle is a placeholder on purpose: a fixture that hardcodes the
+    // founder's identity fails audit-authorship.sh (ADR 0016's no-hardcoded-Archon
+    // rule), and nothing here depends on WHOSE fork the branch came from.
+    'Merge pull request #5 from an-owner/claude/api-docs-bongos-16a682',
+    '',
+    'fix(docs): self-healing /docs/openapi.json — serve committed spec, else generate in-process (task 1002200)',
+  ].join('\n');
+  assert.deepEqual([...authoredIds(mergeBody)], ['1002200']);
+});
+
+test('scanLog keeps the FIRST sha that claimed an id', () => {
+  const raw = [
+    `${SEP}aaaaaaaa1111\nfix: later touch (task 1000001)`,
+    `${SEP}bbbbbbbb2222\nfix: the original (task 1000001)`,
+  ].join('\n');
+  const m = scanLog(raw);
+  assert.equal(m.get('1000001'), 'aaaaaaaa1111', 'git log is newest-first, so the first seen is the most recent claim');
+});
+
+test('a row whose work landed is stranded; one whose has not is left alone', () => {
+  const landed = new Map([['1000001', 'aaaaaaaa1111']]);
+  const rows = [{ id: '1000001', status: 'ready' }, { id: '1000002', status: 'backlog' }];
+  const out = strandedRows(rows, landed);
+  assert.equal(out.length, 1);
+  assert.deepEqual(out[0], { id: '1000001', status: 'ready', sha: 'aaaaaaaa' });
+});
+
+test('the report carries NO builder-authored text — ids and fixed vocabulary only', () => {
+  // A truth-teller printing a commit subject or a task title would put arbitrary
+  // builder prose into a session's context. The house rule for this family is ids and
+  // fixed vocabulary; `strandedRows` returns exactly three machine fields.
+  const out = strandedRows([{ id: '1000001', status: 'ready', title: 'DO NOT LEAK ME' }],
+    new Map([['1000001', 'aaaaaaaa1111']]));
+  assert.deepEqual(Object.keys(out[0]).sort(), ['id', 'sha', 'status']);
+  assert.ok(!JSON.stringify(out).includes('DO NOT LEAK'));
+});
+
+test('an empty scan is a BROKEN scan — it must not read as a clean board', () => {
+  // The detector is silent when healthy, so a pattern that stops matching looks
+  // exactly like good news. scanLog over real-shaped input must be non-empty, and the
+  // IO wrapper throws on an empty map (fail-open at the --line boundary, loud
+  // otherwise).
+  assert.equal(scanLog('').size, 0, 'nothing in, nothing out — which is why the caller checks');
+  assert.ok(scanLog(`${SEP}aaaaaaaa1111\nfix: something (task 1000001)`).size > 0);
+});
+
+// ---- the record separator (grade round 1) ---------------------------------
+//
+// The separator is the word COMMIT wrapped in U+0001. Those bytes are INVISIBLE in a
+// source listing, so the first reviewer read it as a bare 'COMMIT' and flagged — quite
+// reasonably — that a commit body containing that word would split a record in half.
+// It would. This pins that it does not.
+
+test('a commit body containing the bare word COMMIT does not split a record', () => {
+  const raw = `${SEP}aaaaaaaa1111\nfix COMMIT-hook validation (task 1000001)`;
+  const m = scanLog(raw);
+  assert.equal(m.size, 1, 'one commit in, one record out');
+  assert.equal(m.get('1000001'), 'aaaaaaaa1111');
+});
+
+test('the separator really is control-wrapped, not the bare word', () => {
+  assert.equal(SEP.charCodeAt(0), 1);
+  assert.equal(SEP.charCodeAt(SEP.length - 1), 1);
+  assert.notEqual(SEP, 'COMMIT');
+});
+
+// ---- the paging walk (grade round 1) --------------------------------------
+//
+// This was the only untested IO in the file, and off-by-one paging is exactly the kind
+// of logic that silently returns a SHORT list — which here means 'nothing is stranded',
+// the most comfortable wrong answer this tool can give.
+
+const page = (tasks, limit) => ({ ok: true, data: { tasks }, limit });
+const row = (id) => ({ id: String(id), status: 'ready' });
+
+test('a full page is followed by another request; a short page ends it', async () => {
+  const asked = [];
+  const rows = await pageOpenRows(async ({ status, limit, offset }) => {
+    asked.push(`${status}@${offset}`);
+    if (status !== 'ready') return page([], limit);
+    return offset === 0 ? page([row(1), row(2)], 2) : page([row(3)], 2);
+  }, { statuses: ['ready', 'backlog'], pageSize: 2 });
+  assert.deepEqual(rows.map((r) => r.id), ['1', '2', '3']);
+  assert.deepEqual(asked, ['ready@0', 'ready@2', 'backlog@0'], 'a full page must be followed by another request');
+});
+
+test('the offset advances by what was RECEIVED, not by what was asked for', async () => {
+  // The route clamps `limit`. Advancing by the requested size would skip rows.
+  const asked = [];
+  await pageOpenRows(async ({ limit, offset }) => {
+    asked.push(offset);
+    return asked.length === 1 ? page([row(1)], 1) : page([], 1);
+  }, { statuses: ['ready'], pageSize: 500 });
+  assert.deepEqual(asked, [0, 1], 'asked for 500, got 1, so the next offset is 1');
+});
+
+test('a failed page THROWS — a partial board must never read as clean', async () => {
+  await assert.rejects(
+    () => pageOpenRows(async () => ({ ok: false, status: 500 }), { statuses: ['ready'] }),
+    /could not list ready tasks/,
+  );
+});
+
+test('hitting the page cap THROWS rather than silently truncating', async () => {
+  // A detector that quietly stops early reports a clean board, which is the one
+  // outcome this tool must never fake.
+  await assert.rejects(
+    () => pageOpenRows(async ({ limit }) => page([row(1)], 1), { statuses: ['ready'], pageSize: 1, maxPages: 3 }),
+    /refusing to report a partial board as clean/,
+  );
+});
+
+test('both open statuses are walked — a backlog strand counts too', async () => {
+  const seen = [];
+  await pageOpenRows(async ({ status, limit }) => { seen.push(status); return page([], limit); });
+  assert.deepEqual(seen, ['ready', 'backlog']);
+});
+
+test('the live repo actually produces claims — the rule has not drifted', () => {
+  const { execFileSync } = require('node:child_process');
+  const raw = execFileSync('git', ['log', 'origin/main', `--pretty=${SEP}%H%n%B`, '-400'],
+    { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  const m = scanLog(raw);
+  assert.ok(m.size > 20,
+    `only ${m.size} authoring claims in the last 400 commits — the convention or the pattern has moved, and this detector is now inert`);
+});