@bongos/core 1.24.4 → 1.24.5

package/tests/government_laws_session.mjs

@@ -91,7 +91,8 @@ test('GET /me carries the block and resolves the settings slices through the loc
   assert.match(src, /government\.lawsForSession\(\)/, '/me reads the laws through the government port');
   assert.match(src, /settings\.describeWithLaws\(behaviorPrefs, \(sessionLaws && sessionLaws\.laws\) \|\| \[\]/, 'the slices are resolved with the laws applied');
   for (const slice of ['wandering', 'interaction', 'model_allocation']) {
-    assert.match(src, new RegExp(`${slice}: lawed \\? lawed\\.${slice} :`), `${slice} reads the locked slice`);
+    // interaction is wrapped by withStandingRules (task 1005015); the locked slice is still what it wraps.
+    assert.match(src, new RegExp(`${slice}: (?:withStandingRules\\()?lawed \\? lawed\\.${slice} :`), `${slice} reads the locked slice`);
   }
   assert.match(src, /laws: sessionLaws \? \{/, '/me answers a laws block');
   assert.equal(typeof settingsPort.describeWithLaws, 'function');

package/tests/hall_tweak_editor.mjs

@@ -328,6 +328,17 @@ try {
     assert.equal(b.el('tw-notice').hidden, true);
   });
 
+  // task 1004972: a blank round (opened, nothing written) used to read as
+  // 'unknown' and the editor told the viewer it was "submitted and on its way".
+  await test('a blank round nobody holds offers the take button, never "submitted"', async () => {
+    const read = editorRead({ held: false, state: 'ready', draftLines: null });
+    assert.equal(read.round.state, 'blank');
+    const b = bootEditor({ answers: { 'GET /copy-desk/pages/landing:index/draft': ok(read) } });
+    await b.settle();
+    assert.ok(b.el('tw-claim'), 'the notice carries the take button');
+    assert.doesNotMatch(b.el('tw-notice').innerHTML, /submitted/);
+  });
+
   await test('someone else writing it: read-only, and named', async () => {
     const b = bootEditor({ answers: { 'GET /copy-desk/pages/landing:index/draft': ok(editorRead({ holder: '8' })) } });
     await b.settle();

package/tests/host_topology_skips.mjs

@@ -30,6 +30,7 @@ const TESTS_DIR = path.dirname(fileURLToPath(import.meta.url));
 // Every test file permitted to skip itself wholesale, with the topology it needs.
 // Adding a line here is a deliberate, reviewable act — that is the point.
 const ALLOWED = {
+  agent_standing_rules: '.claude/hooks/conductor.js + stop-slopcheck.js (package-excluded)',
   allow_rule_guard: '.claude/hooks/allow-rule-guard.js (package-excluded)',
   art_stage: 'scripts/bongos/art-stage.js (art-pipeline tooling, not in the core)',
   bongos_downloads: 'config/bongos-cli.json (instance content)',
@@ -45,6 +46,7 @@ const ALLOWED = {
   preview_server: 'src/preview-server.js (game module, not in the core)',
   recall_hints: '.claude/hooks/recall-hints.js (package-excluded)',
   rubric_fixtures: 'modules/art-pipeline/template/rubric_fixtures (module not installed)',
+  run_node_reroute: '.claude/hooks/run-node.sh (package-excluded)',
   run_routine_two_root: '.claude/hooks/_core-resolve.js (package-excluded)',
   'session-cards': '.claude/hooks/session-cards.js (package-excluded)',
   session_start_freshness: '.claude/hooks/session-start.js (package-excluded)',

package/tests/run_node_reroute.mjs

@@ -0,0 +1,136 @@
+// tests/run_node_reroute.mjs — the hook resolver runs the SESSION's copy of a hook
+// (.claude/hooks/run-node.sh, task 1005015). Claude Code sets $CLAUDE_PROJECT_DIR to the
+// main checkout even in a worktree session, so every hook ran from there; on a stale main
+// checkout that hid the human-task markers (task 1004922) entirely. Each case builds fake
+// checkouts, SPAWNS the real resolver with the real settings.json argument shape, and
+// lets a probe hook report which file ran and what CLAUDE_PROJECT_DIR it saw.
+//
+// The guard hooks run through the resolver too, so the decoy cases matter as much as
+// the happy path: only a linked git worktree OF THIS PROJECT may have its copy run.
+//
+// .claude/hooks/ is package-excluded, so a clean core checkout skips this file
+// (tests/host_topology_skips.mjs carries the allowlist entry).
+//
+// Run:  node tests/run_node_reroute.mjs
+
+import { strict as assert } from 'node:assert';
+import { spawnSync } 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 { skipUnlessPresent } from './helpers.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const RESOLVER = path.join(ROOT, '.claude', 'hooks', 'run-node.sh');
+
+let passed = 0;
+let failed = 0;
+function t(name, fn) {
+  try { fn(); passed++; console.log(`  PASS  ${name}`); } catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+skipUnlessPresent(['.claude/hooks/run-node.sh']);
+
+const PROBE = "process.stdout.write(JSON.stringify({ file: __filename, pd: process.env.CLAUDE_PROJECT_DIR }))\n";
+
+// A fake Bongos checkout. `linkTo` makes it a linked worktree of that main checkout the
+// way git does: a .git FILE naming <main>/.git/worktrees/<name>, whose gitdir file points
+// back (git writes forward slashes on every platform). `backTo` forges a wrong back-pointer.
+const fwd = (p) => p.split(path.sep).join('/');
+function checkout(dir, { linkTo = null, backTo = null, core = true, probe = true } = {}) {
+  fs.mkdirSync(path.join(dir, '.claude', 'hooks'), { recursive: true });
+  fs.copyFileSync(RESOLVER, path.join(dir, '.claude', 'hooks', 'run-node.sh'));
+  if (probe) fs.writeFileSync(path.join(dir, '.claude', 'hooks', 'probe.js'), PROBE);
+  if (linkTo) {
+    const admin = path.join(linkTo, '.git', 'worktrees', path.basename(dir));
+    fs.mkdirSync(admin, { recursive: true });
+    fs.writeFileSync(path.join(admin, 'gitdir'), `${fwd(path.join(backTo || dir, '.git'))}\n`);
+    fs.writeFileSync(path.join(dir, '.git'), `gitdir: ${fwd(admin)}\n`);
+  } else {
+    fs.mkdirSync(path.join(dir, '.git'), { recursive: true });
+  }
+  if (core) fs.mkdirSync(path.join(dir, 'src', 'bongos'), { recursive: true });
+  return dir;
+}
+
+// The argument shape settings.json uses: "$CLAUDE_PROJECT_DIR/.claude/hooks/<hook>.js".
+function run({ main, cwd, env = {} }) {
+  const r = spawnSync('sh', [path.join(main, '.claude', 'hooks', 'run-node.sh'), `${main}/.claude/hooks/probe.js`], {
+    cwd,
+    env: { ...process.env, CLAUDE_PROJECT_DIR: main, OTB_NODE_BIN: process.execPath, OTB_HOOKS_FROM_PROJECT_DIR: '', ...env },
+    encoding: 'utf8',
+  });
+  if (r.error) throw r.error;
+  assert.equal(r.status, 0, `resolver exited ${r.status}: ${r.stderr}`);
+  return JSON.parse(r.stdout);
+}
+
+// Windows paths are case-insensitive, and the resolver hands node a lower-case drive.
+const canon = (p) => (process.platform === 'win32' ? fs.realpathSync.native(p).toLowerCase() : fs.realpathSync(p));
+const same = (a, b) => canon(a) === canon(b);
+
+if (spawnSync('sh', ['-c', 'exit 0']).status !== 0) {
+  console.log('SKIP run_node_reroute: no `sh` on PATH');
+  process.exit(0);
+}
+
+// realpath: on Windows os.tmpdir() can be an 8.3 short name (GMK1_P~1), which git never
+// writes and the shell's $PWD never shows, so the fixture's paths would not compare.
+const tmp = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'run-node-reroute-')));
+const main = checkout(path.join(tmp, 'main'));
+const MAIN_PROBE = path.join(main, '.claude', 'hooks', 'probe.js');
+const wt = checkout(path.join(main, '.claude', 'worktrees', 'wt'), { linkTo: main });
+fs.mkdirSync(path.join(wt, 'deep', 'er'), { recursive: true });
+const ranMain = (out) => assert.ok(same(out.file, MAIN_PROBE), `ran ${out.file}`);
+
+t('a hook fired from inside a worktree runs the worktree\'s copy, with CLAUDE_PROJECT_DIR pointed at it', () => {
+  const out = run({ main, cwd: path.join(wt, 'deep', 'er') });
+  assert.ok(same(out.file, path.join(wt, '.claude', 'hooks', 'probe.js')), `ran ${out.file}`);
+  assert.ok(same(out.pd, wt), `CLAUDE_PROJECT_DIR was ${out.pd}`);
+});
+
+t('a linked worktree outside the main folder reroutes too', () => {
+  const linked = checkout(path.join(tmp, 'linked'), { linkTo: main });
+  const out = run({ main, cwd: linked });
+  assert.ok(same(out.file, path.join(linked, '.claude', 'hooks', 'probe.js')), `ran ${out.file}`);
+});
+
+t('a hook fired from the main checkout itself runs unchanged', () => {
+  const out = run({ main, cwd: main });
+  ranMain(out);
+  assert.equal(out.pd, main);
+});
+
+t('OTB_HOOKS_FROM_PROJECT_DIR=1 turns the reroute off', () => {
+  ranMain(run({ main, cwd: wt, env: { OTB_HOOKS_FROM_PROJECT_DIR: '1' } }));
+});
+
+t('a worktree that cannot resolve the core (no src/bongos, no node_modules) keeps the main copy', () => {
+  ranMain(run({ main, cwd: checkout(path.join(tmp, 'bare'), { linkTo: main, core: false }) }));
+});
+
+t('a worktree whose branch lacks the hook keeps the main copy', () => {
+  ranMain(run({ main, cwd: checkout(path.join(tmp, 'old'), { linkTo: main, probe: false }) }));
+});
+
+t('a folder outside any checkout keeps the main copy', () => {
+  ranMain(run({ main, cwd: fs.mkdtempSync(path.join(os.tmpdir(), 'run-node-loose-')) }));
+});
+
+t('a look-alike with a .git dir and its own hooks (not a worktree) keeps the main copy', () => {
+  ranMain(run({ main, cwd: checkout(path.join(tmp, 'decoy')) }));
+});
+
+t('a decoy whose .git file names a gitdir outside the project keeps the main copy', () => {
+  const other = checkout(path.join(tmp, 'other-main'));
+  ranMain(run({ main, cwd: checkout(path.join(tmp, 'decoy2'), { linkTo: other }) }));
+});
+
+t('a decoy pointing into the project whose back-pointer names another folder keeps the main copy', () => {
+  ranMain(run({ main, cwd: checkout(path.join(tmp, 'decoy3'), { linkTo: main, backTo: wt }) }));
+});
+
+fs.rmSync(tmp, { recursive: true, force: true });
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exitCode = failed ? 1 : 0;