@bongos/core 1.19.821 → 1.19.823

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.821",
-  "core_contract": "1.19.821",
-  "source_commit": "8010be7b18c8402b4992ca02d3ea6486e3864b8d",
+  "core_version": "1.19.823",
+  "core_contract": "1.19.823",
+  "source_commit": "2dbaf2b0a9d49393d3f3daf6f501a09087b8a156",
   "source_ref": "HEAD",
-  "built_at": "2026-09-17T10:54:28.375Z",
+  "built_at": "2026-09-17T11:55:48.898Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 490,
     "agent_docs_stubbed": 26,
-    "functional_verbatim": 2227,
+    "functional_verbatim": 2230,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 2743,
-  "tree_sha256": "b45cfd41d39a01485663e30b259328725d4eb07530cb520214df9811d2842e0b",
+  "file_count": 2746,
+  "tree_sha256": "6b21d5cba0536e95777730af1de9c226f7d38a89997a4cb586847a39748e7f37",
   "files": [
     {
       "path": ".claude/skills/ask-for-help/SKILL.md",
@@ -2547,7 +2547,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "9d562958c91d14116733518e2934b1a78b980adc6a19c652cfe47eb85c3693bf"
+      "sha256": "5236a1550b3f87d767e2f59479b3f2ef8859621f0c57bbd7a054b8d056c1a2ef"
     },
     {
       "path": "docs/modules-contract.md",
@@ -5612,7 +5612,7 @@
     {
       "path": "modules/lifecycle/dead-deps.js",
       "mode": "0000644",
-      "sha256": "c9f7aa89a4b1e9a201189608ff8ebc4910ee6ca19be33ce681f2d32cedb0b39d"
+      "sha256": "4738131a48e85dd7bf0644ddd3686c85d0d1d0da55ee623b1834d048c614b91c"
     },
     {
       "path": "modules/lifecycle/done-when.js",
@@ -7812,12 +7812,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "bd6442d6f7a4122841efdb7ed6d796e43f9df2bb4a65677d19d586af19cb0650"
+      "sha256": "ade8e48efd7ae7eaeb9f51472f731940ca866a1f0a8917de7dadab245428908b"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "8185455c292222a25c1928dc9ef4959bc09783fb71fc231e89dca09793239e44"
+      "sha256": "bd706beddc637ac4587a99436be805e327d7392306525124874ea39092fa6149"
     },
     {
       "path": "public-docs/index.html",
@@ -7947,7 +7947,7 @@
     {
       "path": "scripts/gds/audit-deps.js",
       "mode": "0000644",
-      "sha256": "891aadcbea8ef257f68f20f140fa988c45ac06d4caa19802136c372d403db7ba"
+      "sha256": "ff7ccdf15ae2c215d3330e957d6a36adc7d48f5d9bd5042b5d61bb228b878073"
     },
     {
       "path": "scripts/gds/audit-exports.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",
@@ -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",
@@ -9232,7 +9237,7 @@
     {
       "path": "scripts/gds/strand-watch.js",
       "mode": "0000644",
-      "sha256": "c7f9c997a6892e6ca083a03789b24524912632731ea550df6ee974f1ef05267e"
+      "sha256": "2a9959bd2e45046dadcda9982998a5b7163cef00b5d719ff299314daa5409770"
     },
     {
       "path": "scripts/gds/stray-unit-sweep.sh",
@@ -9722,7 +9727,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "363876fc33b090bf88ca7b767b82778feb63ee9bb607c00e4a37a2aae0b5416f"
+      "sha256": "2ac366c05863ab86d0bdb5b3df3bf6f605e4edb0182a977c83c781cf503bf5b7"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -12344,6 +12349,11 @@
       "mode": "0000644",
       "sha256": "3c85d28ecc55e375988f3e55aee993c8c84220889678262d8207146c2772f3f5"
     },
+    {
+      "path": "tests/probe_cache.mjs",
+      "mode": "0000644",
+      "sha256": "26c734a1ab1996e1aff6197a9e0b19a448b28c772e0e75b00fee2433535c1193"
+    },
     {
       "path": "tests/profile_activity.mjs",
       "mode": "0000644",
@@ -12494,6 +12504,11 @@
       "mode": "0000644",
       "sha256": "a36acb19e59db1f9eb885ab6497a43d1c8ce0ba6198b0f5cc98f33bf08837fdf"
     },
+    {
+      "path": "tests/prose_gated_deps.mjs",
+      "mode": "0000644",
+      "sha256": "5d85d13a0cf1feb3c0aa809841126f4f9e9effe66fc57b5064b612627ce4916f"
+    },
     {
       "path": "tests/provision.mjs",
       "mode": "0000644",

package/docs/module-api-changelog.md

@@ -2116,5 +2116,9 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.819 with no explicit bump. run 35209838815. (task 1002620)
   1.19.821 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         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 35218228051. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/modules/lifecycle/dead-deps.js

@@ -198,7 +198,148 @@ function findStrandedTasks(tasks) {
   return out;
 }
 
+// ---- PROSE-DECLARED GATES (task 1003857) -----------------------------------
+//
+// Everything above reads the STRUCTURED graph — blocked_by edges. A gate written
+// in a task's DESCRIPTION is entirely unpoliced, and they go stale the same way:
+// task 1002839 (ready) names "existing open task 1001380" as a precondition, and
+// 1001380 was abandoned on 2026-08-18, superseded by ADR 0089. A builder opening
+// 1002839 is told to coordinate with a task that does not exist, and told it is open.
+//
+// ADVISORY, NEVER A GATE. A prose match is weaker evidence than an edge: the text
+// may be history ("this replaces task N"), a citation, or simply wrong. It reports
+// candidates for a human to read and must never refuse a claim — that is the
+// difference between this and DEAD_DEP_STATUSES above, and it is deliberate.
+//
+// PRECISION COMES FROM THE VERB, NOT THE ID. Matching "any abandoned id in the
+// body" is the mistake that made the sibling supersession scan unusable (idea
+// 1000807: ~44 hits, nearly all citations). So an id counts only when a GATE PHRASE
+// governs it within a short window — needs / depends on / blocked by / gated on /
+// requires / after / prereq — and the window is small enough that a paragraph
+// mentioning a gate and, separately, an id does not join them up.
+// TWO PHRASINGS, because the live evidence has both — and the second is the one the
+// filing task's own example actually uses.
+//
+//   A GATE: 'needs task N', 'blocked by N', 'depends on N'.
+//   A LIVENESS ASSERTION: 'existing OPEN task N', 'task N is ready to claim'.
+//
+// Task 1002839 — the live instance the task names — reads "and existing open task
+// 1001380 covers overlapping ground". That is not a dependency; it is a claim that
+// 1001380 is OPEN, and 1001380 was abandoned on 2026-08-18. A gate-only matcher
+// missed it, which I found by measuring rather than by reading the spec: the first
+// version returned it only because a 'needs' in the PREVIOUS clause leaked across a
+// semicolon, and tightening that correctly dropped it.
+//
+// Both shapes send a builder to a task that is not there, which is the harm. Only
+// the liveness one also states something false on its face.
+const GATE_PHRASE_RE = /\b(?:needs?|depends?\s+on|dependent\s+on|blocked\s+by|blocks?|gated\s+on|gates?|requires?|required\s+by|prereq(?:uisite)?s?|precondition|waits?\s+on|waiting\s+on|after)\b/i;
+
+// 'open task N', 'existing open task N', 'still-open task N', 'the open task N'.
+// Anchored to the id's immediate left so a paragraph that says 'open' somewhere does
+// not qualify every id in it.
+const LIVENESS_BEFORE_RE = /\b(?:still[-\s]+)?open\s+(?:task\s+)?#?$/i;
+// 'task N is ready to claim', 'task N is still open', 'task N remains open'.
+const LIVENESS_AFTER_RE = /^\s*(?:\([^)]{0,80}\)\s*)?(?:is|remains|stays)\s+(?:still\s+)?(?:open|ready\s+to\s+claim|unclaimed|in\s+flight)\b/i;
+
+// How far after a gate phrase an id still counts as governed by it. Sized to span
+// 'needs the existing open task 1001380 to land first', not a whole paragraph.
+const GATE_WINDOW = 80;
+
+// A task id in prose. Two forms, and the second is the trap.
+//
+//   LIVE form   — 6-7 digits: 'existing open task 1001380'.
+//   SHORT form  — the PRE-OFFSET ref this project used before the import, written as
+//                 `#528` or 'task 528'. Task 1000528's own gate is written that way,
+//                 and it is the case that motivated the original row — so a live-id
+//                 match misses precisely the instance this exists to find.
+//
+// The short form is only recognised with an explicit `task ` / `#` prefix. A bare
+// 3-digit number in prose is a count, a line number or a year far more often than it
+// is a task, and this runs over every description on the board.
+const ID_RE = /(?:\btask\s+|#)(\d{1,5})\b|(?:\btask\s+|#)?(\d{6,7})\b/g;
+
+// The id spaces to probe, newest first. Same precedent as diagram-facts.js: the import
+// shifted every id by 1,000,000, so a pre-offset ref resolves by adding the offset.
+const IMPORT_ID_OFFSETS = [0, 1_000_000];
+
+// PURE — every id a single textual ref could mean, most likely first. A short ref
+// yields the offset candidate too; a live-width ref is already resolved.
+function idCandidates(raw) {
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n <= 0) return [];
+  // A ref already in the LIVE width is resolved - probing an offset on it would invent
+  // a second id that is not what the text says (1001380 + 1e6 = 2001380, a row nobody
+  // wrote). The offset probe exists for the SHORT pre-offset form only.
+  if (String(n).length >= 6) return [String(n)];
+  const out = [];
+  for (const off of IMPORT_ID_OFFSETS) {
+    const cand = String(n + off);
+    // Only offer a candidate that could BE an id: the live space is 6-7 digits.
+    if (cand.length >= 6 && cand.length <= 7 && !out.includes(cand)) out.push(cand);
+  }
+  return out;
+}
+
+// Ids that share the integer space but are NOT tasks. Measured, not guessed: the
+// first run of this over the live board returned two hits and one was task 1002844's
+// 'Source: idea 1000454' — an idea citation, whose id happens to look like a task's.
+// Reporting it would have sent a human to look up a task that does not exist, which
+// is the very failure this detector exists to stop.
+const OTHER_ENTITY_RE = /\b(?:idea|blocker|report|learning|claim|builder|goal|version|PR|pull\s+request)\s+#?$/i;
+
+// PURE — the ids this text appears to declare a GATE on. Exported so the rule is
+// testable without a DB: the risk here is a matcher that quietly matches nothing (a
+// clean report) or everything (a report nobody reads).
+function proseGatedIds(text) {
+  const src = String(text || '');
+  const out = new Set();
+  for (const m of src.matchAll(ID_RE)) {
+    const rawId = m[1] || m[2];
+    const before = src.slice(Math.max(0, m.index - GATE_WINDOW), m.index);
+    // An id belonging to another entity is not a task gate, whatever governs it.
+    if (OTHER_ENTITY_RE.test(before)) continue;
+    // The window stops at a SENTENCE BOUNDARY. Also measured: the same false
+    // positive had 'needs' in the preceding sentence ('…the first thing that task
+    // needs. Source: idea 1000454'), so a fixed-width window let a verb govern across
+    // a full stop. A gate and its id belong to one sentence.
+    // A liveness assertion binds TIGHTLY to the id on either side, so it needs no
+    // window and no sentence rule.
+    const after = src.slice(m.index + m[0].length, m.index + m[0].length + 60);
+    if (LIVENESS_BEFORE_RE.test(before) || LIVENESS_AFTER_RE.test(after)) { for (const c of idCandidates(rawId)) out.add(c); continue; }
+    // A GATE may be a few words back, but the window stops at a SENTENCE BOUNDARY:
+    // measured, a fixed-width window let 'needs' govern across a full stop and a
+    // semicolon into an unrelated clause.
+    const lastStop = Math.max(before.lastIndexOf('. '), before.lastIndexOf('\n'), before.lastIndexOf('; '));
+    const governing = lastStop === -1 ? before : before.slice(lastStop + 1);
+    // Only the text BEFORE the id, so 'task 1001380 needs review' is not read as a
+    // gate ON 1001380 — the verb has to govern the id, not follow it.
+    if (GATE_PHRASE_RE.test(governing)) for (const c of idCandidates(rawId)) out.add(c);
+  }
+  return out;
+}
+
+// PURE — live tasks whose PROSE names a dead task as a gate. `tasks` are rows with
+// { id, status, description }; `statusById` answers what an id's status is.
+// Deliberately mirrors findStrandedTasks' shape so audit-deps can print one answer
+// to "what is stranded" rather than two.
+function findProseGatedTasks(tasks, statusById) {
+  const out = [];
+  for (const t of Array.isArray(tasks) ? tasks : []) {
+    if (!t || !LIVE_STATUSES.has(String(t.status))) continue;
+    const dead = [];
+    for (const id of proseGatedIds(t.description)) {
+      if (String(id) === String(t.id)) continue; // a task citing itself is not a gate
+      const st = statusById(id);
+      if (st && DEAD_DEP_STATUSES.has(String(st))) dead.push({ id: String(id), status: String(st) });
+    }
+    if (dead.length) out.push({ task_id: t.id, status: t.status, title: t.title, prose_dead_deps: dead.sort((a, b) => Number(a.id) - Number(b.id)) });
+  }
+  return out;
+}
+
 module.exports = {
   DEAD_DEP_STATUSES, LIVE_STATUSES,
   absorbedInto, depRefusalRow, splitDeadDeps, deadDepHint, findStrandedTasks,
+  proseGatedIds, findProseGatedTasks, idCandidates, GATE_PHRASE_RE, GATE_WINDOW, OTHER_ENTITY_RE,
+  LIVENESS_BEFORE_RE, LIVENESS_AFTER_RE, IMPORT_ID_OFFSETS,
 };

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.821",
+  "version": "1.19.823",
   "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/audit-deps.js

@@ -17,14 +17,15 @@
 // gate's notion of "overlap".
 //
 //   node scripts/gds/audit-deps.js [--version GDS-V3] [--min high|medium|low] [--json]
-//   node scripts/gds/audit-deps.js --stranded [--json]   # the INVERSE: dead edges (task 1003153)
+//   node scripts/gds/audit-deps.js --stranded [--json]   # the INVERSE: dead edges (task 1003153),
+//                                                      # plus prose-declared gates naming a dead task (task 1003857, advisory)
 
 const { touchesOverlap } = require('../../src/bongos/path-match.js');
 const { cliClient } = require('./cli-lib');
 const { resolveDefaultVersion } = require('./version-select.js');
 // task 1003153 — the DEAD-edge detector core, shared with the claim refusal so
 // "abandoned dependency" means one thing across the CLI, the route and this audit.
-const { findStrandedTasks } = require('../../modules/lifecycle/dead-deps.js');
+const { findStrandedTasks, findProseGatedTasks } = require('../../modules/lifecycle/dead-deps.js');
 // task 1003752 — the route's page bound + the first-page offset rule, declared once.
 const { TASK_LIST_MAX_LIMIT, buildTaskPageQuery } = require('../../modules/lifecycle/task-list-limits.js');
 
@@ -129,6 +130,16 @@ async function reportStranded({ asJson }) {
     process.exit(1);
   }
   const stranded = findStrandedTasks(all);
+  // task 1003857: the same question asked of PROSE. The structured graph above
+  // reads blocked_by edges; a gate written in a description is unpoliced, and stales
+  // identically — task 1002839 told a builder to coordinate with "existing open task
+  // 1001380", abandoned since 2026-08-18. Reported HERE rather than in a second tool
+  // so there is one answer to "what is stranded".
+  const statusById = (() => {
+    const byId = new Map(all.map((t) => [String(t.id), String(t.status)]));
+    return (id) => byId.get(String(id)) || null;
+  })();
+  const proseGated = findProseGatedTasks(all, statusById);
 
   // Context worth stating even at zero: abandoned tasks that still CARRY
   // dependents are the latent trap. They report clean only because every
@@ -139,7 +150,10 @@ async function reportStranded({ asJson }) {
   }
 
   if (asJson) {
-    console.log(JSON.stringify({ stranded, abandoned_deps_with_dependents: [...gatingAbandoned] }, null, 2));
+    console.log(JSON.stringify({ stranded, prose_gated: proseGated, abandoned_deps_with_dependents: [...gatingAbandoned] }, null, 2));
+    // ADVISORY: a prose match never changes the exit code. It is weaker evidence than
+    // an edge — the text may be history, a citation, or simply wrong — so it reports
+    // candidates for a human and must not gate a sweep or a CI leg.
     return stranded.length ? 1 : 0;
   }
   console.log(`audit-deps --stranded: ${all.length} task(s) scanned — ${stranded.length} LIVE task(s) stranded by an abandoned dependency\n`);
@@ -149,6 +163,14 @@ async function reportStranded({ asJson }) {
     console.log(`           fix: drop the edge (DELETE /dependencies {"from_kind":"task","from_id":${s.task_id},"to_kind":"task","to_id":${s.dead_deps[0].id}})`);
     console.log(`             or restore the dep (POST /tasks/${s.dead_deps[0].id}/promote)\n`);
   }
+  if (proseGated.length) {
+    console.log(`Prose-declared gates naming a dead task: ${proseGated.length} (ADVISORY — a human reads these; they never gate a claim)\n`);
+    for (const p of proseGated) {
+      console.log(`[PROSE]    #${p.task_id} [${p.status}]  ${(p.title || '').slice(0, 70)}`);
+      for (const d of p.prose_dead_deps) console.log(`           body names → #${d.id} [${d.status}]`);
+      console.log('           fix: correct the sentence (PATCH /tasks/' + p.task_id + ' {"description":…}), or promote the named task if the gate is real\n');
+    }
+  }
   if (!stranded.length) {
     console.log('Nothing stranded — no live task is gated by an abandoned dependency.');
     console.log(`Latent exposure: ${gatingAbandoned.size} abandoned task(s) still carry dependents; they read clean only`);

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

@@ -0,0 +1,139 @@
+// tests/prose_gated_deps.mjs — a gate written in a task's DESCRIPTION goes stale the
+// same way an edge does, and nothing was watching (task 1003857).
+//
+// The structured detector (task 1003153) reads blocked_by edges and never touches a
+// description. Task 1002839 sat at `ready` telling a builder to coordinate with
+// "existing open task 1001380" — abandoned since 2026-08-18, superseded by ADR 0089.
+//
+// EVERY REGEX HERE WAS SIZED BY MEASUREMENT, not by reading the spec, and the cases
+// below are the measurements. The first cut over the live board (3,647 tasks) returned
+// two hits and BOTH taught something: one was an `idea` id wearing a task-shaped
+// number, and the true positive only matched because a verb leaked across a semicolon.
+// Tightening that correctly dropped the true positive too — which is how the liveness
+// phrasing was found, because the real sentence is not a dependency at all.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { proseGatedIds, findProseGatedTasks, idCandidates, LIVE_STATUSES } = require('../modules/lifecycle/dead-deps.js');
+
+const ids = (t) => [...proseGatedIds(t)];
+
+test('the LIVE sentence from task 1002839 is caught', () => {
+  // Verbatim. This is a liveness assertion, not a dependency — "existing open task N".
+  assert.deepEqual(
+    ids('this is a gate-review HARD FLOOR surface under ADR 0043 and needs owner approval even for an Archon; and existing open task 1001380 covers overlapping ground with stale touches[]'),
+    ['1001380'],
+  );
+});
+
+test('a liveness assertion AFTER the id is caught too', () => {
+  assert.deepEqual(ids('task 1001380 (Unify the grader: one multimodal engine) is ready to claim'), ['1001380']);
+  assert.deepEqual(ids('task 1001380 remains open'), ['1001380']);
+});
+
+test('an ordinary dependency phrasing is caught', () => {
+  assert.deepEqual(ids('needs task 1001380 to land first'), ['1001380']);
+  assert.deepEqual(ids('depends on #1001380'), ['1001380']);
+  assert.deepEqual(ids('blocked by 1001380'), ['1001380']);
+});
+
+test('an ANOTHER-ENTITY id is not a task gate', () => {
+  // Measured: 'Source: idea 1000454' was one of two hits on the first live run.
+  // Reporting it sends a human to look up a task that does not exist — the exact
+  // failure this detector exists to prevent.
+  assert.deepEqual(ids('the first thing that task needs. Source: idea 1000454'), []);
+  assert.deepEqual(ids('needs idea 1000454'), []);
+  assert.deepEqual(ids('blocked by blocker 1000082'), []);
+  assert.deepEqual(ids('after PR 1000454 lands'), []);
+});
+
+test('a gate verb does NOT reach across a sentence or clause boundary', () => {
+  // Measured: a fixed-width window let 'needs' govern an id in the next clause.
+  assert.deepEqual(ids('this needs owner approval; see 1001380 for history'), []);
+  assert.deepEqual(ids('this needs approval. Background in 1001380.'), []);
+});
+
+test('history and citation are not gates', () => {
+  assert.deepEqual(ids('this supersedes task 1001380'), []);
+  assert.deepEqual(ids('task 1001380 needs review'), [], 'the verb must govern the id, not follow it');
+  assert.deepEqual(ids('open questions remain; see 1001380'), []);
+});
+
+test('a bare number that is not a task id is ignored', () => {
+  assert.deepEqual(ids('needs the 2026 rollout and 4784 commits'), []);
+});
+
+// ---- OFFSET-AWARENESS (task 1003857) ---------------------------------------
+//
+// THE TRAP THE TASK NAMES, and which I walked straight into by reading only the first
+// part of the description. Task 1000528's own gate is written as a bare PRE-OFFSET
+// short-form ref (`#513`, `task 506`), not the live id — so a live-id-only matcher
+// misses the very case that motivated the original row. The import shifted every id by
+// 1,000,000; diagram-facts.js's IMPORT_ID_OFFSETS is the existing precedent for probing
+// both spaces.
+
+test('a SHORT pre-offset ref resolves to its live id', () => {
+  assert.deepEqual(ids('needs task 528 to land first'), ['1000528']);
+  assert.deepEqual(ids('blocked by #528'), ['1000528']);
+});
+
+test('a LIVE-width ref is NOT offset a second time', () => {
+  // 1001380 + 1e6 = 2001380, a row nobody ever wrote. Probing an already-resolved id
+  // invents a second candidate that the text does not say.
+  assert.deepEqual(ids('and existing open task 1001380 covers overlapping ground'), ['1001380']);
+  assert.deepEqual(idCandidates('1001380'), ['1001380']);
+  assert.deepEqual(idCandidates('528'), ['1000528']);
+});
+
+test('a short ref needs an explicit task/# prefix — a bare small number is not an id', () => {
+  // This runs over every description on the board, where a 3-digit number is a count, a
+  // line number or a year far more often than it is a task.
+  assert.deepEqual(ids('needs 3 more reviews'), []);
+  assert.deepEqual(ids('needs 528 lines changed'), []);
+  assert.deepEqual(ids('needs task 528'), ['1000528'], 'the prefix is what makes it a ref');
+});
+
+test('the offset probe still respects the gate/liveness rules', () => {
+  assert.deepEqual(ids('this supersedes task 528'), [], 'history is not a gate, at either width');
+  assert.deepEqual(ids('needs idea 454'), [], 'another entity is not a task, at either width');
+  assert.deepEqual(ids('existing open task 528 covers this'), ['1000528'], 'liveness works at short width too');
+});
+
+test('findProseGatedTasks reports only LIVE rows gated on a DEAD one', () => {
+  const statusById = (id) => ({ 1001380: 'abandoned', 1001381: 'shipped' })[id] || null;
+  const rows = [
+    { id: '1', status: 'ready', title: 'a', description: 'needs task 1001380' },
+    { id: '2', status: 'ready', title: 'b', description: 'needs task 1001381' },  // dep alive
+    { id: '3', status: 'shipped', title: 'c', description: 'needs task 1001380' }, // row not live
+  ];
+  const out = findProseGatedTasks(rows, statusById);
+  assert.equal(out.length, 1);
+  assert.equal(out[0].task_id, '1');
+  assert.deepEqual(out[0].prose_dead_deps, [{ id: '1001380', status: 'abandoned' }]);
+});
+
+test('a task citing ITSELF is not gated on itself', () => {
+  const out = findProseGatedTasks(
+    [{ id: '1001380', status: 'ready', title: 'x', description: 'needs task 1001380' }],
+    () => 'abandoned',
+  );
+  assert.deepEqual(out, []);
+});
+
+test('an unknown id is not reported — absence of a row is not death', () => {
+  const out = findProseGatedTasks(
+    [{ id: '1', status: 'ready', title: 'x', description: 'needs task 1009999' }],
+    () => null,
+  );
+  assert.deepEqual(out, [], 'a task the caller cannot see may simply be outside the page it fetched');
+});
+
+test('LIVE_STATUSES is the shared notion, not a second copy', () => {
+  // If this detector grew its own status set, the two halves of --stranded would
+  // disagree about what "live" means and nobody would notice.
+  assert.ok(LIVE_STATUSES.has('ready') && LIVE_STATUSES.has('backlog'));
+  assert.ok(!LIVE_STATUSES.has('shipped') && !LIVE_STATUSES.has('abandoned'));
+});