@bongos/core 1.24.77 → 1.24.79

package/tests/autonomy_runner_device.mjs

@@ -0,0 +1,444 @@
+// tests/autonomy_runner_device.mjs — each device's own Run switch (task 1005094).
+//
+// Owner direction, 2026-11-09: running Autobongos on a device is ONE button on
+// that device's card, with any cooldown shown on the button. The server half of
+// that is a switch per device, and what must hold about it:
+//
+//   · the switch is the LAST layer of the fence, read by the runner as part of
+//     the fence it already reads — and a caller that names no device is exactly
+//     as fenced as before;
+//   · nothing on the device can move it: the two routes that do refuse a
+//     runner's own login, and a check-in can only set the value a NEW row is
+//     born with;
+//   · a device set up the new way starts stopped; one that predates this keeps
+//     running;
+//   · a press wakes a waiting runner (the fence's updated_at moves);
+//   · a resting runner's resume time reaches the card, sanity-checked.
+//
+// The pure pieces are driven directly; the routes are driven as REAL requests
+// through the assembled router with only the auth gates stubbed (the
+// autonomy_builder_scope precedent); the SQL runs against a stubbed pool.
+//
+// DB-free, no network. Run:  node --test tests/autonomy_runner_device.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const req = createRequire(import.meta.url);
+const express = req('express');
+const { attachFail } = req(path.join(ROOT, 'src/bongos/middleware/error-envelope.js'));
+const fence = req(path.join(ROOT, 'modules/autonomy/fence.js'));
+const cadence = req(path.join(ROOT, 'modules/autonomy/cadence.js'));
+const configIdle = req(path.join(ROOT, 'modules/autonomy/config-idle.js'));
+const health = req(path.join(ROOT, 'modules/autonomy/runner-health.js'));
+
+const PROJECT = Object.freeze({
+  enabled: true, paused_reason: null, priority_goal_id: null,
+  updated_at: '2026-11-01T09:00:00.000Z', updated_by: '3',
+  goals: [{ goal_id: 1000118, note: 'bug squash' }],
+});
+const SCOPE = Object.freeze({ goals: [1000118], owner_paused: false, updated_at: '2026-11-02T09:00:00.000Z' });
+
+// ── the fence's last layer ───────────────────────────────────────────────────
+
+test('a device its builder stopped is fenced off, and the runner is told which stop it is', () => {
+  const f = fence.effectiveFence({ project: PROJECT, scope: SCOPE, mayRun: true, device: { host: 'ada-laptop', run_requested: false, run_changed_at: '2026-11-03T09:00:00.000Z' } });
+  assert.equal(f.enabled, false);
+  assert.equal(f.stop_code, 'device_stopped');
+  assert.deepEqual(f.device, { host: 'ada-laptop', run_requested: false });
+  const d = fence.decideRun({ fence: f, graderBypassed: false });
+  assert.equal(d.go, false);
+  assert.equal(d.code, 'device_stopped');
+  assert.match(d.reason, /press Run/, 'the runner log says how to start it');
+});
+
+test('a device that is switched on, or a caller that names no device, is exactly as fenced as before', () => {
+  const before = fence.effectiveFence({ project: PROJECT, scope: SCOPE, mayRun: true });
+  for (const device of [null, undefined, { host: 'pc', run_requested: true, run_changed_at: null }]) {
+    const f = fence.effectiveFence({ project: PROJECT, scope: SCOPE, mayRun: true, device });
+    assert.equal(f.enabled, true, JSON.stringify(device));
+    assert.deepEqual(f.goals, before.goals);
+    assert.equal(f.stop_code, null);
+  }
+  assert.equal(before.device, null);
+  // Only an explicit false stops: a row that somehow lacks the column is not a stop.
+  assert.equal(fence.effectiveFence({ project: PROJECT, scope: SCOPE, mayRun: true, device: { host: 'pc' } }).enabled, true);
+});
+
+test('the device switch is the LAST reason given: every wider stop is reported first', () => {
+  const device = { host: 'pc', run_requested: false };
+  const off = fence.effectiveFence({ project: { ...PROJECT, enabled: false, paused_reason: 'night off' }, scope: SCOPE, mayRun: true, device });
+  assert.equal(off.stop_code, 'kill_switch');
+  assert.equal(fence.effectiveFence({ project: PROJECT, scope: SCOPE, mayRun: false, device }).stop_code, 'not_permitted');
+  assert.equal(fence.effectiveFence({ project: PROJECT, scope: { ...SCOPE, owner_paused: true }, mayRun: true, device }).stop_code, 'builder_paused');
+});
+
+test('a press of Run moves the fence stamp a waiting runner is watching', () => {
+  const pressed = '2026-11-09T12:00:00.000Z';
+  const f = fence.effectiveFence({ project: PROJECT, scope: SCOPE, mayRun: true, device: { host: 'pc', run_requested: true, run_changed_at: pressed } });
+  assert.equal(f.updated_at, pressed, 'later than the project and the picks, so it wins');
+  const older = fence.effectiveFence({ project: PROJECT, scope: SCOPE, mayRun: true, device: { host: 'pc', run_requested: true, run_changed_at: '2026-10-01T00:00:00.000Z' } });
+  assert.equal(older.updated_at, new Date(SCOPE.updated_at).toISOString(), 'an old press never moves the stamp backwards');
+});
+
+test('the runner waits out a device stop as a stop, and nobody is alerted about it', () => {
+  const row = { event: 'fenced', code: 'device_stopped', reason: 'this device is stopped' };
+  assert.equal(cadence.classifyEvent(row).class, 'stopped', 'a person decided: no failure ladder, no probing');
+  assert.equal(configIdle.configIdleCode(row), null, 'the builder’s own Stop is never a setting someone must fix');
+  assert.equal(configIdle.trackIdle(null, row, Date.now()), null);
+});
+
+// ── what the card is told ────────────────────────────────────────────────────
+
+const NOW = Date.parse('2026-11-09T12:00:00.000Z');
+const beat = (over = {}) => ({ host: 'ada-laptop', last_seen_at: '2026-11-09T11:59:30.000Z', last_event: 'loop', run_requested: true, ...over });
+
+test('a stopped device that is still checking in reads as stopped, not running and not an alarm', () => {
+  const h = health.describeRunner(beat({ run_requested: false, last_event: 'fenced' }), { nowMs: NOW });
+  assert.equal(h.state, 'stopped');
+  assert.equal(h.ok, true);
+  assert.equal(h.runRequested, false);
+  assert.match(h.detail, /stopped on ada-laptop/);
+});
+
+test('a device stopped mid-task is still the working runner it is until the task ends', () => {
+  const h = health.describeRunner(beat({ run_requested: false, working_task_id: 1004711 }), { nowMs: NOW });
+  assert.equal(h.state, 'alive');
+  assert.equal(h.workingTaskId, '1004711');
+  assert.equal(h.runRequested, false, 'and the card can say Stopping');
+});
+
+test('silence wins over the switch: a stopped device nobody has heard from is late or dead first', () => {
+  assert.equal(health.describeRunner(beat({ run_requested: false, last_seen_at: '2026-11-09T11:00:00.000Z' }), { nowMs: NOW }).state, 'late');
+  assert.equal(health.describeRunner(beat({ run_requested: false, last_seen_at: '2026-11-08T00:00:00.000Z' }), { nowMs: NOW }).state, 'dead');
+});
+
+test('every state carries the switch and a rest time that is still ahead', () => {
+  const resting = health.describeRunner(beat({ last_event: 'hold', hold_until: '2026-11-09T15:40:00.000Z' }), { nowMs: NOW });
+  assert.equal(resting.state, 'alive');
+  assert.equal(resting.holdUntil, '2026-11-09T15:40:00.000Z');
+  assert.equal(resting.runRequested, true);
+  assert.equal(health.describeRunner(beat({ hold_until: new Date('2026-11-09T15:40:00.000Z') }), { nowMs: NOW }).holdUntil, '2026-11-09T15:40:00.000Z', 'the database hands back a Date');
+  assert.equal(health.describeRunner(beat({ hold_until: '2026-11-09T11:00:00.000Z' }), { nowMs: NOW }).holdUntil, null, 'a rest already over is not a rest');
+  assert.equal(health.describeRunner(beat({ hold_until: 'soon' }), { nowMs: NOW }).holdUntil, null);
+  assert.equal(health.describeRunner(beat({ run_requested: undefined }), { nowMs: NOW }).runRequested, true, 'a row from before the column reads as switched on');
+});
+
+// ── the routes ───────────────────────────────────────────────────────────────
+
+const permStub = (key) => {
+  const mw = (_req, _res, next) => next();
+  mw.permKey = key;
+  return mw;
+};
+// Who is calling: an ordinary session of builder 7, or builder 7's runner login.
+let caller = { runner: false, sessionId: 501 };
+const passBuilder = (reqq, _res, next) => {
+  reqq.builder = { id: 7, rank: 'metic', runner: caller.runner };
+  reqq.gdsSession = { session_id: caller.sessionId, source: caller.runner ? 'runner' : 'web' };
+  reqq.rawPermissionKeys = ['autonomy.run'];
+  next();
+};
+
+function autonomyRouter() {
+  const api = req(path.join(ROOT, 'src/module-api.js'));
+  const saved = { b: api.requireBuilder, p: api.requirePermission };
+  api.requireBuilder = passBuilder;
+  api.requirePermission = permStub;
+  const routePath = req.resolve(path.join(ROOT, 'modules/autonomy/routes/autonomy.js'));
+  delete req.cache[routePath];
+  try { return req(routePath)(); } finally { api.requireBuilder = saved.b; api.requirePermission = saved.p; }
+}
+
+async function serve(router) {
+  const app = express();
+  app.use(express.json());
+  app.use(attachFail);
+  app.use(router);
+  const server = app.listen(0);
+  await new Promise((r) => server.once('listening', r));
+  return { base: `http://127.0.0.1:${server.address().port}`, close: () => server.close() };
+}
+
+const send = (base, method, p, body) => fetch(`${base}${p}`, {
+  method, headers: { 'content-type': 'application/json' }, body: body === undefined ? undefined : JSON.stringify(body),
+});
+
+function gateOf(router, p, method) {
+  const layer = router.stack.find((l) => l.route && l.route.path === p && l.route.methods[method]);
+  assert.ok(layer, `${method.toUpperCase()} ${p} is registered`);
+  return layer.route.stack.map((s) => s.handle.permKey).filter(Boolean);
+}
+
+// Swap db functions for one test, and put them back whatever happens.
+async function withDb(stubs, fn) {
+  const db = req(path.join(ROOT, 'modules/autonomy/db.js'));
+  const api = req(path.join(ROOT, 'src/module-api.js'));
+  const saved = Object.fromEntries(Object.keys(stubs).map((k) => [k, db[k]]));
+  const savedResolve = api.resolveOptional;
+  Object.assign(db, stubs);
+  api.resolveOptional = (name) => (name === 'government' ? { effectivePermissions: (keys) => keys, builderHasPermissions: async () => true } : savedResolve(name));
+  const s = await serve(autonomyRouter());
+  try { await fn(s.base); } finally {
+    s.close();
+    Object.assign(db, saved);
+    api.resolveOptional = savedResolve;
+    caller = { runner: false, sessionId: 501 };
+  }
+}
+
+test('the gates: Run and Stop behind autonomy.run, Remove open to any builder, the setup scripts public', () => {
+  const router = autonomyRouter();
+  assert.deepEqual(gateOf(router, '/autonomy/runners/:host/run', 'post'), ['autonomy.run']);
+  assert.deepEqual(gateOf(router, '/autonomy/runners/:host', 'delete'), [], 'a builder who lost autonomy.run can still clear their own device');
+  assert.deepEqual(gateOf(router, '/autonomy/runner-setup.ps1', 'get'), []);
+  assert.deepEqual(gateOf(router, '/autonomy/runner-setup.sh', 'get'), []);
+});
+
+test('the fence read folds in the named device, and only that builder’s', async () => {
+  const asked = [];
+  let device = { host: 'ada-laptop', run_requested: false, run_changed_at: '2026-11-09T12:00:00.000Z' };
+  await withDb({
+    readFence: async () => PROJECT,
+    readBuilderScope: async () => SCOPE,
+    readRunnerDevice: async (builderId, host) => { asked.push([builderId, host]); return device; },
+  }, async (base) => {
+    let body = await (await send(base, 'GET', '/autonomy/fence?host=ADA-Laptop')).json();
+    assert.equal(body.enabled, false);
+    assert.equal(body.stop_code, 'device_stopped');
+    assert.deepEqual(asked, [[7, 'ada-laptop']], 'the SESSION builder’s device, by its lowercased name');
+
+    device = { host: 'ada-laptop', run_requested: true, run_changed_at: '2026-11-09T12:05:00.000Z' };
+    body = await (await send(base, 'GET', '/autonomy/fence?host=ada-laptop')).json();
+    assert.equal(body.enabled, true);
+    assert.equal(body.updated_at, '2026-11-09T12:05:00.000Z');
+
+    // No device named: no device read at all, and the answer is the builder's fence.
+    asked.length = 0;
+    body = await (await send(base, 'GET', '/autonomy/fence')).json();
+    assert.equal(body.enabled, true);
+    assert.equal(body.device, null);
+    assert.deepEqual(asked, []);
+
+    // A name that is not a device name is treated as not named — never a failed read.
+    const odd = await send(base, 'GET', `/autonomy/fence?host=${encodeURIComponent('pc; DROP TABLE')}`);
+    assert.equal(odd.status, 200);
+    assert.deepEqual(asked, []);
+
+    // A device that has never checked in has no row: no device layer.
+    device = null;
+    body = await (await send(base, 'GET', '/autonomy/fence?host=new-pc')).json();
+    assert.equal(body.enabled, true);
+  });
+});
+
+test('a runner’s own login cannot dodge its device’s Stop by leaving the name off, or by naming another device', async () => {
+  const asked = [];
+  let mine = { host: 'ada-laptop', run_requested: false, run_changed_at: '2026-11-09T12:00:00.000Z' };
+  await withDb({
+    readFence: async () => PROJECT,
+    readBuilderScope: async () => SCOPE,
+    readRunnerDeviceBySession: async (builderId, sessionId) => { asked.push(['session', builderId, sessionId]); return mine; },
+    readRunnerDevice: async (builderId, host) => { asked.push(['host', builderId, host]); return { host, run_requested: true, run_changed_at: null }; },
+  }, async (base) => {
+    caller = { runner: true, sessionId: 9 };
+    for (const query of ['', '?host=ada-laptop', '?host=some-other-device-that-is-running']) {
+      asked.length = 0;
+      const body = await (await send(base, 'GET', `/autonomy/fence${query}`)).json();
+      assert.equal(body.enabled, false, `a stopped device stays stopped (${query || 'no name'})`);
+      assert.equal(body.stop_code, 'device_stopped');
+      assert.deepEqual(asked, [['session', 7, 9]], 'found by the session the server holds; the name sent is never consulted');
+    }
+
+    // Switched on, it works — by the same lookup.
+    mine = { host: 'ada-laptop', run_requested: true, run_changed_at: '2026-11-09T12:05:00.000Z' };
+    assert.equal((await (await send(base, 'GET', '/autonomy/fence')).json()).enabled, true);
+
+    // A runner login that has not checked in yet has not said which device it is:
+    // it reads as stopped, never as a caller with no device layer.
+    mine = null;
+    const fresh = await (await send(base, 'GET', '/autonomy/fence?host=brand-new')).json();
+    assert.equal(fresh.enabled, false);
+    assert.equal(fresh.stop_code, 'device_stopped');
+
+    // The builder's own session is still asked by name, and only when it gives one.
+    caller = { runner: false, sessionId: 501 };
+    asked.length = 0;
+    assert.equal((await (await send(base, 'GET', '/autonomy/fence?host=old-box')).json()).enabled, true);
+    assert.deepEqual(asked, [['host', 7, 'old-box']]);
+  });
+});
+
+test('Run and Stop set that one device’s switch, for the caller only', async () => {
+  const writes = [];
+  await withDb({
+    setRunnerRun: async (args) => { writes.push(args); return args.host === 'ada-laptop' ? { host: 'ada-laptop', run_requested: args.run, run_changed_at: '2026-11-09T12:00:00.000Z' } : null; },
+  }, async (base) => {
+    let r = await send(base, 'POST', '/autonomy/runners/Ada-Laptop/run', { run: true });
+    assert.equal(r.status, 200);
+    assert.deepEqual(await r.json(), { host: 'ada-laptop', run_requested: true, run_changed_at: '2026-11-09T12:00:00.000Z' });
+    r = await send(base, 'POST', '/autonomy/runners/ada-laptop/run', { run: false });
+    assert.equal((await r.json()).run_requested, false);
+    assert.deepEqual(writes, [{ builderId: 7, host: 'ada-laptop', run: true }, { builderId: 7, host: 'ada-laptop', run: false }]);
+
+    assert.equal((await send(base, 'POST', '/autonomy/runners/someone-elses-pc/run', { run: true })).status, 404, 'a device that is not the caller’s is simply not found');
+    assert.equal((await send(base, 'POST', '/autonomy/runners/ada-laptop/run', {})).status, 400, 'run is required');
+    assert.equal((await send(base, 'POST', '/autonomy/runners/ada-laptop/run', { run: 'yes' })).status, 400, 'and must be a boolean');
+    assert.equal((await send(base, 'POST', '/autonomy/runners/ada-laptop/run', { run: true, builder_id: 3 })).status, 400, 'no extra field can name another builder');
+  });
+});
+
+test('a runner’s own login can neither start, stop nor remove itself', async () => {
+  let touched = 0;
+  await withDb({
+    setRunnerRun: async () => { touched += 1; return { host: 'ada-laptop', run_requested: true }; },
+    removeRunner: async () => { touched += 1; return { host: 'ada-laptop', session_id: '9' }; },
+  }, async (base) => {
+    caller = { runner: true, sessionId: 9 };
+    for (const [method, p, body] of [['POST', '/autonomy/runners/ada-laptop/run', { run: true }], ['POST', '/autonomy/runners/ada-laptop/run', { run: false }], ['DELETE', '/autonomy/runners/ada-laptop', undefined]]) {
+      const r = await send(base, method, p, body);
+      assert.equal(r.status, 403, `${method} ${p}`);
+      assert.equal((await r.json()).error.code, 'runner_session');
+    }
+    assert.equal(touched, 0, 'refused before anything was read or written');
+  });
+});
+
+test('Remove forgets the caller’s device and says whether it had a login of its own', async () => {
+  const removed = [];
+  await withDb({
+    removeRunner: async (args) => { removed.push(args); return args.host === 'ada-laptop' ? { host: 'ada-laptop', session_id: '8801' } : (args.host === 'old-box' ? { host: 'old-box', session_id: null } : null); },
+  }, async (base) => {
+    assert.deepEqual(await (await send(base, 'DELETE', '/autonomy/runners/ada-laptop')).json(), { removed: true, host: 'ada-laptop', had_own_login: true });
+    assert.deepEqual(await (await send(base, 'DELETE', '/autonomy/runners/old-box')).json(), { removed: true, host: 'old-box', had_own_login: false });
+    assert.equal((await send(base, 'DELETE', '/autonomy/runners/not-mine')).status, 404);
+    assert.deepEqual(removed.map((a) => a.builderId), [7, 7, 7], 'always the session builder');
+  });
+});
+
+test('a check-in records the rest time and the runner’s own login from the SESSION, and a new device starts stopped', async () => {
+  const beats = [];
+  await withDb({ recordRunnerHeartbeat: async (args) => { beats.push(args); return { host: args.host }; } }, async (base) => {
+    const inTwoHours = Math.floor(Date.now() / 1000) + 7200;
+
+    // A runner's own login: its session id is recorded, and a new row starts stopped.
+    caller = { runner: true, sessionId: 9 };
+    let r = await send(base, 'POST', '/autonomy/heartbeat', { host: 'ada-laptop', last_event: 'hold', hold_until: inTwoHours, session_id: 4242 });
+    assert.equal(r.status, 400, 'the body cannot name a session');
+    r = await send(base, 'POST', '/autonomy/heartbeat', { host: 'ada-laptop', last_event: 'hold', hold_until: inTwoHours });
+    assert.equal(r.status, 200);
+    assert.equal(beats[0].sessionId, 9, 'from the session that checked in');
+    assert.equal(beats[0].startStopped, true);
+    assert.equal(Math.round(beats[0].holdUntil.getTime() / 1000), inTwoHours);
+
+    // The builder's own CLI session (a runner that predates this): no login of its
+    // own to revoke, and a new row is born running, as it always was.
+    caller = { runner: false, sessionId: 501 };
+    await send(base, 'POST', '/autonomy/heartbeat', { host: 'old-box', last_event: 'loop' });
+    assert.equal(beats[1].sessionId, null);
+    assert.equal(beats[1].startStopped, false);
+    assert.equal(beats[1].holdUntil, null);
+
+    // A rest time that no real rest can have is dropped, never printed on a button.
+    for (const bad of [Math.floor(Date.now() / 1000) + 30 * 24 * 3600, 5, -1]) {
+      beats.length = 0;
+      await send(base, 'POST', '/autonomy/heartbeat', { host: 'old-box', hold_until: bad });
+      assert.equal(beats[0].holdUntil, null, String(bad));
+    }
+    assert.equal((await send(base, 'POST', '/autonomy/heartbeat', { host: 'old-box', hold_until: 'soon' })).status, 400);
+  });
+});
+
+test('the caller’s devices come back with the switch, the rest time and the server’s verdict', async () => {
+  await withDb({
+    readRunnerHeartbeats: async () => [
+      { host: 'ada-laptop', last_seen_at: new Date().toISOString(), last_event: 'fenced', run_requested: false, run_changed_at: null, hold_until: null, session_id: '8801' },
+      { host: 'old-box', last_seen_at: new Date().toISOString(), last_event: 'hold', run_requested: true, run_changed_at: null, hold_until: new Date(Date.now() + 3600 * 1000).toISOString(), session_id: null },
+    ],
+  }, async (base) => {
+    const { runners } = await (await send(base, 'GET', '/autonomy/runners')).json();
+    assert.equal(runners[0].health.state, 'stopped');
+    assert.equal(runners[0].run_requested, false);
+    assert.equal(runners[0].session_id, '8801', 'the caller’s own session id, for Remove');
+    assert.equal(runners[1].health.state, 'alive');
+    assert.ok(runners[1].health.holdUntil, 'a rest still ahead rides on the verdict');
+  });
+});
+
+test('the project serves the two first lines of setup to a device with no login', async () => {
+  await withDb({}, async (base) => {
+    const ps = await send(base, 'GET', '/autonomy/runner-setup.ps1');
+    assert.equal(ps.status, 200);
+    assert.match(ps.headers.get('content-type'), /text\/plain/);
+    assert.equal(ps.headers.get('cache-control'), 'no-store');
+    const psText = await ps.text();
+    assert.match(psText, /autobongos-host\.js/);
+    assert.match(psText, /\$Code/);
+
+    const sh = await send(base, 'GET', '/autonomy/runner-setup.sh');
+    assert.equal(sh.status, 200);
+    const shText = await sh.text();
+    assert.match(shText, /^#!\/usr\/bin\/env bash/);
+    // Nothing about THIS instance is written into either: no address, no code.
+    for (const text of [psText, shText]) assert.doesNotMatch(text, /abr_[0-9a-f]{16}/);
+  });
+});
+
+// ── the SQL ──────────────────────────────────────────────────────────────────
+
+// The module's queries, run against a stand-in pool (the doorway's shared pool
+// object, with its query swapped for the length of one test).
+async function withPool(answer, fn) {
+  const api = req(path.join(ROOT, 'src/module-api.js'));
+  const db = req(path.join(ROOT, 'modules/autonomy/db.js'));
+  const queries = [];
+  const saved = api.pool.query;
+  api.pool.query = async (text, params) => { queries.push({ text, params }); return answer(text, params) || { rows: [] }; };
+  try { await fn(db, queries); } finally { api.pool.query = saved; }
+}
+
+test('a check-in can set the switch only on a row it creates: the conflict arm never names it', async () => {
+  await withPool(() => ({ rows: [{ host: 'pc' }] }), async (db, queries) => {
+    await db.recordRunnerHeartbeat({ builderId: 7, host: 'PC', sessionId: 9, startStopped: true, holdUntil: new Date('2026-11-09T15:40:00Z') });
+    await db.recordRunnerHeartbeat({ builderId: 7, host: 'old-box' });
+    const [fresh, legacy] = queries;
+    const [insert, conflict] = fresh.text.split('ON CONFLICT');
+    assert.match(insert, /run_requested/);
+    assert.doesNotMatch(conflict.split('RETURNING')[0], /run_requested/, 'an existing device keeps the switch its builder set, whatever checks in');
+    assert.match(conflict, /hold_until = EXCLUDED\.hold_until/, 'a runner that stopped resting stops saying so');
+    assert.match(conflict, /session_id = EXCLUDED\.session_id/);
+    assert.equal(fresh.params[0], 'pc', 'the host is the lowercased key');
+    assert.equal(fresh.params[15], false, 'a new device added the new way is born stopped');
+    assert.equal(legacy.params[15], true, 'a runner on its builder’s own session is born running, as before');
+    assert.equal(fresh.params[14], 9);
+    assert.equal(legacy.params[14], null);
+  });
+});
+
+test('the switch and the removal are keyed by the builder AND the device', async () => {
+  await withPool((text) => (/^\s*DELETE/.test(text) ? { rows: [{ host: 'pc', session_id: 8801n }] } : { rows: [{ host: 'pc', run_requested: true, run_changed_at: 't' }] }), async (db, queries) => {
+    await db.setRunnerRun({ builderId: 7, host: 'PC', run: 'truthy-but-not-true' });
+    assert.match(queries[0].text, /WHERE builder_id = \$1 AND host = \$2/);
+    assert.match(queries[0].text, /run_changed_at = now\(\)/);
+    assert.deepEqual(queries[0].params, [7, 'pc', false], 'only a real true switches it on');
+
+    const out = await db.removeRunner({ builderId: 7, host: 'PC' });
+    assert.match(queries[1].text, /DELETE FROM autonomy_runner_heartbeat WHERE builder_id = \$1 AND host = \$2/);
+    assert.deepEqual(out, { host: 'pc', session_id: '8801' });
+
+    await db.readRunnerDevice(7, 'PC');
+    assert.deepEqual(queries[2].params, [7, 'pc']);
+    assert.equal(await db.readRunnerDevice(7, ''), null, 'no name, no read');
+    assert.equal(queries.length, 3);
+
+    await db.readRunnerDeviceBySession(7, 9);
+    assert.match(queries[3].text, /WHERE builder_id = \$1 AND session_id = \$2/);
+    assert.deepEqual(queries[3].params, [7, 9]);
+    assert.equal(await db.readRunnerDeviceBySession(7, null), null, 'no session, no read');
+    assert.equal(queries.length, 4);
+  });
+});

package/tests/autonomy_runner_identity.mjs

@@ -189,7 +189,9 @@ test('the heartbeat SQL overwrites the identity every beat and reads it back', a
     for (const col of ['head', 'disk_head', 'main_head', 'claude_account']) {
       assert.match(calls[0].sql, new RegExp(`\\b${col} = EXCLUDED\\.${col}\\b`), `${col} is overwritten, never kept from the last process`);
     }
-    assert.deepEqual(calls[0].params.slice(9), [A, B, B, 'me@example.com']);
+    // The four identity values, in their own places; what follows them is the
+    // device's rest time, login and birth switch (task 1005094).
+    assert.deepEqual(calls[0].params.slice(9, 13), [A, B, B, 'me@example.com']);
     await db.readRunnerHeartbeats(3);
     assert.match(calls[1].sql, /head, disk_head, main_head, claude_account/);
   } finally {

package/tests/claude_materialize.mjs

@@ -951,6 +951,69 @@ t("the core's OWN deny list covers every file the CLI reads a session from, and
   }
 });
 
+// ---- task 1005186: the runner's own login file is denied like the builder's ----
+// Task 1005095 moved an Autobongos runner's session, heartbeat and run log under a folder of its
+// own, so every deny rule above (all under ~/.config) stopped short of it and a worker on a
+// runner device could read the runner's login.
+const hostProgram = require('../scripts/bongos/autobongos-host.js');
+const RUNNER_RULE = 'Read(~/.cloudbongos-runner/config/**)';
+
+t('the runner deny rule names the folder the device program actually uses, however the runner was installed', () => {
+  // Asked of the device program with a stand-in home, so a renamed folder fails HERE rather
+  // than leaving a rule that guards a place nothing writes to.
+  const home = join(tmpdir(), 'runner-deny-home');
+  const ruleFor = (env) => `Read(~/${relative(home, hostProgram.hostPaths(env, home).configRoot).split(sep).join('/')}/**)`;
+  assert.equal(ruleFor({}), RUNNER_RULE, 'the default install');
+  // AUTOBONGOS_HOME moves the runner's copy, logs and lock. It must NOT move the login:
+  // a login an environment variable can relocate is one the rule does not cover.
+  for (const custom of [join(home, 'elsewhere'), join(tmpdir(), 'not-even-under-home'), join(home, '.cloudbongos-runner')]) {
+    const env = { AUTOBONGOS_HOME: custom };
+    assert.equal(ruleFor(env), RUNNER_RULE, `AUTOBONGOS_HOME=${custom}`);
+    assert.equal(hostProgram.hostPaths(env, home).root, custom, 'while the rest of the runner does move');
+  }
+});
+
+t('the runner deny rule covers the files a runner keeps there: its session, the store, its heartbeat', () => {
+  // The same cli-lib and supervisor a runner runs, under the runner's config root.
+  const home = join(tmpdir(), 'runner-deny-home');
+  const root = hostProgram.hostPaths({}, home).configRoot;
+  const probe = `
+    const cli = require(${JSON.stringify(join(ROOT, 'scripts', 'bongos', 'cli-lib.js'))});
+    const run = require(${JSON.stringify(join(ROOT, 'scripts', 'bongos', 'autobongos-run.js'))});
+    process.stdout.write(JSON.stringify([...cli.SESSION_READ_PATHS, cli.sessionStoreDir(), run.heartbeatPath(), run.logPath()]));`;
+  const r = require('node:child_process').spawnSync(process.execPath, ['-e', probe], { encoding: 'utf8', env: { ...process.env, BONGOS_CONFIG_ROOT: root, AUTOBONGOS_HEARTBEAT_FILE: '', AUTOBONGOS_LOG_FILE: '' } });
+  assert.equal(r.status, 0, r.stderr);
+  const files = JSON.parse(r.stdout);
+  assert.ok(files.length >= 5);
+  const guarded = `${root}${sep}`;   // what Read(<root>/**) matches
+  for (const f of files) assert.ok(f.startsWith(guarded), `${f} sits outside the denied folder`);
+});
+
+t("the core's own deny list and the starter both carry the runner rule", () => {
+  const core = JSON.parse(readFileSync(join(ROOT, '.claude', 'settings.json'), 'utf8')).permissions.deny;
+  assert.ok(core.includes(RUNNER_RULE), 'the core checkout is itself where a runner works');
+  assert.ok(starterDenyFor({}).includes(RUNNER_RULE));
+  assert.ok(starterDenyFor({ configDir: 'acme', envPrefix: 'ACME' }).includes(RUNNER_RULE), 'at the same fixed place whatever the instance is called');
+});
+
+t('a checkout-materialized instance keeps the runner rule at its fixed place through the rebrand', () => {
+  // An instance whose own name is the word in the folder's name: the rebrand must not
+  // carry the rule off to a folder no runner uses.
+  for (const branding of [{ configDir: 'acme', envPrefix: 'ACME' }, { configDir: 'cloudbongos' }, { configDir: 'otb', envPrefix: 'OTB' }]) {
+    const core = mkdtempSync(join(tmpdir(), 'w3-runner-core-'));
+    const inst = mkdtempSync(join(tmpdir(), 'w3-runner-inst-'));
+    mkdirSync(join(core, '.claude', 'skills'), { recursive: true });
+    writeFileSync(join(core, '.claude', 'settings.json'), JSON.stringify({ permissions: { deny: [RUNNER_RULE] } }));
+    mkdirSync(join(inst, 'config'), { recursive: true });
+    writeFileSync(join(inst, 'config', 'branding.json'), JSON.stringify(branding));
+    m.materializeClaude({ coreRoot: core, instanceDir: inst, dryRun: false });
+    const deny = JSON.parse(readFileSync(join(inst, '.claude', 'settings.json'), 'utf8')).permissions.deny;
+    assert.deepEqual(deny, [RUNNER_RULE], JSON.stringify(branding));
+    rmSync(core, { recursive: true, force: true });
+    rmSync(inst, { recursive: true, force: true });
+  }
+});
+
 t('a checkout-materialized instance keeps the session-store rule at its fixed anchor', () => {
   // The rebrand rewrites every `.config/<core dir>` literal, and the store's dir is one of them —
   // but the store does not move with the brand, so a rebranded rule guards a dir nothing reads.
@@ -1011,6 +1074,17 @@ t('an instance still on the allow-only starter GAINS the deny rules on its next
   f.cleanup();
 });
 
+t('an instance that already has a deny list gains the runner rule at its next upgrade (task 1005186)', () => {
+  // Every rule it had before this task, and not the new one.
+  const had = topUpDenyFor({ configDir: 'acme' }).filter((r) => r !== RUNNER_RULE);
+  const f = topUpFixture({ permissions: { allow: m.STARTER_ALLOW, deny: had } });
+  const res = m.materializeClaude({ coreRoot: f.core, instanceDir: f.inst, dryRun: false });
+  const after = JSON.parse(f.read());
+  assert.deepEqual(res.settingsDenyAdded, [RUNNER_RULE], 'the one rule it was missing, and it is named');
+  assert.deepEqual(after.permissions.deny, [...had, RUNNER_RULE], 'appended; nothing it had is moved or dropped');
+  f.cleanup();
+});
+
 t("an owner-edited settings.json keeps every rule of its own and only gains what's missing", () => {
   const f = topUpFixture({
     permissions: { allow: ['Bash(npm test:*)'], deny: ['Read(secrets/**)', 'Read(**/*.pem)'], ask: ['Bash(rm:*)'] },