@bongos/core 1.21.111 → 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.111",
-  "core_contract": "1.21.111",
-  "source_commit": "a3e0196872aa25b75c2e6477c588bf9a3cc19b06",
+  "core_version": "1.21.113",
+  "core_contract": "1.21.113",
+  "source_commit": "083632759dcd4d0b7a640009d2fd5b6e02e88e8c",
   "source_ref": "HEAD",
-  "built_at": "2026-10-09T17:16:36.431Z",
+  "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": "c31261294242b2cd66c134daea2ffb60526f5cfa809bbed76fee9c229436b1a9",
+  "file_count": 3659,
+  "tree_sha256": "1fff5d0d8056ffebe50dfbd2b871d4e2f2c2c83e0566e32ce426390de0388a50",
   "files": [
     {
       "path": ".claude/skills/ask-for-help/SKILL.md",
@@ -612,7 +612,7 @@
     {
       "path": "docs/adr/0043-git-ssh-trust-boundary-and-rank-floor-on-permission-paths.md",
       "mode": "0000644",
-      "sha256": "250ee61fac1aff3aa602a769a0b6fb2dcdac9f9abe9c61381d755a1b53a0eea2"
+      "sha256": "9127ee3f769616ad16e7151cb7f5f5a461690303804ce0ee7ddf6410f101dbd0"
     },
     {
       "path": "docs/adr/0044-mediterranean-palette-replacement.md",
@@ -2352,7 +2352,7 @@
     {
       "path": "docs/canonical-permissions.md",
       "mode": "0000644",
-      "sha256": "58b05e37108c25afa2d1d61a22c6fa0419ec2e242dacc3c1f8b7f7c70bd46ae2"
+      "sha256": "453a9449ea0dc1a5f50b1d786a4d5b14086423bfd02904c9a0df5c541347d144"
     },
     {
       "path": "docs/copy-inventory.md",
@@ -2872,7 +2872,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "1665ae4a1fae5235c36e3a4d4d588de6d93817774de58ce40cd62e623e115a53"
+      "sha256": "a3bef3c5acf2212482d2e29929d92f5ef3738e9b739c7e31f6c37ba4701a7253"
     },
     {
       "path": "docs/modules-contract.md",
@@ -10172,12 +10172,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "4ba883875bbc96c1d74b3e0ad996ea707dea726f16d20989a885b07bde0a8a5b"
+      "sha256": "826f2bbfa8798f0561784c494f5794b9dc1781c930687cee51920e17f1f11bf4"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "69b4ae038049ccf22290a8ab298d08d04d4e8800619f11c24a9aea97614ad535"
+      "sha256": "3defe7b0c206cd3c9433361f12186de2ce84a0ed7b652a82abe285e74d95dc52"
     },
     {
       "path": "public-docs/index.html",
@@ -10197,7 +10197,7 @@
     {
       "path": "release-notes.json",
       "mode": "0000644",
-      "sha256": "aaa8e0550bc3b6b84184791498534dfe89d5accebc4c5e51220a95689c6a053e"
+      "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": "f10cbc790057ddb654dea27953fb735caba80cbc333d28a5b9253b44a852fd6b"
+      "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/adr/0043-git-ssh-trust-boundary-and-rank-floor-on-permission-paths.md

@@ -19,7 +19,7 @@ The SSH deploy failed (their box had no droplet key), but it didn't matter: the
 
 [ADR 0016](0016-trust-boundary-server-enforced-permissions.md) put authority in `builders.rank` and enforced it **server-side per request** — but **only for `/api/gds/*` HTTP routes**. It explicitly does not cover two surfaces:
 
-1. **GitHub `main` is writable by every collaborator.** The repo is a **free-plan private repo**, so GitHub branch protection is *not available* ("Upgrade to GitHub Pro…"). All collaborators (`example-owner`, `LarsCode`, `willExample`, `IAMMASTERQUA`) have full push to `main`. The grader / confirm / rank gates live inside `ship.js` and the server — a raw `git push origin main` touches neither.
+1. **GitHub `main` is writable by every collaborator.** The repo is a **free-plan private repo**, so GitHub branch protection is *not available* ("Upgrade to GitHub Pro…"). All collaborators (`example-owner`, `LarsCode`, `willExample`, `IAMMASTERQUA`) have full push to `main`. The grader / confirm / rank gates live inside `ship.js` and the server — a raw `git push origin main` touches neither. *(As written at the time. Since 2026-08-08 `main` is protected — a pull request plus the `unit` check for every non-admin; see §"Branch-protection status" for the current probes.)*
 2. **The legit pipeline itself distributes the dangerous credentials.** `ship.js` does the merge-to-`main` and `ssh …deploy.sh` **client-side, from the builder's machine** — so the design hands every shipping builder the exact credentials needed to bypass it.
 
 A second, softer problem Lars raised: a sub-Metic builder had free rein to **read into and reason about the tiering/permission code** in the first place. Newcomers (`xenos`/`thetes`) should stay in their lane.
@@ -30,13 +30,13 @@ Two threads.
 
 ### A. Close the code-landing path (chosen: Option A now, Option B later)
 
-The protection goal is "un-graded code cannot reach prod, and a raw push to `main` is caught." Three layers, defense-in-depth, where **layer 3 is the authoritative enforcement** (the only one that survives a raw push / `--no-verify`, given GitHub can't block the push on the free plan):
+The protection goal is "un-graded code cannot reach prod, and a raw push to `main` is caught." Three layers, defense-in-depth, where **layer 3 is the authoritative enforcement** (the only one that survives a raw push / `--no-verify`, given GitHub couldn't block the push on the free plan when this was written). **Since 2026-08-08 GitHub does block a non-admin's direct push** — see §"Branch-protection status"; layer 3 stays authoritative for what branch protection does not cover (the admin's direct push, a self-merged PR with zero reviews, and *who* authored a protected path — the `unit` check passes a sub-Metic author as readily as anyone):
 
 | Layer | Mechanism | Catches | Authoritative? |
 |---|---|---|---|
 | 1 — pre-push hook | `.husky/pre-push` → `scripts/gds/hooks/pre-push.js`. Blocks a direct push to `main` (override `OTB_ALLOW_MAIN_PUSH=1`, used only by the gated `scripts/gds/push-main.js`), and blocks a sub-Metic push that touches a permission-sensitive path. | the cooperative / careless case before the push leaves the box | no — bypassable with `--no-verify` |
 | 2 — grader pre-pass | `grader.permissionPathPrePass(changedFiles, builderRank)` hard-fails the grade if a sub-Metic diff touches a protected path (mirrors the route-rank pre-pass). | the honest GDS ship flow | no — skippable with `--skip-grade` / raw push |
-| 3 — post-push main audit | `scripts/gds/main-audit.js`: reads the **real** git history + **real** builder ranks (roster API, or Postgres via `--db` on the droplet). A resolved sub-Metic author on a protected path is a hard `[BLOCKER]`. Runs nightly (`.claude/scheduled-tasks/main-audit/`) **and** as the deploy gate (`--verify-head --db` from `~/deploy.sh`, `infra/deploy-main-audit-gate.sh`). | a raw `git push origin main`, a `--no-verify`, a `--skip-grade` — anything | **yes** — independent of the builder's cooperation |
+| 3 — post-push main audit | `scripts/gds/main-audit.js`: reads the **real** git history + **real** builder ranks (roster API, or Postgres via `--db` on the droplet). A resolved sub-Metic author on a protected path is a hard `[BLOCKER]`. Runs nightly (`.claude/scheduled-tasks/main-audit/`) **and** as the deploy gate (`--verify-head --db` from `~/deploy.sh`, `infra/deploy-main-audit-gate.sh`). | a raw `git push origin main` (since 2026-08-08 only the admin's; a non-admin's is refused by GitHub), a self-merged PR, a `--no-verify`, a `--skip-grade` — anything | **yes** — independent of the builder's cooperation, and the only layer that judges the author's RANK; branch protection proves a PR + green `unit`, not who may touch a protected path |
 
 "Option A" = the merge-to-`main` + deploy move **server-side** so builders never hold main-push/droplet-SSH at all. The protections above ship now; the *full* server-side move and the credential rotation are operator steps (blockers [#15](https://example.com/builders#/blocker/15), [#16](https://example.com/builders#/blocker/16)). Until then, the legit client-side push is allowed only through `scripts/gds/push-main.js`, and the deploy gate (layer 3) is what guarantees poison never reaches prod.
 
@@ -69,7 +69,40 @@ After shipping, the fix was adversarially red-teamed (a 4-dimension panel + per-
 
 **Not yet done (finding `#7`, follow-up):** the permission-path pre-pass (layer 2) runs only client-side in `ship.js`; the server `/grade` and `/confirm` routes don't re-run it. Layer 3 is the server-side backstop today; re-running the pre-pass server-side (the server holds the live rank in `req.builder.rank`) would harden the cooperative path.
 
-## Branch-protection status: re-verified 2026-07-24 (task [#1001840](https://cloudbongos.com/builders#/task/1001840))
+## Branch-protection status: re-verified 2026-09-25 (task [1004669](https://cloudbongos.com/builders#/task/1004669))
+
+**Current. `main` IS protected — a pull request plus the `unit` check, for everyone but the admin.**
+Probed 2026-09-25 with the owner's (admin) GitHub account while checking task
+[1001433](https://cloudbongos.com/builders#/task/1001433); the protection itself landed 2026-08-08
+(task [1002619](https://cloudbongos.com/builders#/task/1002619)):
+
+| Probe | Result |
+|---|---|
+| `GET /repos/:o/:r/branches/main` | `protected: true` |
+| `GET /repos/:o/:r/branches/main/protection` | `required_status_checks.contexts: ["unit"]` (`strict: false`) · `required_pull_request_reviews` present, `required_approving_review_count: 0` · `enforce_admins: false` · `allow_force_pushes: false` · `allow_deletions: false` |
+| `GET /repos/:o/:r/rulesets` | `[]` — classic branch protection, not a ruleset |
+| Collaborators with write | four, plus the admin owner; all four are Metic or Archon on the public leaderboard |
+
+What this means for the claims above:
+
+- **No longer true:** "a raw `git push origin main` by any collaborator is accepted". A non-admin's
+  direct push is refused; their work reaches `main` only through a PR whose `unit` check is green.
+  Force-pushing and deleting `main` are refused for everyone.
+- **Still true:** the **admin** can push directly (`enforce_admins: false`); a write collaborator can
+  merge **their own** PR with zero reviews (the review count is 0 — the deliberate checks-only posture
+  of ADR 0162); and a builder **below Metic** reaches `main` only through the server's own publish
+  path (ADR 0055), never with a credential of their own.
+- **So layer 3 (`main-audit.js`) stays the authoritative rank check.** Branch protection proves a
+  change came through a PR with a green `unit` run; it says nothing about whether its author may touch
+  a protected path. Option B (blocker [17](https://cloudbongos.com/builders#/blocker/17)) is half-delivered:
+  direct push is closed for non-admins, but nothing restricts `main` to the owner plus a deploy bot.
+
+Treat this as the freshness stamp: re-run the probes above before asserting the claim has changed,
+and update this section — not the history below — when it does.
+
+## Branch-protection status: 2026-07-24 (history — superseded by the section above)
+
+_Originally headed "re-verified 2026-07-24 (task [1001840](https://cloudbongos.com/builders#/task/1001840))"; kept as written._
 
 The 2026-07-03 authority sweep reported that `main` had since gained live branch protection (required
 checks + code-owner review, direct push blocked), which would have demoted `main-audit.js` from
@@ -90,8 +123,8 @@ private repo with no protection available, and **layer 3 (`main-audit.js`) remai
 enforcement**, not a redundant second net. Option B (blocker
 [#17](https://cloudbongos.com/builders#/blocker/17)) is still open and still the durable closure.
 
-Treat this as the freshness stamp: re-run the probes above before asserting the claim has changed —
-a plan upgrade or a new ruleset would flip it, and this section is what a future sweep should update.
+This was the freshness stamp until the 2026-08-08 protection flipped it; the current stamp is the
+2026-09-25 section above.
 
 ## G-2/G-17 resolution: Layer 1 delivered; the "path bug" refuted (2026-08-08, task 1002608)
 

package/docs/canonical-permissions.md

@@ -290,12 +290,15 @@ Reading the code is not rank-gated today; what a builder can LAND is (next secti
 ADR 0016's per-request rank check covers `/api/bongos/*` only. Two surfaces it does **not** cover —
 `git push` to `main` and `ssh` to the droplet — were used in the Builder 25 incident to land an
 un-graded tiering change straight on prod `main`. **Since 2026-08-08 (task 1002619), `main` HAS
-live branch protection: the required `unit` status check blocks every direct push, so all work
-lands via PR.** The protection is *checks-only* — a code-owner review requirement was briefly
+live branch protection: a pull request plus the required `unit` status check, so a non-admin's
+direct push is refused and their work lands via PR.** Re-probed 2026-09-25 (task
+[1004669](https://cloudbongos.com/builders#/task/1004669)): `enforce_admins` is off, so the **admin**
+can still push directly; the PR needs **zero** approvals, so a write collaborator can merge their own;
+force-push and deletion of `main` are refused for everyone. The protection is *checks-only* — a code-owner review requirement was briefly
 enforced and then deliberately retired by the owner (ADR 0162, task 1002635): gates are
 rank-consistent CI checks, never a named human's approval. (The 2026-07-24 state — no protection
 at all, PR #19 merged with zero checks — is preserved in ADR 0043 §"Branch-protection status" as
-history.) `main-audit.js` remains the authoritative *post-merge* layer — it catches what any
+history, below the current 2026-09-25 probes.) `main-audit.js` remains the authoritative *post-merge* layer — it catches what any
 pre-merge gate misses, independent of the builder's cooperation:
 
 - A builder **below Metic** (`xenos`, `thetes`) may **not modify permission-sensitive paths** — the

package/docs/module-api-changelog.md

@@ -3059,5 +3059,9 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.21.109 with no explicit bump. run 37963285770. (task 1002620)
   1.21.111 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         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.111",
+  "version": "1.21.113",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.21.111",
+      "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.111",
+  "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

@@ -9524,5 +9524,17 @@
       "id": "1004667",
       "text": "Lost bug screenshots can now be brought back. We used to tell people a missing screenshot from the Discord bugs channel was gone for good. That was wrong: only the link expires, and the picture stays in Discord as long as the"
     }
+  ],
+  "1.21.112": [
+    {
+      "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.111'; // 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);
+});