@bongos/core 1.24.25 → 1.24.27

package/scripts/hall-preview/README.md

@@ -22,6 +22,7 @@ node scripts/hall-preview/server.js                 # neutral pack, port 4600
 | `--modules-off discord,provisioning` | report those modules disabled in `window.__MODULES__` — verifies `moduleOn()` gating (the Discord links, Instances/Start-a-project widgets must vanish) |
 | `--empty` | drain every array in every fixture — the empty-state screenshot pass |
 | `--fixture-me` | don't read your own account live — serve the checked-in `me.json` snapshot (see below) |
+| `--latency 3000` | hold every data read that many ms before answering, so a page's loading state (the hall's `.hall-loading` mark) stays on screen long enough to look at |
 
 Writes are not wired: any `POST/PATCH/DELETE` answers `501 preview_readonly` — except
 the canned writes in `server.js` and, since task 1004685, the five per-builder pref

package/scripts/hall-preview/server.js

@@ -65,6 +65,10 @@ const MODULES_ON = String(arg('--modules-on') || '').split(',').map((s) => s.tri
 // own account live. The screenshot matrix in the README wants a stable subject,
 // and it is the explicit way to preview the signed-out fallback (task 1003315).
 const FIXTURE_ME = process.argv.includes('--fixture-me');
+// --latency: hold every data read this many ms before answering (task 1005043),
+// so a page's loading state stays on screen long enough to be looked at. The
+// fixtures answer in a millisecond, which is why no loader had ever been seen.
+const LATENCY = Math.max(0, Number(arg('--latency')) || 0);
 const BRAND_FILE = arg('--brand') || 'config/branding.neutral.json';
 process.env.BONGOS_BRANDING_FILE = path.resolve(ROOT, BRAND_FILE);
 
@@ -295,6 +299,11 @@ function fixtureFor(apiPath, query = {}) {
 // ---- app ----------------------------------------------------------------------
 const app = express();
 
+// --latency (above): the live channel is left alone, it is a stream, not a read.
+if (LATENCY) {
+  app.use((req, res, next) => (/^\/api\//.test(req.path) && !/\/live\/?$/.test(req.path) ? setTimeout(next, LATENCY) : next()));
+}
+
 // The API stub — intercepts every /api/gds/*, /api/bongos/*, /api/bongos/v1/*
 // request BEFORE mountInternalSurfaces can reach the real routes (which would
 // touch Postgres — the harness is DB-less by design). A plain function

package/src/bongos/apex-hall-redirects.js

@@ -0,0 +1,53 @@
+'use strict';
+
+// src/bongos/apex-hall-redirects.js — the apex hands the hall's addresses to the hall's own
+// host: /builders/* (the ADR 0036 cutover) and /deploy, the deploy door every hosted
+// project's Update button names (task 1004736).
+//
+// Moved out of serve-internal.js, which sits at the 1500-line size ratchet, and mounted from
+// it at the same point in the chain. `skip(req)` is true for a module surface host and for
+// the hall's own host (on a single-host instance that is every request), so both answer only
+// on the apex. `hostOf(req)` is the request's host, lower-cased, without a port.
+
+// #739 (ADR 0036 cutover): the builder surface's canonical home is the subdomain. On the
+// apex, /builders and /builders/* go to builders.<apex>/<rest> so old links keep working.
+// 301 (permanent) — the cutover is proven live (#741; started as a 302 in #739). The URL
+// fragment (#/task/N deep-links) is preserved by the browser across the redirect; the query
+// string is carried explicitly. The target apex comes from the request host, so it stays
+// brand-agnostic.
+function buildersRedirect({ skip, hostOf }) {
+  return (req, res, next) => {
+    if (skip(req)) return next();
+    if (req.path !== '/builders' && !req.path.startsWith('/builders/')) return next();
+    const rest = req.path.replace(/^\/builders\/?/, '');            // '/builders'→'', '/builders/watch'→'watch'
+    const qs = req.url.includes('?') ? req.url.slice(req.url.indexOf('?')) : '';
+    return res.redirect(301, `https://builders.${hostOf(req)}/${rest}${qs}`);
+  };
+}
+
+// THE DEPLOY DOOR ON THE APEX (task 1004736). A hosted project's Update button is
+// `<hub origin>/deploy?project=<slug>` (routes/core-update.js hubDeployUrl, and the
+// HUB_UPGRADE_URL provisioning writes), and the hub origin is its apex, where nothing served
+// /deploy: every hosted owner who pressed Update met a 404. The page is the hall's, so the
+// apex hands the request over, query and all, and the hall decides (its page gate, or
+// Settings where no door runs). Answered here rather than by rewriting the links, because
+// those already sit in every project's web.env and core and would wait for each project's
+// core to move. 302: the apex may serve its own /deploy one day.
+const APEX_DEPLOY_RE = /^\/deploy(?:\.html)?\/?$/;
+function deployRedirect({ skip, hostOf }) {
+  return (req, res, next) => {
+    if (skip(req)) return next();
+    if (req.method !== 'GET' && req.method !== 'HEAD') return next();
+    if (!APEX_DEPLOY_RE.test(req.path)) return next();
+    const qs = req.url.includes('?') ? req.url.slice(req.url.indexOf('?')) : '';
+    return res.redirect(302, `https://builders.${hostOf(req)}/deploy${qs}`);
+  };
+}
+
+/** Mount both on `app`, in order, at the caller's point in the chain. */
+function mountApexHallRedirects(app, { skip, hostOf }) {
+  app.use(buildersRedirect({ skip, hostOf }));
+  app.use(deployRedirect({ skip, hostOf }));
+}
+
+module.exports = { mountApexHallRedirects };

package/src/bongos/serve-internal.js

@@ -34,6 +34,7 @@ const fs = require('fs');
 const express = require('express');
 
 const { buildGdsRouter } = require('./routes');
+const { mountApexHallRedirects } = require('./apex-hall-redirects');
 const { attachFail } = require('./middleware/error-envelope');
 const metrics = require('./metrics');
 const { logger } = require('./logger');
@@ -923,24 +924,8 @@ function mountInternalSurfaces(app) {
     next();
   });
 
-  // #739 (ADR 0036 cutover): the builder surface's canonical home is now the
-  // subdomain. On the apex/game host, redirect /builders and /builders/* to
-  // builders.<apex>/<rest> so old links keep working while the subdomain becomes
-  // the front door. Runs ONLY on the apex (skipped on the status + builders
-  // hosts; /api is host-agnostic and mounted earlier, and never starts /builders).
-  // 301 (permanent) — the cutover is proven live + verified end-to-end (#741;
-  // started as a 302 in #739). The URL fragment (#/task/N deep-links) is preserved
-  // by the browser across the redirect; the query string is carried explicitly.
-  // The redirect target apex is read from the request host (strip a leading
-  // "builders."/"status." if present) so it stays brand-agnostic.
-  app.use((req, res, next) => {
-    if (isModuleSurfaceHost(req) || isBuildersHost(req)) return next();
-    if (req.path !== '/builders' && !req.path.startsWith('/builders/')) return next();
-    const apex = siteOf(req).host;
-    const rest = req.path.replace(/^\/builders\/?/, '');            // '/builders'→'', '/builders/watch'→'watch'
-    const qs = req.url.includes('?') ? req.url.slice(req.url.indexOf('?')) : '';
-    return res.redirect(301, `https://builders.${apex}/${rest}${qs}`);
-  });
+  // The apex hands /builders/* (ADR 0036) and /deploy (task 1004736) to the hall's own host.
+  mountApexHallRedirects(app, { skip: (req) => isModuleSurfaceHost(req) || isBuildersHost(req), hostOf: (req) => siteOf(req).host });
 
   // The /watch monitoring page and the /gate page (task 1179) both sit behind
   // `page.view.government` — Metic and up since ADR 0157. Same server-side page

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

package/tests/autobongos_host_access.mjs

@@ -48,9 +48,11 @@ const T1003980 = {
 };
 const CODE_TASK = {
   id: 9002, goal_id: 1000119, kind: 'feature', status: 'ready', requires_rank: 'xenos',
-  touches: ['scripts/bongos/sequence.js'], manual_degree: null, automation_tag: null,
-  title: 'Teach the picker a new halt reason',
-  description: 'Add a halt reason to scripts/bongos/sequence.js and cover it with a tests/*.mjs case. '.repeat(4)
+  // Not the picker itself: since task 1004546 sequence.js is on the runner's own
+  // list, so a task editing it is passed over as self_modification.
+  touches: ['modules/hall-ui/public/goals.js'], manual_degree: null, automation_tag: null,
+  title: 'Show a new column on the goals page',
+  description: 'Add a column to modules/hall-ui/public/goals.js and cover it with a tests/*.mjs case. '.repeat(4)
     + 'DONE WHEN: the new case passes and the old ones still do.',
 };
 

package/tests/autobongos_self_modification.mjs

@@ -0,0 +1,420 @@
+// tests/autobongos_self_modification.mjs — an Autobongos runner never changes its
+// own supervisor, safety checks or kill switch (task 1004546, carrying task
+// 1004540's work; ADR 0307 §6).
+//
+// The done-when, case by case:
+//   1. a task DECLARING modules/autonomy/fence.js is refused before the claim
+//      (the picker skips it, and decideTask refuses it if it is handed one);
+//   2. an UNDECLARED edit to an autobongos-* file in the real diff is caught, by
+//      ship.js inside the worker and by the server at publish, which reads the
+//      pull request's own files and closes it;
+// plus the three findings that failed task 1004540's second grade:
+//   - the guard's own implementation is on the list it enforces, and the server
+//     guard requires its matcher directly rather than through the module doorway;
+//   - the wiring in the publish route is held by driving the REAL route here, so
+//     deleting that line turns this file red (and this file is on the list);
+//   - the runner-worktree shape is written once.
+// No DB, no network: fake pools, the real router, stubbed GitHub reads.
+//
+// Run:  node tests/autobongos_self_modification.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import http from 'node:http';
+import { fileURLToPath } from 'node:url';
+import { makeRunner } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(fileURLToPath(new URL('..', import.meta.url)));
+const { test, summary } = makeRunner();
+const read = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8');
+
+const runnerSelf = require('../modules/lifecycle/runner-self.js');
+const guard = require('../modules/lifecycle/runner-self-guard.js');
+const fence = require('../modules/autonomy/fence.js');
+const runner = require('../scripts/bongos/autobongos-run.js');
+const pcheck = require('../src/bongos/permission-path-check.js');
+
+const onList = (f) => runnerSelf.matchRunnerSelf([f]).length === 1;
+
+// ---- the list ---------------------------------------------------------------
+
+await test('every file that implements the self-edit checks is on the list it enforces', () => {
+  const implementation = [
+    'modules/lifecycle/runner-self.js', // the list
+    'modules/lifecycle/runner-self-guard.js', // the server refusal
+    'modules/autonomy/fence.js', // decideTask
+    'scripts/bongos/autobongos-run.js', // the picker skip + the worker env
+    'scripts/bongos/ship-flow.js', // the ship-time check
+    'scripts/bongos/ship.js',
+    'tests/autobongos_self_modification.mjs', // this file, which holds the route wiring
+  ];
+  for (const f of implementation) assert.ok(onList(f), `${f} must be on the runner's own list`);
+});
+
+await test('everything the server guard requires is on the list too, and the runner-list matcher is never the doorway\'s', () => {
+  const src = read('modules/lifecycle/runner-self-guard.js');
+  const required = [...src.matchAll(/require\('(\.\/[^']+)'\)/g)].map((m) => m[1]);
+  assert.ok(required.includes('./runner-self'), 'the runner-list matcher is required directly, as a sibling');
+  for (const rel of required) {
+    const file = `modules/lifecycle/${rel.replace(/^\.\//, '')}.js`;
+    assert.ok(onList(file), `${file} decides what the guard sees, so a runner may not change it`);
+  }
+  // The registry matcher can only come through the doorway; it is verified before use.
+  assert.match(src, /verifiedMatcher\(deps\.matchProtected \|\| \(\(files\) => api\.permissionPathCheck\.matchProtected\(files\)\)\)/);
+  assert.doesNotMatch(src, /api\.pathMatch/);
+  // And the list itself requires nothing at all.
+  assert.doesNotMatch(read('modules/lifecycle/runner-self.js'), /require\(/);
+});
+
+await test('the route line that calls the server guard is itself a protected file', () => {
+  // The owner kept tasks.js off the runner's own list; the registry covers it, and
+  // the real-diff checks read the registry, so a runner cannot publish its removal.
+  assert.equal(pcheck.matchProtected(['modules/lifecycle/routes/tasks.js']).length, 1);
+  assert.equal(runnerSelf.diffRefusal({ files: ['modules/lifecycle/routes/tasks.js'], protectedHits: pcheck.matchProtected(['modules/lifecycle/routes/tasks.js']) }).code, 'runner_protected_path');
+});
+
+await test('the kill switch, the gauge, the grader and the registry are on the list', () => {
+  for (const f of [
+    'modules/autonomy/routes/autonomy.js', 'modules/autonomy/gauge.js', 'modules/autonomy/cadence.js',
+    'modules/government/catalog.js', 'modules/government/protected-surfaces.json', 'src/bongos/permission-path-check.js',
+    'modules/grading/grader.js', 'scripts/bongos/autobongos-loop.js', 'scripts/bongos/autobongos-verify.js',
+    'scripts/bongos/autobongos-grade-cap.js', 'scripts/gds/autobongos-run.js', 'scripts/bongos/autonomy-gauge.js',
+    'scripts/bongos/sequence.js', 'modules/lifecycle/autopickup-files.js',
+  ]) assert.ok(onList(f), f);
+});
+
+await test('the module doorway is on the list: the server guard reaches its matcher and pool through it', () => {
+  // Owner ruling 2026-11-03 (grade round 2 of this task): a runner that could rewrite
+  // the doorway could swap what the server guard checks with.
+  assert.ok(onList('src/module-api.js'));
+  assert.match(read('modules/lifecycle/runner-self-guard.js'), /require\('\.\.\/\.\.\/src\/module-api'\)/, 'the guard does reach it, so it must stay listed');
+});
+
+await test('the tweak lane asks the runner-list question too', () => {
+  const lane = require('../scripts/bongos/autobongos-tweak-lane.js');
+  const d = lane.decideRound({ task: { id: 7, goal_id: 1, updated_at: 'x' }, claims: [], files: ['modules/autonomy/fence.js'], matchProtected: () => [] });
+  assert.equal(d.code, 'self_modification');
+});
+
+await test('ordinary work is not on the list (the owner ruled tasks.js out)', () => {
+  for (const f of [
+    'modules/lifecycle/routes/tasks.js', 'modules/hall-ui/public/settings.js',
+    'scripts/bongos/claim.js', 'docs/recipes/autobongos-windows-host.md', 'modules/lifecycle/db-claims.js',
+    'scripts/bongos/autobongos-lib/nested.js', // a '*' pattern stays inside its directory
+  ]) assert.ok(!onList(f), f);
+});
+
+await test('every entry on the list says why it is there, and none is listed twice', () => {
+  const patterns = runnerSelf.RUNNER_SELF_SURFACES.map((s) => s.pattern);
+  assert.equal(new Set(patterns).size, patterns.length);
+  for (const s of runnerSelf.RUNNER_SELF_SURFACES) {
+    assert.ok(typeof s.why === 'string' && s.why.length > 5, `${s.pattern} carries a reason`);
+    assert.match(s.pattern, /^[a-z0-9_./-]+(\/|\*)?$/, `${s.pattern} is an exact path, a 'dir/' or a 'prefix*'`);
+  }
+  assert.ok(Object.isFrozen(runnerSelf.RUNNER_SELF_SURFACES), 'nothing at run time can shorten it');
+});
+
+await test('a declared touch cannot slip past on its spelling', () => {
+  for (const f of ['scripts\\bongos\\autobongos-run.js', './modules/autonomy/fence.js', 'Modules/Autonomy/Fence.js', '/modules/autonomy/fence.js']) {
+    assert.ok(onList(f), f);
+  }
+  assert.deepEqual(runnerSelf.matchRunnerSelf(['', null, 42]), []);
+});
+
+await test('both guard files are on the ADR 0043 registry, at the pipeline floor', () => {
+  const hits = pcheck.matchProtected(['modules/lifecycle/runner-self.js', 'modules/lifecycle/runner-self-guard.js']);
+  assert.equal(hits.length, 2);
+  for (const h of hits) assert.equal(h.permission, 'path.protected.modify');
+});
+
+// ---- one shape for a runner's claim -----------------------------------------
+
+await test('the runner-worktree shape is written once, and the runner uses that one', () => {
+  assert.equal(runner.RUNNER_TREE_RE, runnerSelf.RUNNER_TREE_RE, 'the supervisor re-exports the shared regex');
+  assert.equal(runner.isRunnerTree, runnerSelf.isRunnerTree);
+  for (const id of [1, 4242, 1004546]) assert.ok(runnerSelf.isRunnerTree(runner.worktreeName(id)), `worktreeName(${id})`);
+  assert.equal(runnerSelf.isRunnerTree('autobongos-resume-1003904-d29f25'), false, "a person's readable name is not the runner's");
+  // No other file spells the shape: a second copy is how two checks drift apart.
+  const spelling = String.raw`autobongos-\d+-[0-9a-f]{6}`;
+  const copies = [];
+  for (const dir of ['modules', 'scripts', 'src']) {
+    const walk = (d) => {
+      for (const e of fs.readdirSync(path.join(ROOT, d), { withFileTypes: true })) {
+        const rel = `${d}/${e.name}`;
+        if (e.isDirectory()) { if (e.name !== 'node_modules') walk(rel); continue; }
+        if (/\.js$/.test(e.name) && read(rel).includes(spelling)) copies.push(rel);
+      }
+    };
+    walk(dir);
+  }
+  assert.deepEqual(copies, ['modules/lifecycle/runner-self.js']);
+});
+
+// ---- 1. declared: refused before the claim ----------------------------------
+
+await test('decideTask refuses a task declaring modules/autonomy/fence.js, and names it', () => {
+  const task = { id: 7, goal_id: 1000118, touches: ['modules/autonomy/fence.js'] };
+  const d = fence.decideTask({ task, goals: [1000118], protectedHits: [], selfHits: runnerSelf.matchRunnerSelf(task.touches) });
+  assert.equal(d.go, false);
+  assert.equal(d.code, 'self_modification');
+  assert.deepEqual(d.files, ['modules/autonomy/fence.js']);
+  assert.match(d.reason, /supervisor, safety checks or kill switch/);
+});
+
+await test('decideTask keeps its order: a protected path is still reported as one', () => {
+  const task = { id: 7, goal_id: 1, touches: ['scripts/gds/autobongos-run.js'] };
+  const d = fence.decideTask({ task, goals: [1], protectedHits: pcheck.matchProtected(task.touches), selfHits: runnerSelf.matchRunnerSelf(task.touches) });
+  assert.equal(d.code, 'protected_path');
+  assert.equal(fence.decideTask({ task: { id: 8, goal_id: 1, touches: [] }, goals: [1] }).go, true, 'no hits, no refusal');
+});
+
+function fakeApi(tasks) {
+  return {
+    me: { getMe: async () => ({ ok: true, data: { builder: { rank: 'archon' } } }) },
+    tasks: {
+      getTasks: async ({ query }) => ({ ok: true, data: { tasks: query.offset ? [] : tasks.map((t) => ({ goal_id: query.goal_id, ...t })) } }),
+      getTasksId: async ({ id }) => {
+        const t = tasks.find((x) => Number(x.id) === Number(id));
+        return t ? { ok: true, data: { task: { goal_id: 1000118, ...t } } } : { ok: false };
+      },
+      getTasksClaimable: async () => ({ ok: true, data: { claimable: tasks.map((t) => ({ id: t.id })) } }),
+    },
+  };
+}
+const ready = (over) => ({ title: 'A change', status: 'ready', kind: 'bug', description: 'x'.repeat(400), dependencies: [], touches: [], requires_rank: 'xenos', ...over });
+
+await test('the picker passes over a self-editing task and takes the next one, listing why', async () => {
+  const api = fakeApi([ready({ id: 9001, touches: ['modules/autonomy/fence.js'] }), ready({ id: 9002 })]);
+  const got = await runner.pickTask([1000118], { api, rank: 'archon' });
+  assert.equal(got.task.id, 9002, 'the runner must not keep re-picking work it may never do');
+  const sk = got.skipped.find((s) => s.id === 9001);
+  assert.ok(sk, 'the passed-over task is listed');
+  assert.equal(sk.reasons[0].code, 'self_modification');
+});
+
+await test('a goal of nothing but self-editing work reads as an unworkable queue, not idle', async () => {
+  const got = await runner.pickTask([1000118], { api: fakeApi([ready({ id: 9001, touches: ['scripts/bongos/autobongos-loop.js'] })]), rank: 'archon' });
+  assert.equal(got.none, true);
+  assert.deepEqual(got.skipped.map((s) => s.reasons[0].code), ['self_modification']);
+});
+
+await test('an iteration handed a self-editing task makes no tree, no claim and no worker', async () => {
+  const calls = [];
+  const rows = [];
+  const deps = {
+    gauge: () => ({ decision: { go: true, unknown: false, sleepUntil: null, reason: 'headroom' } }),
+    readFence: async () => ({ raw: { enabled: true, paused_reason: null, goals: [{ goal_id: 1000118 }] }, graderBypassed: false }),
+    api: {},
+    state: runner.newRunnerState(),
+    pickTask: async () => ({ task: { id: 4242, title: 't', kind: 'bug', description: 'd'.repeat(300), goal_id: 1000118, touches: ['modules/autonomy/fence.js'] }, goalId: 1000118, skipped: [] }),
+    worktreeName: () => 'autobongos-4242-abc123',
+    record: (r) => { rows.push(r); return r; },
+    run: async (bin, args) => { calls.push(args[0]); return { ok: true, code: 0, stdout: '', stderr: '' }; },
+    spawnWorker: async () => { calls.push('WORKER'); return { envelope: {}, exitCode: 0 }; },
+  };
+  const row = await runner.iteration({ goals: [1000118], maxTasks: 1, dryRun: false, model: 'm', timeoutMs: 1000 }, deps);
+  assert.equal(row.event, 'fenced');
+  assert.equal(row.code, 'self_modification');
+  assert.deepEqual(row.files, ['modules/autonomy/fence.js'], 'the log row names the file');
+  assert.deepEqual(calls, []);
+});
+
+// ---- 2. undeclared: caught in the real diff ---------------------------------
+
+await test('every worker the supervisor spawns carries the runner flag', () => {
+  const env = runner.workerEnv({ PATH: '/usr/bin' });
+  assert.equal(env[runnerSelf.RUNNER_WORKER_ENV], '1');
+  assert.equal(runnerSelf.RUNNER_WORKER_ENV, 'AUTOBONGOS_WORKER');
+});
+
+await test('ship.js inside a worker refuses an undeclared autobongos-* edit; outside one it does nothing', () => {
+  const files = ['modules/hall-ui/public/x.js', 'scripts/bongos/autobongos-loop.js'];
+  const worker = { AUTOBONGOS_WORKER: '1' };
+  assert.deepEqual(runnerSelf.selfEditRefusal({ files, env: worker, matchProtected: pcheck.matchProtected }), { code: 'self_modification', files: ['scripts/bongos/autobongos-loop.js'], protected: [] });
+  assert.equal(runnerSelf.selfEditRefusal({ files, env: {}, matchProtected: pcheck.matchProtected }), null, 'a person shipping is never refused');
+  assert.equal(runnerSelf.selfEditRefusal({ files: ['modules/hall-ui/public/x.js'], env: worker, matchProtected: pcheck.matchProtected }), null);
+});
+
+await test('ship.js inside a worker refuses an undeclared protected file, and only asks the matcher inside a worker', () => {
+  const worker = { AUTOBONGOS_WORKER: '1' };
+  const r = runnerSelf.selfEditRefusal({ files: ['migrations/999_x.sql', 'docs/a.md'], env: worker, matchProtected: pcheck.matchProtected });
+  assert.deepEqual(r, { code: 'runner_protected_path', files: [], protected: ['migrations/999_x.sql'] });
+  assert.match(runnerSelf.selfEditMessage(r), /protected permission, migration, infrastructure or pipeline file \(migrations\/999_x\.sql\)/);
+  let asked = 0;
+  runnerSelf.selfEditRefusal({ files: ['migrations/999_x.sql'], env: {}, matchProtected: () => { asked++; return []; } });
+  assert.equal(asked, 0, 'a person\'s ship never runs the check at all');
+});
+
+await test('ship.js runs that check on the committed diff, before the grade, on both the ship and the re-grade', () => {
+  const src = read('scripts/bongos/ship-flow.js');
+  const sites = src.match(/const committedFiles = computeChangedFiles\(graderBaseline\);\n\s*refuseRunnerSelfEdit\(committedFiles\);/g) || [];
+  assert.equal(sites.length, 2, 'shipMain and regradeMain each check before anything is resolved or graded');
+  assert.match(src, /function refuseRunnerSelfEdit\(files\) \{\n\s*const refusal = runnerSelf\.selfEditRefusal\(\{ files, matchProtected \}\);/);
+});
+
+await test('the worker is told not to add a session log, which would make the ship touch the protected CLAUDE.md', () => {
+  const { buildWorkerPrompt } = require('../scripts/bongos/autobongos-loop.js');
+  assert.match(buildWorkerPrompt({ task: { id: 7, title: 't', description: 'd' } }), /Do not add a session-log file under docs\/session-logs\//);
+  assert.equal(pcheck.matchProtected(['CLAUDE.md']).length, 1, 'still protected, so the instruction is load-bearing');
+});
+
+const RUNNER_CLAIM = { worktree_name: 'autobongos-4242-abc123', requested_worktree_name: 'autobongos-4242-abc123' };
+const files = (...p) => p.map((x) => ({ path: x }));
+const refusal = (claim, prFiles, extra = {}) => guard.runnerSelfEditRefusal({ taskId: 4242, prNumber: 77 }, {
+  readLatestClaim: async () => claim, getPullRequestFiles: async () => prFiles, ...extra,
+});
+
+await test('the server refuses a runner\'s pull request that edits an autobongos-* file it never declared', async () => {
+  const r = await refusal(RUNNER_CLAIM, files('modules/hall-ui/public/x.js', 'scripts/bongos/autobongos-loop.js'));
+  assert.deepEqual(r, { code: 'self_modification', files: ['scripts/bongos/autobongos-loop.js'], protected: [] });
+  assert.match(guard.refusalMessage(r), /autobongos-loop\.js.*pull request was closed/s);
+});
+
+await test('the server refuses a runner\'s pull request that touches a protected file, the route itself included', async () => {
+  const r = await refusal(RUNNER_CLAIM, files('modules/lifecycle/routes/tasks.js'));
+  assert.equal(r.code, 'runner_protected_path');
+  assert.deepEqual(r.protected, ['modules/lifecycle/routes/tasks.js']);
+  assert.match(guard.refusalMessage(r), /protected permission, migration, infrastructure or pipeline file/);
+});
+
+await test('a registry matcher that does not flag the paths it always has is not trusted', async () => {
+  for (const matchProtected of [() => [], () => { throw new Error('swapped'); }, () => null]) {
+    const r = await refusal(RUNNER_CLAIM, files('docs/a.md'), { matchProtected });
+    assert.equal(r.code, 'self_modification_unreadable', 'a neutered matcher refuses rather than waving everything through');
+  }
+});
+
+await test('moving a guard away is an edit to it', async () => {
+  const r = await refusal(RUNNER_CLAIM, [{ path: 'modules/elsewhere/fence.js', previous_path: 'modules/autonomy/fence.js', status: 'renamed' }]);
+  assert.equal(r.code, 'self_modification');
+  assert.deepEqual(r.files, ['modules/autonomy/fence.js']);
+});
+
+await test('a person\'s claim is never checked, and its files are never read', async () => {
+  let read = 0;
+  const r = await refusal({ worktree_name: 'my-branch', requested_worktree_name: null }, files('modules/autonomy/fence.js'), {
+    getPullRequestFiles: async () => { read++; return []; },
+  });
+  assert.equal(r, null);
+  assert.equal(read, 0);
+  assert.equal(await refusal(null, files('modules/autonomy/fence.js')), null, 'no claim row, no check');
+});
+
+await test('a disambiguated name is still the runner when the requested one is', async () => {
+  const r = await refusal({ worktree_name: 'autobongos-4242-abc123-2', requested_worktree_name: 'autobongos-4242-abc123' }, files('modules/autonomy/gauge.js'));
+  assert.equal(r.code, 'self_modification');
+});
+
+await test('a runner\'s files that cannot be read in full are refused, never waved through', async () => {
+  assert.equal((await refusal(RUNNER_CLAIM, null, { getPullRequestFiles: async () => { throw new Error('502'); } })).code, 'self_modification_unreadable');
+  const cap = require('../modules/lifecycle/ship-files.js').PR_FILES_CAP;
+  const many = Array.from({ length: cap }, (_, i) => ({ path: `docs/n${i}.md` }));
+  assert.equal((await refusal(RUNNER_CLAIM, many)).code, 'self_modification_unreadable');
+  assert.equal(await refusal(RUNNER_CLAIM, files('docs/a.md')), null, 'a clean runner diff publishes');
+});
+
+await test('a claim read that fails lets an ordinary publish through, but not a runner\'s branch', async () => {
+  const failing = { query: async () => { throw new Error('db down'); } };
+  const claim = await guard.readLatestClaim(4242, failing);
+  assert.equal(claim && claim.unreadable, true, 'a failed read is not the same answer as no claim');
+  const viaFailedRead = (branch, prFiles) => guard.runnerSelfEditRefusal({ taskId: 4242, prNumber: 77, branch }, {
+    readLatestClaim: (id) => guard.readLatestClaim(id, failing), getPullRequestFiles: async () => prFiles,
+  });
+  assert.equal(await viaFailedRead('fix-the-fence', files('modules/autonomy/fence.js')), null, 'an ordinary publish never depends on the read');
+  assert.equal((await viaFailedRead('autobongos-4242-abc123', files('modules/autonomy/fence.js'))).code, 'self_modification', 'a runner branch is still checked');
+  const seen = [];
+  await guard.readLatestClaim(4242, { query: async (sql, params) => { seen.push({ sql, params }); return { rows: [] }; } });
+  assert.match(seen[0].sql, /FROM claims c WHERE c\.task_id = \$1\s+ORDER BY c\.claimed_at DESC, c\.id DESC LIMIT 1/);
+  assert.deepEqual(seen[0].params, [4242]);
+});
+
+// ---- the real publish route --------------------------------------------------
+
+const express = require('express');
+const api = require('../src/module-api.js');
+const db = require('../modules/lifecycle/db.js');
+const gp = require('../modules/lifecycle/github-push.js');
+const prAssign = require('../modules/lifecycle/pr-assign.js');
+const prClose = require('../modules/lifecycle/github-pr-close.js');
+const pageTweakReads = require('../modules/lifecycle/page-tweak-reads.js');
+
+let claim = RUNNER_CLAIM;
+let prFiles = files('docs/a.md');
+let armCalls = 0;
+let closed = [];
+api.requireBuilder = (req, res, next) => { req.builder = { id: 1, rank: 'archon', github_login: 'the-archon' }; next(); };
+db.getLastClaimHolder = async () => ({ builder_id: 3, github_login: 'some-builder' });
+db.setClaimPublishedSha = async () => {};
+api.pool.query = async (sql) => {
+  if (/c\.auto_pickup/.test(sql)) return { rows: [{ id: 4242, source: 'planning-session', source_ref: null, auto_pickup: null }] };
+  if (/c\.worktree_name, c\.requested_worktree_name/.test(sql)) return { rows: claim ? [claim] : [] };
+  return { rows: [] };
+};
+gp.isConfigured = () => true;
+gp.pushBundle = async () => ({ head_sha: 'a'.repeat(40) });
+gp.openOrFindPullRequest = async () => ({ number: 77, url: 'https://github.com/o/r/pull/77', node_id: 'N' });
+gp.enableAutoMergeDetailed = async () => { armCalls++; return { ok: true }; };
+let fileReads = 0;
+gp.getPullRequestFiles = async () => { fileReads++; return prFiles; };
+gp.setCommitStatus = async () => true;
+prAssign.assignPullRequest = async () => ({ assigned: true });
+prClose.closePullRequest = async ({ number }) => { closed.push(number); return { ok: true }; };
+pageTweakReads.heldForArtistFailClosed = async () => false;
+
+const app = express();
+app.use((req, res, next) => { res.fail = (code, status, extra) => res.status(typeof status === 'number' ? status : (status && status.status) || 500).json({ error: code, ...(extra || {}) }); next(); });
+app.use(require('../modules/lifecycle/routes/tasks.js')());
+const server = http.createServer(app);
+await new Promise((r) => server.listen(0, '127.0.0.1', r));
+const base = `http://127.0.0.1:${server.address().port}`;
+const publish = async () => {
+  const res = await fetch(`${base}/tasks/4242/publish-branch`, {
+    method: 'POST', headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ branch: 'autobongos-4242-abc123', head_sha: 'a'.repeat(40), bundle_b64: Buffer.from('b').toString('base64'), value_summary: 'A fix.' }),
+  });
+  return { status: res.status, body: await res.json() };
+};
+
+await test('publish: a runner\'s undeclared self-edit is REFUSED 409, its PR closed, never armed', async () => {
+  claim = RUNNER_CLAIM; prFiles = files('modules/hall-ui/public/x.js', 'scripts/bongos/autobongos-run.js'); armCalls = 0; closed = [];
+  const r = await publish();
+  assert.equal(r.status, 409, JSON.stringify(r.body));
+  assert.equal(r.body.error, 'self_modification');
+  assert.deepEqual(r.body.files, ['scripts/bongos/autobongos-run.js']);
+  assert.match(r.body.message, /supervisor, safety checks or kill switch/);
+  assert.deepEqual(closed, [77]);
+  assert.equal(armCalls, 0);
+});
+
+await test('publish: a runner\'s clean change publishes and arms as usual', async () => {
+  claim = RUNNER_CLAIM; prFiles = files('modules/hall-ui/public/x.js'); armCalls = 0; closed = [];
+  const r = await publish();
+  assert.equal(r.status, 201, JSON.stringify(r.body));
+  assert.deepEqual(closed, []);
+  assert.equal(armCalls, 1);
+});
+
+await test('publish: a runner\'s auto-pickup round reads its pull request\'s files from GitHub once, for both checks', async () => {
+  const round = { id: 4242, source: 'page-tweak', source_ref: 'page-tweak/landing:index/r2', auto_pickup: true };
+  const before = api.pool.query;
+  api.pool.query = async (sql) => (/c\.auto_pickup/.test(sql) ? { rows: [round] } : before(sql));
+  claim = RUNNER_CLAIM; prFiles = files('modules/public-landing/public/index.html'); fileReads = 0; closed = [];
+  try {
+    await publish();
+    assert.equal(fileReads, 1, 'the auto-pickup check and the runner check share one read');
+  } finally { api.pool.query = before; }
+});
+
+await test('publish: a person\'s change to the same files is not checked', async () => {
+  claim = { worktree_name: 'fix-the-fence', requested_worktree_name: null }; prFiles = files('modules/autonomy/fence.js'); closed = [];
+  const r = await publish();
+  assert.equal(r.status, 201, JSON.stringify(r.body));
+  assert.deepEqual(closed, []);
+});
+server.close();
+
+summary();