@bongos/core 1.21.112 → 1.21.113

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.21.112",
-  "core_contract": "1.21.112",
-  "source_commit": "20d2e0bfe68101dc84b13e8322b6c1dd35abcfe3",
+  "core_version": "1.21.113",
+  "core_contract": "1.21.113",
+  "source_commit": "083632759dcd4d0b7a640009d2fd5b6e02e88e8c",
   "source_ref": "HEAD",
-  "built_at": "2026-10-09T17:32:18.946Z",
+  "built_at": "2026-10-09T17:43:10.621Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 592,
     "agent_docs_stubbed": 28,
-    "functional_verbatim": 3036,
+    "functional_verbatim": 3038,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 3657,
-  "tree_sha256": "8fb96168c1321372e872219e26f508d99b040b9ebce4ce6ca17e482c0216c0a0",
+  "file_count": 3659,
+  "tree_sha256": "1fff5d0d8056ffebe50dfbd2b871d4e2f2c2c83e0566e32ce426390de0388a50",
   "files": [
     {
       "path": ".claude/skills/ask-for-help/SKILL.md",
@@ -2872,7 +2872,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "c7506ded99bfae21631034eaeda8c97b705dc16fe06bbf4e2419a257f578f755"
+      "sha256": "a3bef3c5acf2212482d2e29929d92f5ef3738e9b739c7e31f6c37ba4701a7253"
     },
     {
       "path": "docs/modules-contract.md",
@@ -10172,12 +10172,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "c0b56b64fd6deff145189d27a3aec0713132b1112d2545617719ee5d29f5e714"
+      "sha256": "826f2bbfa8798f0561784c494f5794b9dc1781c930687cee51920e17f1f11bf4"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "3093047c8006d903bd5348bba1b43d9cd99f8dfd9ed19bb1575c8c92035a16b0"
+      "sha256": "3defe7b0c206cd3c9433361f12186de2ce84a0ed7b652a82abe285e74d95dc52"
     },
     {
       "path": "public-docs/index.html",
@@ -10197,7 +10197,7 @@
     {
       "path": "release-notes.json",
       "mode": "0000644",
-      "sha256": "15e75913ea8e573944116d52fe5e44135ca7be4bc7a338cb6ee7d36f4b2a44d3"
+      "sha256": "bf1eda9f678bc9322ef19422a006bfef706f36065e1393c4a2337a9b611279c0"
     },
     {
       "path": "scripts/cron/style_guide_audit.sh",
@@ -10357,7 +10357,7 @@
     {
       "path": "scripts/gds/autobongos-run.js",
       "mode": "0000644",
-      "sha256": "6c945bd585134f13e972f07225d8522c1ea045f77cffeb788e751377064d3166"
+      "sha256": "96022e88a705b3d3e6a7da77e51a1ccc8c3c590058a18605d785e1dcf2a23986"
     },
     {
       "path": "scripts/gds/autobongos-service.cmd",
@@ -10369,6 +10369,11 @@
       "mode": "0000644",
       "sha256": "b1e038bb70ace1652b85a4d29f5a68761c6b432fd50fbfdafb5e1e38d93627de"
     },
+    {
+      "path": "scripts/gds/autobongos-tweak-lane.js",
+      "mode": "0000644",
+      "sha256": "7dfe043c33b6a050d6e3fbd8912fa35775beed4f6d7da1d46a0147d226e2e6b5"
+    },
     {
       "path": "scripts/gds/autobongos-verify.js",
       "mode": "0000644",
@@ -10497,7 +10502,7 @@
     {
       "path": "scripts/gds/claim.js",
       "mode": "0000644",
-      "sha256": "77c5d63df2ba881c11e184f11e7972527bac310d856a82d0d7cd234de514665c"
+      "sha256": "b8f83e685d6e237da18a38cc50916ce76832e6638de1782fb8cfe5b4b9c04e3d"
     },
     {
       "path": "scripts/gds/classify-discipline.js",
@@ -11887,7 +11892,7 @@
     {
       "path": "scripts/gds/tweak-halt.js",
       "mode": "0000644",
-      "sha256": "df5fa45f622f59d7867295afc559d334807a31e732b16a1c869305d3033fb9a3"
+      "sha256": "3b521b4055e6a851dc64f4151dca4ff75231d85df930360df785d695207807dc"
     },
     {
       "path": "scripts/gds/tweak-renders.js",
@@ -12482,7 +12487,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "a59fd4faf5376d371522507f8d01e336f655e2871ca2b4409f59606cccdfa28f"
+      "sha256": "0100b0bd0d67196146680d7be8a0f67430d013fe57af2642906d708ec2599983"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -12974,6 +12979,11 @@
       "mode": "0000644",
       "sha256": "34ca7d75bc83d9c4a77706dd06ecc170011ef52b7ee77eea5c3b77ac514389d0"
     },
+    {
+      "path": "tests/autobongos_tweak_lane.mjs",
+      "mode": "0000644",
+      "sha256": "c97a39cffaef5885e3cd48709cd879668cee228405de01f0be8615b85765548d"
+    },
     {
       "path": "tests/autobongos_verify.mjs",
       "mode": "0000644",

package/docs/module-api-changelog.md

@@ -3061,5 +3061,7 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.21.110 with no explicit bump. run 37965024171. (task 1002620)
   1.21.112 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.21.111 with no explicit bump. run 37966893511. (task 1002620)
+  1.21.113 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.21.112 with no explicit bump. run 37968179413. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.112",
+  "version": "1.21.113",
   "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

@@ -9530,5 +9530,11 @@
       "id": "1004669",
       "text": "The security record for the main branch now says what is actually true. It used to say anyone with access could push straight to the main code line. That stopped being true in August: now every change from a regular collaborat"
     }
+  ],
+  "1.21.113": [
+    {
+      "id": "1004679",
+      "text": "When a project turns automatic pickup on, the background runner now picks up the oldest page an artist submitted and applies it, before its other work, then leaves it waiting for the artist. It stops at the monthly limit, leav"
+    }
   ]
 }

package/scripts/gds/autobongos-run.js

@@ -45,6 +45,7 @@ const {
 const { verifyShip, failureReason, recheckLands, pendingLandIds } = require('./autobongos-verify.js');
 const gradeCap = require('./autobongos-grade-cap.js');
 const fence = require('../../modules/autonomy/fence.js');
+const tweakLane = require('./autobongos-tweak-lane.js');
 // The ADR 0043 protected-path registry, reused rather than re-derived. scripts/
 // sits outside the kernel boundary, so this direct core require is allowed here
 // where it would not be inside modules/ — which is exactly why fence.js takes the
@@ -346,13 +347,13 @@ async function gradeCapReader({ api, taskId, ledger }) {
 
 // spawnWorker — one headless session, bounded by WALL CLOCK, in the task's own
 // working tree.
-async function spawnWorker({ task, model, timeoutMs, cwd, gradeLedger = null, capCheck = null, deps = {} }) {
+async function spawnWorker({ task, model, timeoutMs, cwd, gradeLedger = null, capCheck = null, prompt: givenPrompt = null, deps = {} }) {
   const spawnFn = deps.spawn || spawn;
   const sessionId = deps.sessionId || crypto.randomUUID();   // pinned, so the session can be resumed
   const { bin, shell: workerShell } = deps.resolveBin ? deps.resolveBin() : resolveWorkerBin();
   const isRoot = typeof process.getuid === 'function' && process.getuid() === 0;
   const args = buildWorkerArgs({ sessionId, model, isRoot });
-  const prompt = buildWorkerPrompt({ task });
+  const prompt = givenPrompt || buildWorkerPrompt({ task });   // the tweak lane names its own (task 1004679)
 
   return new Promise((resolve) => {
     let child;
@@ -547,9 +548,13 @@ async function iteration(opts, deps = {}) {
   // always injected deps.run. Caught by the grader on task 1003908; the test that
   // now drives iteration() with no deps is the actual fix — this rename is half.
   const gate = fence.decideRun({ fence: raw, requestedGoals: opts.goals, graderBypassed });
-  if (!gate.go) {
-    return log({ event: 'fenced', code: gate.code, reason: gate.reason, refused_goals: gate.refusedGoals || [] });
-  }
+  // ADR 0371 D3 (task 1004679): the tweak lane's own setting replaces the GOAL
+  // ALLOWLIST for that lane only, so a fence that refused on goals alone still lets
+  // the lane run below; the kill switch and the grader stop refuse it here.
+  const fencedRow = () => log({ event: 'fenced', code: gate.code, reason: gate.reason, refused_goals: gate.refusedGoals || [] });
+  const goalsOnly = !gate.go && tweakLane.GOAL_ONLY_CODES.has(gate.code)
+    && await (deps.laneSwitchOn || tweakLane.laneSwitchOn)(deps.api);
+  if (!gate.go && !goalsOnly) return fencedRow();
 
   // 1. The gauge. Never start a task we cannot pay for out of the window.
   const g = readGauge();
@@ -588,6 +593,16 @@ async function iteration(opts, deps = {}) {
   }
   for (const [id, until] of state.setAside) if (until <= now) state.setAside.delete(id);
 
+  // 1d. THE TWEAK LANE (task 1004679, ADR 0371 D1): before ordinary work, the
+  // oldest submitted page round the lane may take. Null means it took none.
+  const laneRow = await (deps.tweakLaneStep || tweakLane.tweakLaneStep)({ opts, state }, {
+    api: deps.api || await (require('./cli-lib').cliClient)(), log, matchProtected, runCmd, spawnWork,
+    worktreeName: deps.worktreeName || worktreeName, spawnDeps: deps, gradeCapReader,
+    gradeLedgerPath: deps.gradeLedgerPath || gradeLedgerPath, ...(deps.laneDeps || {}),
+  });
+  if (laneRow) return laneRow;
+  if (goalsOnly) return fencedRow();
+
   // 2–4, up to MAX_CLAIM_ATTEMPTS times: pick, fence, tree, claim. A task refused
   // on its own is set aside and the NEXT one is tried in the same pass.
   let task = null; let picked = null; let wtName = null; let wtPath = null;

package/scripts/gds/autobongos-tweak-lane.js

@@ -0,0 +1,262 @@
+// scripts/gds/autobongos-tweak-lane.js — the Autobongos tweak lane: pick the
+// oldest submitted page round and hand it to a worker (task 1004679 / BV2.TW19c,
+// ADR 0371 D1, D2, D4, D6, D7).
+//
+// WHY. An artist who presses submit with nobody at a terminal waits forever. The
+// runner already wakes on a cadence, holds a fence and ships through the normal
+// grade, so the lane is a step INSIDE its iteration (D1), before ordinary work,
+// fed by the same derived state the studio shows (D2: open_round.state ===
+// 'submitted', oldest task id first). Everything a person's /tweak does still
+// happens; the worker runs `/tweak --page <id> --unattended` (task 1004678).
+//
+// THE RULES, each its own refusal so a run-log row can say which one held:
+//   lane_off            tweak.autopickup is off (D3) — the lane is silent
+//   lane_at_cap         this month's marked claims reached the cap (D5)
+//   lane_rank_too_low   the runner's builder is below Metic (D4) — reported ONCE
+//   round_waits_for_person  this runner already applied the round twice (D6.2)
+//   round_failed_unchanged  the last apply failed and the round has not moved (D6.3)
+//   page_unknown / protected_path / needs_host_access   the fence over the
+//                       PAGE'S files (D7) — the setting replaces only the goal
+//                       allowlist, so decideTask is asked with the round's own goal
+//
+// The server holds the cap, the per-round limit, the artist gate and the file
+// rule again (tasks 1004677, 1004678). This file is the runner not ASKING for
+// what would be refused, so a quiet machine does not spend a worker learning it.
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const fence = require('../../modules/autonomy/fence');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const LANE_RANK_FLOOR = 'metic';
+// D6.2, the same number the server refuses a third marked claim at.
+const MAX_AUTO_APPLIES_PER_ROUND = 2;
+const MAX_ROUNDS_READ_PER_PASS = 10;
+// The runner's own tree names (autobongos-run.js worktreeName). Restated rather
+// than required: requiring the runner here would be a cycle.
+const RUNNER_TREE_RE = /^autobongos-\d+-[0-9a-f]{6}$/;
+// The fence refusals that are about the goal allowlist and nothing else: the lane
+// runs past them (D3). The kill switch, a paused builder and the grader stop do not.
+const GOAL_ONLY_CODES = new Set(['goal_not_allowlisted', 'no_allowlist', 'no_builder_scope']);
+
+// ---- pure ------------------------------------------------------------------
+
+// The lane as a whole: may it try at all this pass?
+function decideLane({ settings, rank, state = {} }) {
+  if (!settings || typeof settings !== 'object') return { go: false, code: 'lane_unreadable', quiet: true, reason: 'could not read the tweak auto-pickup setting' };
+  if (settings.mode !== 'on') return { go: false, code: 'lane_off', quiet: true, reason: 'tweak auto-pickup is off for this project' };
+  const remaining = Number.isFinite(Number(settings.remaining_this_month))
+    ? Number(settings.remaining_this_month) : Number(settings.cap) - Number(settings.used_this_month);
+  if (!(remaining > 0)) return { go: false, code: 'lane_at_cap', reason: `this month's ${settings.cap} automatic page tweaks are used up — rounds wait for a person` };
+  const { RANK_TIER } = require('../../src/module-api'); // the one rank map (lazy: only when the lane is on)
+  if (!(RANK_TIER[rank] >= RANK_TIER[LANE_RANK_FLOOR])) {
+    const once = !state.laneRankReported;
+    state.laneRankReported = true;
+    return { go: false, code: 'lane_rank_too_low', quiet: !once, reason: `the runner's builder is ${rank || 'of unknown rank'}; applying a page tweak needs Metic or higher` };
+  }
+  return { go: true };
+}
+
+// The submitted rounds, oldest first (D2).
+function submittedRounds(pagesBody) {
+  const out = [];
+  for (const p of (pagesBody && pagesBody.pages) || []) {
+    const r = p && p.open_round;
+    if (r && r.state === 'submitted' && /^[1-9][0-9]*$/.test(String(r.task_id))) out.push({ pageId: p.id, taskId: String(r.task_id) });
+  }
+  return out.sort((a, b) => Number(a.taskId) - Number(b.taskId));
+}
+
+// How many times THIS runner applied the round: its claims from a runner tree.
+function autoAppliesByRunner(claims) {
+  return (claims || []).filter((c) => c && RUNNER_TREE_RE.test(String(c.worktree_name || ''))).length;
+}
+
+function pageFiles(inventory, pageId) {
+  const page = ((inventory && inventory.pages) || []).find((p) => p && p.id === pageId);
+  return page ? [...(page.files || []), ...(page.states_files || [])] : null;
+}
+
+// One round: may the lane take it?
+function decideRound({ task, claims, files, failedAt, matchProtected }) {
+  if (autoAppliesByRunner(claims) >= MAX_AUTO_APPLIES_PER_ROUND) {
+    return { go: false, code: 'round_waits_for_person', reason: `applied automatically ${MAX_AUTO_APPLIES_PER_ROUND} times already — waiting for a person` };
+  }
+  if (failedAt !== undefined && failedAt === task.updated_at) {
+    return { go: false, code: 'round_failed_unchanged', reason: 'the last automatic apply failed and the round has not changed since' };
+  }
+  if (!files || !files.length) return { go: false, code: 'page_unknown', reason: 'the page inventory does not list this page\'s files' };
+  return fence.decideTask({
+    task: { ...task, touches: files },
+    goals: task.goal_id == null ? [] : [task.goal_id],
+    protectedHits: matchProtected(files),
+  });
+}
+
+function buildTweakPrompt({ task, pageId }) {
+  return [
+    `You are an unattended Autobongos worker applying ONE page tweak: task ${task.id}, page ${pageId}.`,
+    'The round is already claimed in this worktree with the auto_pickup mark.',
+    `Read modules/copy-desk/skills/tweak/SKILL.md and follow its "Unattended mode" for: /tweak --page ${pageId} --unattended`,
+    'Never ask a question. On any halt, run the tweak-halt.js line the skill names and stop.',
+    'Never pass --skip-grade, --force or --allow-empty. Your finish line is WAITING FOR THE ARTIST.',
+  ].join('\n');
+}
+
+// After the worker: what the LEDGER says happened to the round. A held pass at
+// completed is the success; a released round is a halt (no blocker: the round
+// already carries its note, and D6.3 keeps the lane off it until it moves).
+function tweakOutcome({ task, grade }) {
+  const status = task && task.status;
+  if (status === 'completed' && grade && grade.passed === true) return { shape: 'waiting_for_artist', ok: true };
+  if (status === 'ready' || status === 'backlog') return { shape: 'tweak_halted', ok: false, failed: true };
+  return { shape: 'other', ok: false };
+}
+
+// ---- reads -----------------------------------------------------------------
+
+function readInventory(root = REPO_ROOT) {
+  return JSON.parse(fs.readFileSync(path.join(root, 'docs', 'page-inventory.json'), 'utf8'));
+}
+
+async function readRound(api, taskId) {
+  const r = await api.tasks.getTasksId({ id: Number(taskId), query: { include: 'claims,grade' } });
+  if (!r || !r.ok || !r.data || !r.data.task) return null;
+  return { task: r.data.task, claims: r.data.claims || [], grade: r.data.grade || null };
+}
+
+// pickRound — the lane's one call per iteration. Returns { round } to work,
+// or { none, code, reason, quiet?, skipped[] }.
+async function pickRound(deps) {
+  const { api, state, matchProtected } = deps;
+  let settings = null;
+  try { const r = await api.projectSettings.getProjectSettingsTweakAutopickup(); if (r && r.ok) settings = r.data; } catch (_) { /* unreadable */ }
+  let rank = deps.rank;
+  if (rank === undefined) {
+    try { const me = await api.me.getMe(); rank = me && me.ok ? me.data.builder?.rank : null; } catch (_) { rank = null; }
+  }
+  const lane = decideLane({ settings, rank, state });
+  if (!lane.go) return { none: true, ...lane, skipped: [] };
+
+  let pages = null;
+  try { const r = await api.copyDesk.getCopyDeskPages(); if (r && r.ok) pages = r.data; } catch (_) { /* unreadable */ }
+  if (!pages) return { none: true, code: 'lane_unreadable', reason: 'could not read the studio\'s page list', skipped: [] };
+  let inventory = null;
+  try { inventory = (deps.readInventory || readInventory)(); } catch (_) { inventory = null; }
+
+  const skipped = [];
+  const failed = state.tweakFailed || new Map();
+  // Bounded: a backlog of rounds the lane must skip costs at most this many reads a pass.
+  for (const { pageId, taskId } of submittedRounds(pages).slice(0, MAX_ROUNDS_READ_PER_PASS)) {
+    const round = await (deps.readRound || readRound)(api, taskId);
+    if (!round) { skipped.push({ id: taskId, page_id: pageId, code: 'round_unreadable' }); continue; }
+    const files = pageFiles(inventory, pageId);
+    const d = decideRound({ task: round.task, claims: round.claims, files, failedAt: failed.get(taskId), matchProtected });
+    if (!d.go) { skipped.push({ id: taskId, page_id: pageId, code: d.code }); continue; }
+    return { round: { task: round.task, pageId, files } };
+  }
+  return { none: true, code: 'lane_empty', quiet: true, reason: 'no submitted page round the lane may take', skipped };
+}
+
+// Is the lane's switch on? Asked only when the fence refused on goals alone, so a
+// runner with no allowlist and the lane off reports "fenced" exactly as before.
+// Unreadable answers no.
+async function laneSwitchOn(api) {
+  try {
+    const client = api || await (require('./cli-lib').cliClient)();
+    const r = await client.projectSettings.getProjectSettingsTweakAutopickup();
+    return !!(r && r.ok && r.data && r.data.mode === 'on');
+  } catch (_) { return false; }
+}
+
+// ---- the iteration step ----------------------------------------------------
+
+// The codes a lane refusal is logged under. A quiet one (off, nothing to do, the
+// rank refusal after its first report) writes no row, so an idle lane costs the
+// run log nothing.
+function laneRow(got) {
+  return { event: 'tweak_lane', code: got.code, reason: got.reason, skipped: got.skipped || [] };
+}
+
+// workRound — tree, marked claim, one worker, then the ledger. `d` carries the
+// runner's own helpers (runCmd, spawnWork, worktreeName, log, api) so this file
+// adds a lane, not a second way to run a worker.
+async function workRound({ round, opts, state }, d) {
+  const { task, pageId } = round;
+  const id = String(task.id);
+  const node = process.execPath;
+  const failedAt = async () => {
+    const after = await (d.readRound || readRound)(d.api, id).catch(() => null);
+    if (!state.tweakFailed) state.tweakFailed = new Map();
+    state.tweakFailed.set(id, after && after.task ? after.task.updated_at : task.updated_at);
+    return after;
+  };
+  const name = d.worktreeName(task.id);
+  const made = await d.runCmd(node, [path.join('scripts', 'gds', 'worktree.js'), 'add', name, '--base', 'origin/main']);
+  if (!made.ok) return d.log({ event: 'worktree_failed', lane: 'tweak', task_id: task.id, page_id: pageId, worktree: name });
+  const treePath = path.join(REPO_ROOT, '.claude', 'worktrees', name);
+  const claimed = await d.runCmd(node, [path.join(REPO_ROOT, 'scripts', 'gds', 'claim.js'), id, '--auto-pickup'], { cwd: treePath });
+  if (!claimed.ok) {
+    await d.runCmd(node, [path.join('scripts', 'gds', 'worktree.js'), 'remove', name]);
+    await failedAt();
+    return d.log({ event: 'claim_failed', lane: 'tweak', task_id: task.id, page_id: pageId, worktree: name, reason: String(claimed.stderr || claimed.stdout || '').slice(0, 400) });
+  }
+  const started = Date.now();
+  // The grade cap (task 1004536) holds here as on ordinary work: the run's own
+  // grade ledger, read after the worker, never the worker's word.
+  const gradeLedger = d.gradeLedgerPath ? d.gradeLedgerPath(task.id) : null;
+  const capCheck = d.gradeCapReader ? await d.gradeCapReader({ api: d.api, taskId: task.id, ledger: gradeLedger }) : null;
+  const res = await d.spawnWork({ task, model: opts.model, timeoutMs: opts.timeoutMs, cwd: treePath, gradeLedger, capCheck, prompt: buildTweakPrompt({ task, pageId }), deps: d.spawnDeps || {} });
+  const grades = capCheck ? await capCheck() : null;
+  if (gradeLedger) { try { fs.rmSync(gradeLedger, { force: true }); } catch (_) { /* its counts travel in the row */ } }
+  let after = await (d.readRound || readRound)(d.api, id).catch(() => null);
+  const capped = !!(grades && grades.exhausted);
+  if (after && after.task && (after.task.status === 'active' || (capped && after.task.status === 'completed' && !(after.grade && after.grade.passed === true)))) {
+    // Left held, or the grade cap reached: release with the fixed note (ADR 0371 D8).
+    await d.runCmd(node, [path.join(REPO_ROOT, 'scripts', 'gds', 'tweak-halt.js'), id, '--code', capped ? 'grade_failed' : 'worker_stopped'], { cwd: treePath });
+    after = await (d.readRound || readRound)(d.api, id).catch(() => null);
+  }
+  const out = after ? tweakOutcome(after) : { shape: 'unreadable', ok: false };
+  if (!out.ok) await failedAt();
+  return d.log({
+    event: 'worked', lane: 'tweak', task_id: task.id, title: task.title, page_id: pageId, worktree: name,
+    outcome: out.shape, ledger_status: after && after.task ? after.task.status : null,
+    ...(grades && (grades.graded || grades.outages) ? { grade_rounds: grades.graded, grade_outages: grades.outages, grade_cap_reached: capped } : {}),
+    session_id: (res && res.sessionId) || null, duration_s: Math.round((Date.now() - started) / 1000),
+    // A read that fails stops the run, as an unreadable ledger does for ordinary work.
+    ...(out.shape === 'unreadable' ? { event: 'verify_halt' } : {}),
+  });
+}
+
+// tweakLaneStep — the runner's call. Returns a run-log row when the lane did
+// something this pass (worked, refused a claim, dry run), else null and the
+// iteration goes on to ordinary work.
+async function tweakLaneStep({ opts, state }, d) {
+  const got = await (d.pickRound || pickRound)({ api: d.api, state, matchProtected: d.matchProtected, readInventory: d.readInventory, readRound: d.readRound, rank: d.rank });
+  if (got.none) {
+    if (!got.quiet) d.log(laneRow(got));
+    return null;
+  }
+  if (opts.dryRun) return d.log({ event: 'dry_run', lane: 'tweak', task_id: got.round.task.id, page_id: got.round.pageId });
+  return workRound({ round: got.round, opts, state }, d);
+}
+
+module.exports = {
+  GOAL_ONLY_CODES,
+  laneSwitchOn,
+  tweakLaneStep,
+  workRound,
+  MAX_AUTO_APPLIES_PER_ROUND,
+  LANE_RANK_FLOOR,
+  decideLane,
+  submittedRounds,
+  autoAppliesByRunner,
+  pageFiles,
+  decideRound,
+  buildTweakPrompt,
+  tweakOutcome,
+  readRound,
+  pickRound,
+};

package/scripts/gds/claim.js

@@ -606,6 +606,8 @@ async function main() {
       worktree_name: worktree,
       head_sha: headSha,
       enforce_touches: enforceTouches,
+      // --auto-pickup (task 1004679, ADR 0371 D5): the Autobongos tweak lane's mark.
+      ...(args.includes('--auto-pickup') ? { auto_pickup: true } : {}),
     },
   });
   let r = await postClaim();

package/scripts/gds/tweak-halt.js

@@ -29,6 +29,7 @@ const HALT_NOTES = Object.freeze({
   ship_check_stale: 'The automatic apply stopped because the pre-ship checks named something stale it may not fix by itself.',
   grader_unavailable: 'The quality review could not run, so the automatic apply stopped. The round waits for the next try or a person.',
   grade_failed: 'The quality review did not pass the automatic apply. The round waits for a person.',
+  worker_stopped: 'The automatic apply stopped before it finished, without saying why. The round waits for the next try or a person.',
   outside_page: 'The automatic apply would have changed a file outside this page, so it stopped.',
 });
 

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

@@ -0,0 +1,208 @@
+// tests/autobongos_tweak_lane.mjs — the Autobongos tweak lane (task 1004679 /
+// BV2.TW19c, ADR 0371 D1, D2, D4, D6, D7).
+//
+// The REAL picker (pickRound) and the REAL fence (modules/autonomy/fence.js +
+// the protected-path matcher) over a fake server, one fixture per rule: off, at
+// the cap, a protected page file, a round applied twice, a failed apply, a runner
+// below Metic. Then the REAL iteration(): a round is worked before ordinary work,
+// with a marked claim and the unattended prompt; with nothing for the lane, an
+// ordinary task is still picked; and a goal-only fence lets the lane run while the
+// kill switch and the grader stop do not.
+//
+// Run:  node --test tests/autobongos_tweak_lane.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const lane = require('../scripts/gds/autobongos-tweak-lane.js');
+const runner = require('../scripts/gds/autobongos-run.js');
+const { matchProtected } = require('../src/bongos/permission-path-check');
+
+const INV = { pages: [
+  { id: 'landing:index', files: ['modules/public-landing/public/index.html'], states_files: [] },
+  { id: 'landing:other', files: ['modules/public-landing/public/other.html'], states_files: [] },
+  { id: 'builders:core', files: ['CLAUDE.md'], states_files: [] },
+] };
+const ON = { mode: 'on', cap: 20, used_this_month: 3, remaining_this_month: 17 };
+const round = (id, over = {}) => ({ task: { id, title: `Tweak ${id}`, status: 'ready', source: 'page-tweak', goal_id: 1000095, description: 'Apply the round.', updated_at: 't1', ...over }, claims: [], grade: null });
+
+// A fake server: the setting, the page list, and each round's task + claims.
+function fakeApi({ settings = ON, rank = 'metic', pages, rounds = {} } = {}) {
+  return {
+    projectSettings: { getProjectSettingsTweakAutopickup: async () => (settings ? { ok: true, data: settings } : { ok: false }) },
+    me: { getMe: async () => ({ ok: true, data: { builder: { rank }, grader_bypass: false } }) },
+    copyDesk: { getCopyDeskPages: async () => ({ ok: true, data: { pages } }) },
+    tasks: { getTasksId: async ({ id }) => (rounds[id] ? { ok: true, data: { task: rounds[id].task, claims: rounds[id].claims, grade: rounds[id].grade } } : { ok: false }) },
+  };
+}
+const submitted = (id, taskId) => ({ id, open_round: { task_id: String(taskId), state: 'submitted' } });
+const pick = (api, state = {}) => lane.pickRound({ api, state, matchProtected, readInventory: () => INV });
+
+test('the oldest submitted round is picked, by task id, and only submitted ones', async () => {
+  const api = fakeApi({
+    pages: [submitted('landing:other', 902), submitted('landing:index', 901), { id: 'x:y', open_round: { task_id: '900', state: 'drafting' } }],
+    rounds: { 901: round(901), 902: round(902) },
+  });
+  const got = await pick(api);
+  assert.equal(got.round.task.id, 901);
+  assert.equal(got.round.pageId, 'landing:index');
+  assert.deepEqual(got.round.files, ['modules/public-landing/public/index.html'], 'the page\'s files are the touches');
+});
+
+test('OFF: the lane is silent and takes nothing', async () => {
+  const got = await pick(fakeApi({ settings: { ...ON, mode: 'off' }, pages: [submitted('landing:index', 901)], rounds: { 901: round(901) } }));
+  assert.equal(got.code, 'lane_off');
+  assert.equal(got.quiet, true);
+});
+
+test('AT THE CAP: refused, and it says the rounds wait for a person', async () => {
+  const got = await pick(fakeApi({ settings: { ...ON, used_this_month: 20, remaining_this_month: 0 }, pages: [submitted('landing:index', 901)], rounds: { 901: round(901) } }));
+  assert.equal(got.code, 'lane_at_cap');
+  assert.match(got.reason, /wait for a person/);
+});
+
+test('A PROTECTED PAGE FILE: the round is left for a person and the next one is taken', async () => {
+  const got = await pick(fakeApi({
+    pages: [submitted('builders:core', 900), submitted('landing:index', 901)],
+    rounds: { 900: round(900), 901: round(901) },
+  }));
+  assert.equal(got.round.task.id, 901);
+  const d = lane.decideRound({ task: round(900).task, claims: [], files: ['CLAUDE.md'], matchProtected });
+  assert.equal(d.code, 'protected_path', 'the fence\'s own refusal, over the page\'s files');
+});
+
+test('HOST ACCESS: the fence\'s host check runs on the round too', () => {
+  const t = { ...round(1).task, automation_tag: 'live-only' };
+  assert.equal(lane.decideRound({ task: t, claims: [], files: ['modules/public-landing/public/index.html'], matchProtected }).code, 'needs_host_access');
+});
+
+test('SENT BACK TWICE: after two applies by this runner the round waits for a person', async () => {
+  const runnerClaim = (n) => ({ worktree_name: `autobongos-901-${n}` });
+  const twice = round(901); twice.claims = [runnerClaim('aaaaaa'), runnerClaim('bbbbbb')];
+  const got = await pick(fakeApi({ pages: [submitted('landing:index', 901)], rounds: { 901: twice } }));
+  assert.equal(got.none, true);
+  assert.deepEqual(got.skipped.map((s) => s.code), ['round_waits_for_person']);
+  // A person's claims, or one runner apply, do not count against it.
+  const once = round(901); once.claims = [runnerClaim('aaaaaa'), { worktree_name: null }, { worktree_name: 'fix-copy-12ab' }];
+  assert.equal((await pick(fakeApi({ pages: [submitted('landing:index', 901)], rounds: { 901: once } }))).round.task.id, 901);
+});
+
+test('A FAILED APPLY: skipped until the round\'s updated_at moves', async () => {
+  const state = { tweakFailed: new Map([['901', 't1']]) };
+  const api = (updated) => fakeApi({ pages: [submitted('landing:index', 901)], rounds: { 901: round(901, { updated_at: updated }) } });
+  const same = await pick(api('t1'), state);
+  assert.deepEqual(same.skipped.map((s) => s.code), ['round_failed_unchanged']);
+  assert.equal((await pick(api('t2'), state)).round.task.id, 901, 'the artist edited or resubmitted it');
+});
+
+test('BELOW METIC: reported once, then quiet', async () => {
+  const state = {};
+  const api = fakeApi({ rank: 'thetes', pages: [submitted('landing:index', 901)], rounds: { 901: round(901) } });
+  const first = await pick(api, state);
+  assert.equal(first.code, 'lane_rank_too_low');
+  assert.equal(first.quiet, false);
+  const second = await pick(api, state);
+  assert.equal(second.code, 'lane_rank_too_low');
+  assert.equal(second.quiet, true, 'the lane stops saying it');
+});
+
+test('the outcome is read from the ledger: a held pass is the success, a released round a halt', () => {
+  assert.equal(lane.tweakOutcome({ task: { status: 'completed' }, grade: { passed: true } }).shape, 'waiting_for_artist');
+  assert.equal(lane.tweakOutcome({ task: { status: 'ready' }, grade: null }).failed, true);
+  assert.equal(lane.tweakOutcome({ task: { status: 'completed' }, grade: { passed: false } }).ok, false);
+});
+
+// ---- the real iteration() ---------------------------------------------------
+
+const goodGauge = () => ({ decision: { go: true, unknown: false, sleepUntil: null, reason: 'headroom' } });
+const openFence = (goals = [{ goal_id: 1000119 }]) => ({ raw: { enabled: true, paused_reason: null, goals }, graderBypassed: false });
+const aTask = { id: 4242, title: 'Do the thing', kind: 'feature', description: 'd'.repeat(300), goal_id: 1000119, touches: [] };
+const opts = { goals: [1000119], maxTasks: 1, dryRun: false, model: 'm', timeoutMs: 1000 };
+
+function harness({ api, fenceRead = openFence(), afterStatus = 'completed', afterGrade = { passed: true } } = {}) {
+  const calls = []; const rows = []; let picked = 0;
+  const after = { ...round(901, { status: afterStatus, updated_at: 't9' }), grade: afterGrade };
+  const deps = {
+    gauge: goodGauge, readFence: async () => fenceRead, api, state: runner.newRunnerState(),
+    record: (r) => { rows.push(r); return r; },
+    worktreeName: (id) => `autobongos-${id}-abc123`,
+    pickTask: async () => { picked++; return { task: aTask, goalId: 1000119, skipped: [] }; },
+    run: async (bin, args, o = {}) => { calls.push({ script: String(args[0]).split(/[\\/]/).pop(), args: args.slice(1), cwd: o.cwd || null }); return { ok: true, code: 0, stdout: '', stderr: '' }; },
+    spawnWorker: async (a) => { calls.push({ script: 'WORKER', prompt: a.prompt }); return { envelope: { structured_output: { outcome: 'shipped' } }, exitCode: 0, sessionId: 's' }; },
+    laneDeps: { readInventory: () => INV, readRound: async (_api, id) => (String(id) === '901' ? after : null) },
+    verifyDeps: { task: { id: 4242, status: 'shipped', updated_at: new Date().toISOString() }, probeArtifact: async () => ({ checked: true, onMain: true }), fileBlocker: async () => ({ filed: true }) },
+  };
+  return { deps, calls, rows, pickedCount: () => picked };
+}
+
+test('iteration: a submitted round is worked BEFORE ordinary work — marked claim, unattended prompt', async () => {
+  const h = harness({ api: fakeApi({ pages: [submitted('landing:index', 901)], rounds: { 901: round(901) } }) });
+  const row = await runner.iteration(opts, h.deps);
+  assert.equal(row.event, 'worked');
+  assert.equal(row.lane, 'tweak');
+  assert.equal(row.outcome, 'waiting_for_artist');
+  assert.equal(h.pickedCount(), 0, 'ordinary work waits for the next pass');
+  const claim = h.calls.find((c) => c.script === 'claim.js');
+  assert.deepEqual(claim.args, ['901', '--auto-pickup']);
+  const worker = h.calls.find((c) => c.script === 'WORKER');
+  assert.match(worker.prompt, /\/tweak --page landing:index --unattended/);
+  assert.match(worker.prompt, /Never pass --skip-grade/);
+});
+
+test('iteration: a halted round is remembered as failed at its new updated_at, with no blocker', async () => {
+  const h = harness({ api: fakeApi({ pages: [submitted('landing:index', 901)], rounds: { 901: round(901) } }), afterStatus: 'ready', afterGrade: null });
+  const row = await runner.iteration(opts, h.deps);
+  assert.equal(row.outcome, 'tweak_halted');
+  assert.equal(h.deps.state.tweakFailed.get('901'), 't9');
+});
+
+test('iteration: with nothing for the lane, an ordinary task is still picked', async () => {
+  const h = harness({ api: fakeApi({ pages: [] }) });
+  const row = await runner.iteration(opts, h.deps);
+  assert.equal(h.pickedCount(), 1);
+  assert.equal(row.task_id, 4242);
+  assert.equal(row.lane, undefined);
+});
+
+test('iteration: a fence refusing on GOALS alone still lets the lane run; the kill switch does not', async () => {
+  const api = fakeApi({ pages: [submitted('landing:index', 901)], rounds: { 901: round(901) } });
+  const goalsOnly = harness({ api, fenceRead: openFence([]) });
+  assert.equal((await runner.iteration(opts, goalsOnly.deps)).lane, 'tweak');
+
+  const empty = harness({ api: fakeApi({ pages: [] }), fenceRead: openFence([]) });
+  const r2 = await runner.iteration(opts, empty.deps);
+  assert.equal(r2.event, 'fenced', 'no round: the goal refusal is reported as before');
+  assert.equal(empty.pickedCount(), 0);
+
+  const killed = harness({ api, fenceRead: { raw: { enabled: false }, graderBypassed: false } });
+  const r3 = await runner.iteration(opts, killed.deps);
+  assert.equal(r3.code, 'kill_switch');
+  assert.deepEqual(killed.calls, []);
+
+  const offLane = harness({ api: fakeApi({ settings: { ...ON, mode: 'off' }, pages: [submitted('landing:index', 901)], rounds: { 901: round(901) } }), fenceRead: openFence([]) });
+  assert.equal((await runner.iteration(opts, offLane.deps)).event, 'fenced', 'lane off: exactly the old fenced row');
+});
+
+test('iteration: the grade cap holds on a tweak worker — two failed grades release the round to a person', async () => {
+  const h = harness({ api: fakeApi({ pages: [submitted('landing:index', 901)], rounds: { 901: round(901) } }), afterGrade: { passed: false } });
+  let capGiven = null;
+  h.deps.gradeLedgerPath = () => null;
+  h.deps.laneDeps.gradeCapReader = async () => async () => ({ graded: 2, fails: 2, outages: 0, exhausted: true });
+  const spawn = h.deps.spawnWorker;
+  h.deps.spawnWorker = async (a) => { capGiven = a.capCheck; return spawn(a); };
+  const row = await runner.iteration(opts, h.deps);
+  assert.equal(typeof capGiven, 'function', 'the worker is handed the cap check');
+  const halt = h.calls.find((c) => c.script === 'tweak-halt.js');
+  assert.deepEqual(halt && halt.args, ['901', '--code', 'grade_failed']);
+  assert.equal(row.grade_cap_reached, true);
+});
+
+test('a backlog of rounds the lane must skip costs at most ten reads a pass', async () => {
+  let reads = 0;
+  const pages = Array.from({ length: 25 }, (_, i) => submitted('builders:core', 1000 + i));
+  const api = fakeApi({ pages });
+  await lane.pickRound({ api, state: {}, matchProtected, readInventory: () => INV, readRound: async () => { reads++; return round(1); } });
+  assert.equal(reads, 10);
+});