@bongos/core 1.24.75 → 1.24.77

package/scripts/bongos/autobongos-run.js

@@ -265,6 +265,10 @@ const WORKER_ENV_ALLOW = [
   // missing here would be set on the host and silently absent in the worker.
   ...claudeBinEnvNames(),
   'XDG_CONFIG_HOME',
+  // The runner's own config root (task 1005095): its login, heartbeat and run log
+  // sit apart from the builder's own CLI session on the same device, and a worker
+  // that did not inherit this would claim and ship as the wrong session.
+  'BONGOS_CONFIG_ROOT',
   // THE WORKER'S OWN CREDENTIAL, and it has to be here (task 1003907, found by
   // running it). On a desktop, the claude CLI authenticates from the credential
   // store under USERPROFILE/HOME, which are already allowed - so this list looked
@@ -545,7 +549,9 @@ function queueGatedRow(queueGate, now) {
 async function iteration(opts, deps = {}) {
   const runCmd = deps.run || run;
   const spawnWork = deps.spawnWorker || spawnWorker;
-  const readGauge = deps.gauge || (() => gauge.evaluate());
+  // absentMeansGo: a device with no gauge file at all works until the usage limit
+  // stops it (task 1005095) — see decideCapacity in modules/autonomy/gauge.js.
+  const readGauge = deps.gauge || (() => gauge.evaluate(undefined, { absentMeansGo: true }));
   const pick = deps.pickTask || pickTask;
   const log = deps.record || record;
 

package/scripts/bongos/autonomy-gauge.js

@@ -26,9 +26,14 @@ function gaugePath() {
   catch (_) { return null; }
 }
 
+// null means there is NO file. A file that exists but cannot be read or parsed
+// comes back as the string 'unreadable', which the decision treats as a bad
+// reading (unknown) and never as "this device has no gauge" (task 1005095).
 function loadGauge(p) {
   if (!p) return null;
-  try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch (_) { return null; }
+  let text;
+  try { text = fs.readFileSync(p, 'utf8'); } catch (e) { return e && e.code === 'ENOENT' ? null : 'unreadable'; }
+  try { return JSON.parse(text); } catch (_) { return 'unreadable'; }
 }
 
 function readConfig() {
@@ -47,9 +52,12 @@ function readConfig() {
   return c;
 }
 
-function evaluate(nowEpochS = Math.floor(Date.now() / 1000)) {
+// `overrides` is merged over the env config. The supervisor passes
+// { absentMeansGo: true } (task 1005095); this CLI passes nothing, so a missing
+// file is still UNKNOWN here.
+function evaluate(nowEpochS = Math.floor(Date.now() / 1000), overrides = {}) {
   const p = gaugePath();
-  return { path: p, decision: decideCapacity({ gauge: loadGauge(p), now: nowEpochS, config: readConfig() }) };
+  return { path: p, decision: decideCapacity({ gauge: loadGauge(p), now: nowEpochS, config: { ...readConfig(), ...overrides } }) };
 }
 
 async function main(argv) {

package/scripts/bongos/blocker-recheck.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// scripts/bongos/blocker-recheck.js — what has shipped since a blocker was filed that may
+// already answer it (task 1005120).
+//
+// WHY. A blocker is a claim about the world, made on a date, by a session that has long
+// since ended. One project's blocker asked its owner to "apply to Plaid for Chase and Bank of
+// America OAuth" for days after the project's own shipped work had found there was nothing
+// to apply for — nothing ever re-read it, and it had no linked tasks, so no promotion would
+// ever surface it. /blocker-review runs this before putting a blocker to a person again: it
+// lists the shipped work since the filing that shares the blocker's subject, so the session
+// reads that first and offers to close the blocker when the answer is already in.
+//
+// IT SUGGESTS, IT NEVER DECIDES. A word overlap is a reason to read a task, not proof the
+// blocker is answered; closing one is still a person's verdict in the review. So the match is
+// deliberately simple and explainable (shared subject words, each shown), never a score a
+// reader has to trust.
+//
+// usage: node scripts/bongos/blocker-recheck.js <blocker-id> [--json]
+
+'use strict';
+
+// Words that say nothing about a blocker's SUBJECT. Short words are dropped by length.
+const STOP = new Set([
+  'about', 'after', 'again', 'already', 'also', 'apply', 'because', 'before', 'being', 'blocker',
+  'cannot', 'could', 'does', 'done', 'each', 'from', 'have', 'into', 'just', 'make', 'more', 'must',
+  'need', 'needs', 'only', 'other', 'owner', 'should', 'some', 'still', 'than', 'that', 'their',
+  'them', 'then', 'there', 'these', 'they', 'this', 'those', 'through', 'until', 'very', 'want',
+  'were', 'what', 'when', 'where', 'which', 'while', 'will', 'with', 'without', 'would', 'your',
+  'task', 'tasks', 'work', 'page', 'pages', 'project',
+  // Words nearly every shipped summary in this ledger carries, so they say nothing about a
+  // blocker's subject (measured against a live blocker: these alone matched ten tasks).
+  'back', 'both', 'check', 'checks', 'core', 'main', 'once', 'open', 'itself', 'shipped', 'test',
+  'tests', 'version', 'versions', 'instance', 'server', 'update', 'copy', 'first', 'every', 'now',
+]);
+
+/** The subject words of a text: lower-cased, 4+ letters, not a stop word. */
+function subjectWords(text) {
+  const out = new Set();
+  for (const w of String(text || '').toLowerCase().match(/[a-z][a-z0-9]{3,}/g) || []) {
+    if (!STOP.has(w)) out.add(w);
+  }
+  return out;
+}
+
+/**
+ * Shipped tasks AFTER the blocker was filed that share at least `minShared` subject words
+ * with its title + body, most shared first, then newest. PURE.
+ * Each result: { id, short_name, title, shipped_at, value_summary, shared: [words] }.
+ */
+function relatedShipped(blocker, tasks, { minShared = 2, max = 10 } = {}) {
+  const filed = Date.parse(blocker && blocker.created_at);
+  if (!Number.isFinite(filed)) return [];
+  // The TITLE names the subject; a long body mostly carries generic words that match
+  // everything. The body is used only when the title alone is too thin to match on.
+  let want = subjectWords(blocker.title);
+  if (want.size < minShared) want = subjectWords(`${blocker.title || ''} ${blocker.body_md || ''}`);
+  const hits = [];
+  for (const t of Array.isArray(tasks) ? tasks : []) {
+    if (!t || t.status !== 'shipped') continue;
+    const at = Date.parse(t.shipped_at);
+    if (!Number.isFinite(at) || at <= filed) continue;
+    const have = subjectWords(`${t.title || ''} ${t.value_summary || ''}`);
+    const shared = [...want].filter((w) => have.has(w)).sort();
+    if (shared.length >= minShared) {
+      hits.push({ id: t.id, short_name: t.short_name || null, title: t.title, shipped_at: t.shipped_at, value_summary: t.value_summary || null, shared });
+    }
+  }
+  hits.sort((a, b) => (b.shared.length - a.shared.length) || (Date.parse(b.shipped_at) - Date.parse(a.shipped_at)));
+  return hits.slice(0, max);
+}
+
+/** The lines /blocker-review reads. Never "nothing is related" as proof the blocker holds. */
+function reportLines(blocker, hits) {
+  const head = `Blocker ${blocker.id} - "${blocker.title}" (filed ${String(blocker.created_at).slice(0, 10)})`;
+  if (!hits.length) {
+    return [head, '  No shipped work since it was filed shares its subject. That is not proof it still holds: re-run the check it names, if any.'];
+  }
+  return [head, `  ${hits.length} shipped since it was filed may answer it — read these before asking again:`,
+    ...hits.map((h) => `  - task ${h.id}${h.short_name ? ` - ${h.short_name}` : ''} (shipped ${String(h.shipped_at).slice(0, 10)}; shares: ${h.shared.join(', ')})${h.value_summary ? `\n      ${h.value_summary}` : ''}`)];
+}
+
+async function main(argv) {
+  const id = Number(argv[0]);
+  if (!Number.isInteger(id) || id <= 0) {
+    console.error('usage: node scripts/bongos/blocker-recheck.js <blocker-id> [--json]');
+    return 2;
+  }
+  const { cliClient } = require('./cli-lib');
+  const api = await cliClient();
+  const b = await api.request('GET', `/blockers/${id}`);
+  if (!b.ok || !b.data || !b.data.blocker) {
+    console.error(`blocker ${id}: could not be read (${b.status})`);
+    return 1;
+  }
+  const t = await api.request('GET', '/tasks?status=shipped&limit=1000');
+  if (!t.ok) {
+    console.error(`shipped tasks could not be read (${t.status}), so nothing was re-checked`);
+    return 1;
+  }
+  const tasks = Array.isArray(t.data) ? t.data : (t.data && t.data.tasks) || [];
+  const hits = relatedShipped(b.data.blocker, tasks);
+  if (argv.includes('--json')) console.log(JSON.stringify({ blocker_id: id, related: hits }, null, 2));
+  else console.log(reportLines(b.data.blocker, hits).join('\n'));
+  return 0;
+}
+
+module.exports = { subjectWords, relatedShipped, reportLines };
+
+if (require.main === module) {
+  main(process.argv.slice(2)).then((code) => { process.exitCode = code; }, (e) => { console.error(e.message); process.exitCode = 1; });
+}

package/scripts/bongos/cli-lib.js

@@ -333,7 +333,11 @@ function sessionStoreDir() {
   // Directory name deliberately NOT 'sessions': that is a live module key, and ADR 0083
   // §Decision #4 forbids naming one in shared machinery. 'instances' is the truer name anyway —
   // one file per instance is exactly what this holds.
-  return path.join(os.homedir(), '.config', ic.FALLBACK_DIR, 'instances');
+  // Under the config ROOT, which is ~/.config unless BONGOS_CONFIG_ROOT moves it
+  // (task 1005095) — so an Autobongos runner's login is never filed into, or read
+  // out of, the builder's own store. The root is not the brand: the anchor is
+  // still the same fixed dir name for every checkout that shares a root.
+  return path.join(ic.configRoot(), ic.FALLBACK_DIR, 'instances');
 }
 
 // The store's filename for an instance, derived from its api_base host. Returns null when the base

package/scripts/bongos/government-walk.js

@@ -1267,7 +1267,7 @@ async function walkNewMachinery({ call, code, vote, voteAll, check, section, sta
   });
   let matter = null;
   await check('With an ask, the AI session\'s blocker is filed and carries its card', '201; the blocker reads back with its question', async () => {
-    const r = await call(CY, 'POST', '/blockers', { title: 'Walk needs a decision', ask: GOOD_ASK }, 'cli');
+    const r = await call(CY, 'POST', '/blockers', { title: 'Walk needs a decision', ask: GOOD_ASK, checked: 'Ran the walk against the stub server and read its refusal for this exact card.' }, 'cli');
     const id = r.json && r.json.blocker && r.json.blocker.id;
     matter = id ? `blockers:${id}` : null;
     const back = await call(CY, 'GET', `/blockers/${id}`);

package/scripts/gds/autobongos-bootstrap.ps1

@@ -0,0 +1,8 @@
+# scripts/gds/autobongos-bootstrap.ps1 -- @bongos-forwarder (task 1004848). Generated by
+# scripts/bongos/codemod-rename-scripts-gds.js; do not edit.
+# The real script is scripts/bongos/autobongos-bootstrap.ps1. This forwarder keeps callers that still name
+# the old path working, and warns once so they get repointed. Task 1003706 removes it.
+if (-not $env:BONGOS_FORWARDER_WARNED) { Write-Warning '[bongos] scripts/gds/autobongos-bootstrap.ps1 has moved to scripts/bongos/autobongos-bootstrap.ps1. This old path still works for now, but update whatever called it. The forwarders in scripts/gds/ are removed in a later release.' }
+$env:BONGOS_FORWARDER_WARNED = '1'
+& (Join-Path $PSScriptRoot '..\bongos\autobongos-bootstrap.ps1') @args
+exit $LASTEXITCODE

package/scripts/gds/autobongos-bootstrap.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+# scripts/gds/autobongos-bootstrap.sh — @bongos-forwarder (task 1004848). Generated by
+# scripts/bongos/codemod-rename-scripts-gds.js; do not edit.
+# The real script is scripts/bongos/autobongos-bootstrap.sh. This forwarder keeps callers that still name
+# the old path working, and warns once so they get repointed. Task 1003706 removes it.
+if [ -z "${BONGOS_FORWARDER_WARNED:-}" ]; then echo "[bongos] scripts/gds/autobongos-bootstrap.sh has moved to scripts/bongos/autobongos-bootstrap.sh. This old path still works for now, but update whatever called it. The forwarders in scripts/gds/ are removed in a later release." >&2; fi
+export BONGOS_FORWARDER_WARNED=1
+exec bash "$(dirname "$0")/../bongos/autobongos-bootstrap.sh" "$@"

package/scripts/gds/autobongos-host.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// scripts/gds/autobongos-host.js — @bongos-forwarder (task 1004848). Generated by
+// scripts/bongos/codemod-rename-scripts-gds.js; do not edit.
+// The real script is scripts/bongos/autobongos-host.js. This forwarder keeps callers that still name
+// the old path working, and warns once so they get repointed. Task 1003706 removes it.
+'use strict';
+require('../bongos/forwarder.js').forward(module, 'autobongos-host.js');

package/scripts/gds/blocker-recheck.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// scripts/gds/blocker-recheck.js — @bongos-forwarder (task 1004848). Generated by
+// scripts/bongos/codemod-rename-scripts-gds.js; do not edit.
+// The real script is scripts/bongos/blocker-recheck.js. This forwarder keeps callers that still name
+// the old path working, and warns once so they get repointed. Task 1003706 removes it.
+'use strict';
+require('../bongos/forwarder.js').forward(module, 'blocker-recheck.js');

package/scripts/hall-preview/server.js

@@ -182,6 +182,7 @@ const FIXTURE_FALLBACKS = [
 // and changes nothing: the harness has no state to change, and the page reads
 // the same fixtures again on reload. Anything absent is still refused.
 const CANNED_WRITES = [
+  ['POST', /^inbox$/, 'inbox.post'],
   ['PUT', /^copy-desk\/pages\/[a-z0-9-]+:[a-z0-9-]+\/draft$/, 'copy-desk__pages__draft.put'],
   ['POST', /^copy-desk\/pages\/[a-z0-9-]+:[a-z0-9-]+\/submit$/, 'copy-desk__pages__submit.post'],
   ['POST', /^copy-desk\/pages\/[a-z0-9-]+:[a-z0-9-]+\/claim$/, 'copy-desk__pages__claim.post'],

package/src/instance-config.js

@@ -112,17 +112,35 @@ function resolveApiBase({ session, env = process.env, b = safeBrand() } = {}) {
   return fromSession || defaultApiBase(b);
 }
 
+// The folder every config dir lives under: ~/.config, unless BONGOS_CONFIG_ROOT
+// names another one (task 1005095).
+//
+// WHY AN OVERRIDE. An Autobongos runner on a builder's own laptop holds a login
+// of its own (src/bongos/runner-login.js), and it must not share a session file
+// with the builder's CLI: one slot means adding the laptop as a runner signs the
+// builder's own tools out, and removing the runner signs them out again. The
+// runner's device program (scripts/bongos/autobongos-host.js) sets this for the
+// supervisor and every worker it starts, so their session, heartbeat and run log
+// sit apart — and with a root of its own the LEGACY dirs below are not found
+// either, so the runner can never fall back to the builder's own session.
+// One fixed name, read directly: the branded-prefix lookup needs the brand, and
+// this decides where the brand's own dir goes.
+function configRoot(env = process.env) {
+  const over = typeof env.BONGOS_CONFIG_ROOT === 'string' ? env.BONGOS_CONFIG_ROOT.trim() : '';
+  return over ? path.resolve(over) : path.join(os.homedir(), '.config');
+}
+
 // Absolute path to the instance config dir — the WRITE target and first read.
 function configHome(b = safeBrand()) {
-  return path.join(os.homedir(), '.config', configDirName(b));
+  return path.join(configRoot(), configDirName(b));
 }
 
 // All config dirs to try on READ, configured first then legacy, de-duped.
 function configReadDirs(b = safeBrand()) {
-  const home = os.homedir();
+  const root = configRoot();
   const dirs = [configHome(b)];
   for (const d of LEGACY_DIRS) {
-    const p = path.join(home, '.config', d);
+    const p = path.join(root, d);
     if (!dirs.includes(p)) dirs.push(p);
   }
   return dirs;
@@ -367,6 +385,7 @@ module.exports = {
   envPrefix,
   defaultApiBase,
   resolveApiBase,
+  configRoot,
   configHome,
   configReadDirs,
   configPath,

package/src/module-api.js

@@ -81,7 +81,7 @@ const { sleep } = require('./sleep');
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.24.75'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.24.77'; // 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('discord'); log.info('mounted');