@bongos/core 1.24.26 → 1.24.28

package/scripts/hall-preview/server.js

@@ -195,6 +195,10 @@ const CANNED_WRITES = [
   // the Market Watch weekly ask's answer (task 1004940), so its "sent." state renders.
   ['POST', /^market-watch\/ask\/answer$/, 'market-watch__ask__answer.post'],
   ['PATCH', /^specialities\/\d+$/, 'specialities__12.patch'],
+  // the rest of the speciality tools, now on My agents too (task 1005052): stop
+  // using one, and train your own, so their toasts and redraws render here.
+  ['POST', /^specialities\/\d+\/abandon$/, 'specialities__12__abandon.post'],
+  ['POST', /^specialities\/\d+\/documents$/, 'specialities__12__documents.post'],
   // a vote cast from the street's matter card (task 1004528), so the card's
   // answer (the toast, the building lighting) renders here too.
   ['POST', /^government\/board\/items\/\d+\/votes$/, 'government__board__items__votes.post'],

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

package/tests/core_update_banner.mjs

@@ -237,7 +237,7 @@ test('a real request through the assembled router returns the verdict, not a 500
   }
 });
 
-// ── the banner ────────────────────────────────────────────────────────────────
+// ── the shell's half: who is asked, and how often ───────────────────────────────
 
 function boot({ permissions, update, status = 200, dismissed = null, provisioning = true, pathname = '/settings' } = {}) {
   const els = new Map();
@@ -295,15 +295,6 @@ function boot({ permissions, update, status = 200, dismissed = null, provisionin
 
 const BEHIND = { running: '1.19.861', latest: '1.19.871', behind: true, reading: 'ok' };
 
-test('an owner who is behind sees the banner, naming both versions', async () => {
-  const b = boot({ permissions: { 'core.pin.move': true }, update: BEHIND });
-  await new Promise((r) => setTimeout(r, 0));
-  const el = b.banner();
-  assert.ok(el, 'banner rendered');
-  assert.match(el.innerHTML, /1\.19\.871/);
-  assert.match(el.innerHTML, /1\.19\.861/);
-});
-
 test('a builder without the atom is never even asked about it', async () => {
   const b = boot({ permissions: { 'task.create': true }, update: BEHIND });
   await new Promise((r) => setTimeout(r, 0));
@@ -311,33 +302,6 @@ test('a builder without the atom is never even asked about it', async () => {
   assert.ok(!b.requested.includes('GET /api/bongos/core-update'), 'no request is made');
 });
 
-test('no answer renders no banner — not a false "up to date"', async () => {
-  const b = boot({ permissions: { 'core.pin.move': true }, update: { running: '1.19.861', latest: null, behind: false, reading: 'no_answer' } });
-  await new Promise((r) => setTimeout(r, 0));
-  assert.equal(b.banner(), undefined);
-});
-
-test('a dismissal silences THAT version only', async () => {
-  const same = boot({ permissions: { 'core.pin.move': true }, update: BEHIND, dismissed: '1.19.871' });
-  await new Promise((r) => setTimeout(r, 0));
-  assert.equal(same.banner(), undefined, 'the dismissed version stays dismissed');
-
-  const newer = boot({ permissions: { 'core.pin.move': true }, update: BEHIND, dismissed: '1.19.800' });
-  await new Promise((r) => setTimeout(r, 0));
-  assert.ok(newer.banner(), 'a newer release re-announces itself');
-});
-
-test('the Upgrade action appears only where the deploy door exists', async () => {
-  const on = boot({ permissions: { 'core.pin.move': true }, update: BEHIND, provisioning: true });
-  await new Promise((r) => setTimeout(r, 0));
-  assert.match(on.banner().innerHTML, /href="\/deploy"/);
-
-  const off = boot({ permissions: { 'core.pin.move': true }, update: BEHIND, provisioning: false });
-  await new Promise((r) => setTimeout(r, 0));
-  assert.ok(off.banner(), 'a tenant still hears the news');
-  assert.doesNotMatch(off.banner().innerHTML, /href="\/deploy"/, 'but is not offered a 404');
-});
-
 test('the banner is asked for ONCE, not on every access settle', async () => {
   const b = boot({ permissions: { 'core.pin.move': true }, update: BEHIND });
   await new Promise((r) => setTimeout(r, 0));
@@ -345,61 +309,11 @@ test('the banner is asked for ONCE, not on every access settle', async () => {
   assert.equal(first, 1);
 });
 
-// ── the chain, with the map the SERVER would really send (task 1004118) ───────
-//
-// Every case above hands applyAccess a permissions map written here. That is exactly
-// how task 1004045's banner shipped dead: it gated on `core.pin.move`, /me resolved
-// only NAV_PERMISSION_ATOMS, the atom was not in it, and the guard bailed for every
-// builder on every instance — while this suite stayed green throughout.
-//
-// So this case does NOT write the map. It DERIVES it from me.js's own declaration,
-// the way the server does, and grants everything in it. If the atom the banner needs
-// is not part of that projection, there is nothing here to grant and the banner
-// cannot render — which is the real bug, reproduced as a failure.
-test('the banner renders from the projection /me ACTUALLY sends, not one written by this test', async () => {
-  const meSrc = fs.readFileSync(path.join(ROOT, 'src/bongos/routes/me.js'), 'utf8');
-  const m = meSrc.match(/NAV_PERMISSION_ATOMS = Object\.freeze\(\[([^\]]*)\]\)/);
-  assert.ok(m, 'NAV_PERMISSION_ATOMS is readable');
-  const atoms = m[1].split(',').map((x) => x.trim().replace(/^'|'$/g, '')).filter(Boolean);
-  // A builder who holds everything the projection can report — the most generous real
-  // answer the server is capable of giving.
-  const permissions = Object.fromEntries(atoms.map((a) => [a, true]));
-  const b = boot({ permissions, update: BEHIND });
-  await new Promise((r) => setTimeout(r, 0));
-  assert.ok(
-    b.banner(),
-    'the banner did not render for a builder holding EVERY atom /me can report — so the atom it ' +
-    'gates on is outside NAV_PERMISSION_ATOMS and the feature is dead for everyone (task 1004118)',
-  );
-});
-
-// ── the banner must not offer the page you are on (task 1004145) ──────────────
-// The owner pressed this on /deploy and reported "I clicked update, but I didn't see
-// anything happen". Nothing had: it is an <a href="/deploy"> styled as a button and
-// labelled with the verb, so on /deploy it navigates to the current page and does
-// nothing at all. No request was ever made — verified against the live box, which had
-// no core-upgrade POST in three hours and no queued intent from that press.
-
-test('on /deploy the banner points at the control instead of linking to /deploy', async () => {
-  const b = boot({ pathname: '/deploy', permissions: { 'core.pin.move': true }, update: BEHIND });
-  await new Promise((r) => setTimeout(r, 0));
-  const html = b.banner().innerHTML;
-  assert.doesNotMatch(html, /href="\/deploy"/, 'no link to the page already open');
-  assert.match(html, /control below/i, 'it says where the real control is');
-  assert.match(html, /1\.19\.871/, 'and still announces the release');
-});
-
-test('everywhere else the banner still offers the link', async () => {
-  const b = boot({ pathname: '/settings', permissions: { 'core.pin.move': true }, update: BEHIND });
-  await new Promise((r) => setTimeout(r, 0));
-  assert.match(b.banner().innerHTML, /href="\/deploy"/, 'the action is real from any other page');
-});
-
-test('a trailing slash is still /deploy', async () => {
-  const b = boot({ pathname: '/deploy/', permissions: { 'core.pin.move': true }, update: BEHIND });
-  await new Promise((r) => setTimeout(r, 0));
-  assert.doesNotMatch(b.banner().innerHTML, /href="\/deploy"/);
-});
+// The pill (task 1005041) replaced the banner, and its DOM half — said only from an answer,
+// rendered from the projection /me really sends (task 1004118), never a link to the page you
+// are on (task 1004145), never offering a held version (task 1004730) — is pinned against the
+// real shell.js and update-pill.js in tests/update_pill.mjs. What stays here is the verdict,
+// the route, and the shell's half: who is asked, and how often.
 
 test('the banner asks with the project\'s stored update rule (task 1004535)', async () => {
   const r2 = createRequire(import.meta.url);