@bongos/core 1.21.13 → 1.21.14

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.21.13",
-  "core_contract": "1.21.13",
-  "source_commit": "a9ae955060881e54339da9d9cfb1cb1fa7d25671",
+  "core_version": "1.21.14",
+  "core_contract": "1.21.14",
+  "source_commit": "1ce8d85952de7169b5f672c8c3e3a8055431aaab",
   "source_ref": "HEAD",
-  "built_at": "2026-10-02T19:22:55.678Z",
+  "built_at": "2026-10-02T19:42:26.201Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 579,
     "agent_docs_stubbed": 27,
-    "functional_verbatim": 2891,
+    "functional_verbatim": 2892,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 3498,
-  "tree_sha256": "1910703098217bf699609725a8605efbdcadc7aa035383cc6431a1c671e63734",
+  "file_count": 3499,
+  "tree_sha256": "87469b136b4b8c01e2b74045f76630dcad52edff25e8394663c1428642244179",
   "files": [
     {
       "path": ".claude/skills/ask-for-help/SKILL.md",
@@ -2827,7 +2827,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "b89b2eeef341e48e5bf816a53f97a91ac52317b14285a6e76af85a78bd079171"
+      "sha256": "79c94a7687066e362f87810166929b406808b1f36b04b894a0e3c0a0306e7dd2"
     },
     {
       "path": "docs/modules-contract.md",
@@ -4152,7 +4152,7 @@
     {
       "path": "modules/autonomy/fence.js",
       "mode": "0000644",
-      "sha256": "9b320bd16414a0af957ee2a62f559cdd63cc196eceac7bcb9dca207547ed3606"
+      "sha256": "5c293c02e1c112185aaf3ed3d731a1d9c938d574624acae0b7e58d575a2f30d1"
     },
     {
       "path": "modules/autonomy/gauge.js",
@@ -9762,12 +9762,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "c7e6e6a89d48813975d7054be141a240197bbc5b045cf65fa41334311e639bc7"
+      "sha256": "c24ae3bb13ec063dd4ec47e93690119c9d45bcaf1cd325ebc208809185d2245b"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "350bbabd5dd0fe70a82ca0dc837802afc1e0707ef5b3d6930ce5dba7e3511ee7"
+      "sha256": "5372bf5df4e17254670021fbe8be6e7ef84fe6aa6c0051d79104f9707362635f"
     },
     {
       "path": "public-docs/index.html",
@@ -9787,7 +9787,7 @@
     {
       "path": "release-notes.json",
       "mode": "0000644",
-      "sha256": "020aad6b4b6684d47f115dd18cf1a41142f295eb94929bc290e7fb468699a0f3"
+      "sha256": "6f1ec4627d1a643864c27dbd4e06125c992d1e97a69738b101f149448d36dd8e"
     },
     {
       "path": "scripts/bongos-mcp.js",
@@ -9952,7 +9952,7 @@
     {
       "path": "scripts/gds/autobongos-run.js",
       "mode": "0000644",
-      "sha256": "8fec3f44a9c19413efe549f0175e3568f614f9f31d885b43699475264480054f"
+      "sha256": "6c945bd585134f13e972f07225d8522c1ea045f77cffeb788e751377064d3166"
     },
     {
       "path": "scripts/gds/autobongos-service.cmd",
@@ -12012,7 +12012,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "40026259cc69c051470e03bde81e78b1daf4aaf7c336010ca85d11dd3103e352"
+      "sha256": "b1eadcb18331e93e9877413504297e502bbd495fbb8294c4864df896e16e6649"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -12479,6 +12479,11 @@
       "mode": "0000644",
       "sha256": "f750e0978dc811420e61ac2ae7be4abd896631447c47004b1ab662e742ec3ac3"
     },
+    {
+      "path": "tests/autobongos_host_access.mjs",
+      "mode": "0000644",
+      "sha256": "49c40df38ea622fc5adbb2128619f75b808694a309180cc5ab200c1f2b8387f4"
+    },
     {
       "path": "tests/autobongos_loop.mjs",
       "mode": "0000644",

package/docs/module-api-changelog.md

@@ -2853,5 +2853,7 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.21.11 with no explicit bump. run 37051031732. (task 1002620)
   1.21.13 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.21.12 with no explicit bump. run 37053665960. (task 1002620)
+  1.21.14 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.21.13 with no explicit bump. run 37055782677. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/modules/autonomy/fence.js

@@ -48,6 +48,7 @@ const REFUSALS = {
   no_allowlist: 'no goal is allowlisted, so there is nothing this runner may work on',
   goal_not_allowlisted: 'that goal is not on the allowlist',
   protected_path: 'the task declares work on a permission, migration, infrastructure or deploy-pipeline surface',
+  needs_host_access: 'the work needs shell access to a live host (SSH, root, systemd) that the runner machine does not have',
   grader_unavailable: 'the grader is bypassed, and it is the only review between an unattended worker and main',
   not_permitted: 'your rank does not hold autonomy.run, so your runner may not work on this project',
   builder_paused: 'the owner paused your runner',
@@ -247,6 +248,82 @@ function decideRun({ fence: rawFence, requestedGoals = [], graderBypassed = null
   return { go: true, goals, priorityGoal, refusedGoals: refused, code: null, reason: null };
 }
 
+// needsHostAccess — can this task only be done ON a live host? (task 1004537)
+//
+// The runner machine holds no SSH key, no root and no service environment for any
+// live droplet (ADR 0031 §6, ADR 0055), so a task whose work is "edit the unit on
+// the droplet" is one it can only claim, fail and hand back as an owner blocker.
+// Tasks 1003969 and 1003980 did exactly that three times between them.
+//
+// TWO SIGNALS, in a fixed order:
+//
+//   1. THE EXPLICIT TAG, which wins both ways. `automation_tag` already carries a
+//      'live-only' value (migration 003, the claimable views' fit rules): it
+//      refuses with no text needed. 'overnight-safe' is the owner saying "an
+//      unattended session may do this", and it silences the text rule below — so
+//      a false positive costs one PATCH, not a task the runner refuses forever.
+//
+//   2. THE TEXT, when the tag says nothing. Neither real task carried a tag (nor
+//      touches[] on a host path — 1003980 has none; nor a manual_degree), so an
+//      explicit-only rule would have skipped neither of the two shapes this exists
+//      for. The phrases are OPERATIONS on a host, never the nouns: "a droplet" is
+//      code about the DigitalOcean API, "on the production droplet" or
+//      "sudo systemctl restart" is work done there. Each match is returned, so the
+//      skip row can say which phrase refused the task.
+//
+//      ONE MENTION IS NOT ENOUGH; it takes HOST_ACCESS_MIN_SIGNALS distinct
+//      phrases. Measured against the 150 ready tasks on 2026-10-02, a single hit
+//      was a code task describing the box in passing ("the owner's only route is
+//      ssh ... systemctl restart", "a manual fix already applied on the live box")
+//      as often as it was host work. Both real shapes carry three or more. A
+//      host task described in one phrase is missed and costs one claim; the
+//      'live-only' tag is the fix for it, and the skip row names the phrases so a
+//      false positive is visible too.
+//
+// manual_degree is NOT a signal: it is null on most rows and the views read null
+// as 5, so using it would refuse nearly everything; and a high degree says a task
+// is human-heavy, not that it is host-bound.
+const HOST_ACCESS_PATTERNS = [
+  /\/etc\/(?:systemd|caddy|nginx|cron)\b/i,                                   // host config files
+  /\bsudo\s+(?:systemctl|journalctl|-u\b|cp|mv|tee|install|chown|chmod|rm|nano|vim?)\b/i,
+  /\bsystemctl\s+(?:daemon-reload|restart|start|stop|enable|disable|edit)\b/i,
+  /\b(?:root|via)\s+ssh\b/i,
+  /\bssh\s+(?:to|into|onto|in\s+to)\b/i,
+  /\b(?:on|onto|to|from)\s+the\s+(?:old|live|production|prod|control-plane|co-hosting|remote)\s+(?:droplet|box|host|server)s?\b/i,
+  /\blive\s+(?:droplet|box|host|server)(?:es|s)?\b/i,
+];
+const HOST_ACCESS_MIN_SIGNALS = 2;
+
+// Every match of every pattern, overlapping ones merged into one span, so
+// "on the live box" (two patterns, one phrase) counts once.
+function hostAccessSpans(text) {
+  const hits = [];
+  for (const re of HOST_ACCESS_PATTERNS) {
+    const g = new RegExp(re.source, 'gi');
+    let m;
+    while ((m = g.exec(text))) hits.push({ start: m.index, end: m.index + m[0].length, text: m[0] });
+  }
+  hits.sort((a, b) => a.start - b.start || b.end - a.end);
+  const spans = [];
+  for (const h of hits) {
+    const last = spans[spans.length - 1];
+    if (last && h.start < last.end) { last.end = Math.max(last.end, h.end); continue; }
+    spans.push({ ...h });
+  }
+  return spans;
+}
+
+function needsHostAccess(task) {
+  if (!task || typeof task !== 'object') return { needs: false, source: null, signals: [] };
+  const tag = task.automation_tag;
+  if (tag === 'live-only') return { needs: true, source: 'automation_tag', signals: ["automation_tag 'live-only'"] };
+  if (tag === 'overnight-safe') return { needs: false, source: 'automation_tag', signals: [] };
+  const spans = hostAccessSpans(`${task.title || ''}\n${task.description || ''}`);
+  const signals = [...new Set(spans.map((s) => s.text.replace(/\s+/g, ' ').toLowerCase()))];
+  if (spans.length < HOST_ACCESS_MIN_SIGNALS) return { needs: false, source: null, signals };
+  return { needs: true, source: 'text', signals };
+}
+
 // decideTask — may THIS task be handed to an unattended worker?
 //
 // `protectedHits` is the output of the ADR 0043 registry matcher run over the
@@ -273,7 +350,15 @@ function decideTask({ task, goals = [], protectedHits = [] } = {}) {
       globs,
     };
   }
+  const host = needsHostAccess(task);
+  if (host.needs) {
+    return {
+      go: false, code: 'needs_host_access',
+      reason: `${REFUSALS.needs_host_access} (${host.signals.join('; ')})`,
+      signals: host.signals,
+    };
+  }
   return { go: true, code: null, reason: null };
 }
 
-module.exports = { REFUSALS, normaliseFence, prioritise, allowedGoals, effectiveFence, decideRun, decideTask };
+module.exports = { REFUSALS, HOST_ACCESS_PATTERNS, HOST_ACCESS_MIN_SIGNALS, normaliseFence, prioritise, allowedGoals, effectiveFence, decideRun, decideTask, needsHostAccess };

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.13",
+  "version": "1.21.14",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.21.13",
+      "version": "1.21.14",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.13",
+  "version": "1.21.14",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -8834,5 +8834,11 @@
       "id": "1004528",
       "text": "On the street, a pin now opens the full matter card: who raised it in their own words, exactly what would change, who has voted and what it still needs, the objections, and a short note of advice. Governors can vote for, objec"
     }
+  ],
+  "1.21.14": [
+    {
+      "id": "1004537",
+      "text": "Autobongos no longer picks tasks that can only be done by logging into a live server. They are skipped before any claim and listed as \"needs_host_access\", so no more wasted runs and pointless owner blockers."
+    }
   ]
 }

package/scripts/gds/autobongos-run.js

@@ -207,10 +207,22 @@ async function pickTask(goals, deps = {}) {
     // AFTER ordering, so a dependent of one is still halted by its own unmet
     // dependency rather than promoted by the task's absence.
     const exclude = deps.exclude || null;
-    const open = exclude && exclude.size ? order.filter((t) => !exclude.has(String(t.id))) : order;
+    const unexcluded = exclude && exclude.size ? order.filter((t) => !exclude.has(String(t.id))) : order;
+    // Work this machine structurally cannot do — SSH, root, systemd on a live
+    // host (task 1004537) — is skipped BEFORE the claim, and listed with its
+    // reason. It is decided here and not in sequence.js's matrix because the
+    // matrix also serves /builder-sequence, where the builder may well hold the
+    // host access an unattended runner never has.
+    const hostSkipped = [];
+    const open = unexcluded.filter((t) => {
+      const host = fence.needsHostAccess(t);
+      if (!host.needs) return true;
+      hostSkipped.push({ id: t.id, title: t.title, reasons: [{ code: 'needs_host_access', detail: `${fence.REFUSALS.needs_host_access} (${host.signals.join('; ')})` }] });
+      return false;
+    });
     const { next, skipped } = seq.pickNext(open, { rank, claimableIds });
-    if (next) return { task: next, goalId, skipped };
-    for (const sk of skipped) allSkipped.push({ ...sk, goal_id: goalId });
+    if (next) return { task: next, goalId, skipped: [...hostSkipped, ...skipped] };
+    for (const sk of [...hostSkipped, ...skipped]) allSkipped.push({ ...sk, goal_id: goalId });
   }
   return { none: true, skipped: allSkipped };
 }

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.21.13'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.14'; // 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

@@ -0,0 +1,176 @@
+// tests/autobongos_host_access.mjs — the runner skips work it structurally
+// cannot do (task 1004537).
+//
+// The runner machine holds no SSH key, no root and no service environment for a
+// live droplet (ADR 0031 §6 / ADR 0055). Tasks 1003969 and 1003980 were still
+// picked, three times between them, and each run burned a claim and filed an
+// owner blocker saying the work was never doable there. These tests hold the
+// fence that stops that: a host-access task is SKIPPED, before any claim, with
+// the reason `needs_host_access` in nothing_claimable's skipped[], and an
+// ordinary code task beside it is still picked.
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+
+const require = createRequire(import.meta.url);
+const fence = require('../modules/autonomy/fence.js');
+const runner = require('../scripts/gds/autobongos-run.js');
+
+const { needsHostAccess, decideTask } = fence;
+
+// The two real shapes, excerpted from their task rows (touches, tags and
+// manual_degree exactly as they were: nothing explicit marked either one).
+const T1003969 = {
+  id: 1003969, goal_id: 1000119, kind: 'bug', status: 'ready', requires_rank: 'xenos',
+  touches: ['docs/recipes/upgrading-the-core.md'], manual_degree: null, automation_tag: null,
+  title: 'Install the core-update-subscription timer at the declared 15min cadence on the cloudbongos.com control plane',
+  description: [
+    'WHAT REMAINS (host state, not in this repo): the systemd unit lives on the droplet.',
+    '/etc/systemd/system/cloudbongos-core-update-subscription.timer is still OnCalendar=daily with RandomizedDelaySec=1800. Change it to:',
+    '    OnCalendar=*:0/15',
+    'then `sudo systemctl daemon-reload && sudo systemctl restart cloudbongos-core-update-subscription.timer`',
+  ].join('\n'),
+};
+const T1003980 = {
+  id: 1003980, goal_id: 1000119, kind: 'bug', status: 'ready', requires_rank: 'xenos',
+  touches: [], manual_degree: null, automation_tag: null,
+  title: 'Recover the five lost bug-attachment screenshots from the co-hosting box, or accept the loss on the record',
+  description: [
+    'WHAT IS LEFT. ADR 0126 kept the old co-hosting droplet as a rollback net after the 2026-07-05 move.',
+    'If its var/bug-attachments survived, the five files are recoverable by copying them onto the control-plane droplet at BUG_ATTACHMENTS_DIR.',
+    'WHY IT IS A SEPARATE ROW. It needs an interactive session on two live boxes - look for var/bug-attachments on the old droplet,',
+    'copy across, set BUG_ATTACHMENTS_DIR in the service environment, confirm the probe goes green.',
+    'DONE WHEN: either the audit reports zero missing, or the files are confirmed unrecoverable.',
+  ].join('\n'),
+};
+const CODE_TASK = {
+  id: 9002, goal_id: 1000119, kind: 'feature', status: 'ready', requires_rank: 'xenos',
+  touches: ['scripts/gds/sequence.js'], manual_degree: null, automation_tag: null,
+  title: 'Teach the picker a new halt reason',
+  description: 'Add a halt reason to scripts/gds/sequence.js and cover it with a tests/*.mjs case. '.repeat(4)
+    + 'DONE WHEN: the new case passes and the old ones still do.',
+};
+
+// ── the predicate ───────────────────────────────────────────────────────────────
+
+test('the 1003969 shape (systemd unit edited on the droplet via sudo) needs host access', () => {
+  const d = needsHostAccess(T1003969);
+  assert.equal(d.needs, true);
+  assert.equal(d.source, 'text');
+  assert.ok(d.signals.length, 'the matched phrase is named, so a false positive can be seen and overridden');
+});
+
+test('the 1003980 shape (copying files between two live boxes) needs host access', () => {
+  const d = needsHostAccess(T1003980);
+  assert.equal(d.needs, true);
+  assert.equal(d.source, 'text');
+});
+
+test('an ordinary code task does not', () => {
+  assert.equal(needsHostAccess(CODE_TASK).needs, false);
+});
+
+test("the explicit tag wins both ways: 'live-only' skips with no text, 'overnight-safe' overrides the text", () => {
+  const tagged = needsHostAccess({ ...CODE_TASK, automation_tag: 'live-only' });
+  assert.equal(tagged.needs, true);
+  assert.equal(tagged.source, 'automation_tag');
+  // An owner who reads the reason and disagrees marks the task safe; the phrase
+  // match must then stay quiet rather than refuse forever.
+  assert.equal(needsHostAccess({ ...T1003969, automation_tag: 'overnight-safe' }).needs, false);
+});
+
+test('code that merely talks ABOUT droplets is not mistaken for work ON one', () => {
+  const t = { ...CODE_TASK, description: 'The DigitalOcean droplet-create call in modules/box/do-client.js leaks a droplet when the API blips. Fix the retry so no droplet is orphaned. '.repeat(2) };
+  assert.equal(needsHostAccess(t).needs, false);
+});
+
+test('one passing mention of the box does not refuse a code task (the task 1004463 shape)', () => {
+  // A real ready task on 2026-10-02: a code fix whose description quotes the
+  // owner's current workaround. One phrase is description, not the work.
+  const t = { ...CODE_TASK, description: `${CODE_TASK.description} Today the owner's only route is \`ssh cloudbongos 'systemctl restart cloudbongos'\`; the hall should do it instead.` };
+  const d = needsHostAccess(t);
+  assert.equal(d.needs, false);
+  assert.deepEqual(d.signals, ['systemctl restart'], 'the lone phrase is still reported, so the threshold is visible');
+  // The same phrase twice over, as in the two real shapes, does refuse.
+  const twice = { ...t, description: `${t.description} Then sudo systemctl daemon-reload on the production droplet.` };
+  assert.equal(needsHostAccess(twice).needs, true);
+});
+
+test('a missing task is not a host-access task (decideTask refuses it on its own)', () => {
+  assert.equal(needsHostAccess(null).needs, false);
+});
+
+// ── decideTask refuses it, like protected_path ─────────────────────────────────
+
+test('decideTask refuses a host-access task with code needs_host_access', () => {
+  const d = decideTask({ task: T1003969, goals: [1000119], protectedHits: [] });
+  assert.equal(d.go, false);
+  assert.equal(d.code, 'needs_host_access');
+  assert.match(d.reason, /live host/);
+  assert.equal(decideTask({ task: CODE_TASK, goals: [1000119], protectedHits: [] }).go, true);
+});
+
+// ── the picker: skipped with a reason, and the code task behind it is picked ───
+
+function fakeApi(tasks, claimable) {
+  return {
+    me: { getMe: async () => ({ ok: true, data: { builder: { rank: 'archon' } } }) },
+    tasks: {
+      getTasks: async ({ query }) => ({ ok: true, data: { tasks: query.offset ? [] : tasks } }),
+      getTasksId: async ({ id }) => {
+        const t = tasks.find((x) => Number(x.id) === Number(id));
+        return t ? { ok: true, data: { task: { dependencies: [], dependents: [], ...t } } } : { ok: false };
+      },
+      getTasksClaimable: async () => ({ ok: true, data: { claimable: claimable.map((id) => ({ id })) } }),
+    },
+  };
+}
+
+test('pickTask walks past the host-access tasks to the code task behind them', async () => {
+  const api = fakeApi([T1003969, T1003980, CODE_TASK], [1003969, 1003980, 9002]);
+  const got = await runner.pickTask([1000119], { api, rank: 'archon' });
+  assert.equal(got.task && got.task.id, 9002, 'an ordinary code task is still picked');
+});
+
+test('when only host-access tasks are left, they appear in skipped[] as needs_host_access', async () => {
+  const api = fakeApi([T1003969, T1003980], [1003969, 1003980]);
+  const got = await runner.pickTask([1000119], { api, rank: 'archon' });
+  assert.equal(got.none, true, 'no claim is made on work the machine cannot do');
+  const byId = new Map(got.skipped.map((s) => [Number(s.id), s]));
+  for (const id of [1003969, 1003980]) {
+    const sk = byId.get(id);
+    assert.ok(sk, `task ${id} must be listed, not silently vanish`);
+    assert.ok(sk.reasons.some((r) => r.code === 'needs_host_access'), `task ${id} carries the reason`);
+    assert.equal(sk.goal_id, 1000119);
+  }
+});
+
+test('the nothing_claimable row the iteration writes carries needs_host_access', async () => {
+  const api = fakeApi([T1003969], [1003969]);
+  let claimed = false;
+  const row = await runner.iteration({ goals: [1000119] }, {
+    readFence: async () => ({ raw: { enabled: true, paused_reason: null, goals: [{ goal_id: 1000119 }] }, graderBypassed: false }),
+    gauge: () => ({ decision: { go: true, unknown: false, sleepUntil: null, reason: 'headroom' } }),
+    state: runner.newRunnerState(),
+    pickTask: (goals, d) => runner.pickTask(goals, { ...d, api, rank: 'archon' }),
+    run: async () => { claimed = true; return { ok: true, code: 0, stdout: '', stderr: '' }; },
+    // Inert stand-ins, so a regression that DOES pick the task fails this test
+    // without spawning a real worker or writing to a real ledger.
+    spawnWorker: async () => { claimed = true; return { code: 0, envelope: null, stdout: '', stderr: '' }; },
+    worktreeName: () => 'autobongos-test-host-access',
+    gradeLedgerPath: () => path.join(os.tmpdir(), `autobongos-host-access-${process.pid}.jsonl`),
+    api,
+    verifyDeps: {
+      task: { id: 1003969, status: 'shipped', updated_at: new Date().toISOString() },
+      probeArtifact: async () => ({ checked: true, onMain: true, sha: 'a'.repeat(40), subject: 'x' }),
+      fileBlocker: async () => ({ filed: false }),
+    },
+    record: (r) => r,
+  });
+  assert.equal(row.event, 'nothing_claimable');
+  assert.equal(claimed, false, 'no worktree is made and no claim is attempted');
+  assert.deepEqual(row.skipped, [{ id: 1003969, goal_id: 1000119, reasons: ['needs_host_access'] }]);
+});