@bongos/core 1.20.32 → 1.20.34

package/tests/autobongos_loop.mjs

@@ -11,7 +11,7 @@ import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
 const {
-  WORKER_VERDICT_SCHEMA, buildWorkerArgs, buildWorkerPrompt, parseWorkerEnvelope, classifyRun,
+  WORKER_VERDICT_SCHEMA, buildWorkerArgs, buildWorkerPrompt, parseWorkerEnvelope, classifyRun, usageLimitHit,
 } = require('../scripts/gds/autobongos-loop.js');
 const runner = require('../scripts/gds/autobongos-run.js');
 
@@ -237,6 +237,12 @@ test('an unreadable claimable feed does not halt everything', async () => {
   assert.equal(got.task.id, 9001, 'the not_claimable reason stays quiet when the feed cannot be read');
 });
 
+test('pickTask passes over a task the runner has set aside (task 1004396)', async () => {
+  const api = fakeApi({ tasks: [ready({ id: 9001 }), ready({ id: 9002 })], claimable: [{ id: 9001 }, { id: 9002 }] });
+  const got = await runner.pickTask([1000119], { api, rank: 'archon', exclude: new Set(['9001']) });
+  assert.equal(got.task.id, 9002, 'a refused task must not stay at the head of the order');
+});
+
 test('a goal whose tasks cannot be read is reported, not silently skipped', async () => {
   const api = fakeApi({ tasks: [], claimable: [] });
   api.tasks.getTasks = async () => { throw new Error('boom'); };
@@ -273,7 +279,11 @@ function harness(over = {}) {
     // The LEDGER, faked. iteration() now reads the task back from Bongos after
     // every worker (task 1003903) instead of believing the worker's own verdict,
     // so a test that does not say what the ledger holds is not describing a run.
-    api: {},
+    api: over.api || {},
+    // Per-test runner memory (task 1004396): refused tasks and a queue gate
+    // outlive one iteration, so a shared module-level copy would leak between tests.
+    state: over.state || runner.newRunnerState(),
+    now: over.now,
     verifyDeps: {
       task: over.ledger !== undefined ? over.ledger : { id: 4242, status: 'shipped', updated_at: new Date().toISOString() },
       probeArtifact: over.probeArtifact || (async () => ({ checked: true, onMain: true, sha: 'a'.repeat(40), subject: 'x (task 4242)' })),
@@ -422,6 +432,137 @@ test('failureReason: stdout is used when stderr is empty, whitespace is collapse
   assert.equal(runner.failureReason({ code: 1, stderr: 'a'.repeat(400) }, 'x').length, 400);
 });
 
+// ── task 1004396: a refusal is not a reason to stop, unless it refuses everything ──
+//
+// Owner ruling (2026-09-30): a refused claim must not put the runner into waiting
+// by default. It sets that task aside and tries the next one. It waits only when
+// there is a block AND nothing else it can claim — which is exactly the shape of
+// the queue-wide gate (a stranded confirmed task refuses EVERY claim).
+
+const taskA = { ...aTask, id: 4242 };
+const taskB = { ...aTask, id: 4343, title: 'The next thing' };
+// A picker that honours the exclusion set, the way the real pickTask now does.
+const pickAorB = async (_goals, pd = {}) => {
+  const ex = pd.exclude || new Set();
+  for (const t of [taskA, taskB]) if (!ex.has(String(t.id))) return { task: t, goalId: 1000119, skipped: [] };
+  return { none: true, skipped: [] };
+};
+const scriptOf = (args) => String(args[0]).split(/[\\/]/).pop();
+const gatedCard = [
+  'Your queue is gated — 1 confirmed task(s) are waiting on your rebase:',
+  '  - task 777  A stranded thing',
+  '      flagged: strand:branch_modifies_executed_code',
+].join(String.fromCharCode(10));
+
+test('a task refused on its own is set aside and the NEXT task is worked in the same pass', async () => {
+  const claims = [];
+  const h = harness({
+    pickTask: pickAorB,
+    ledger: { id: 4343, status: 'shipped', updated_at: new Date().toISOString() },
+    run: async (bin, args) => {
+      if (scriptOf(args) === 'claim.js') {
+        claims.push(args[1]);
+        return args[1] === '4242' ? { ok: false, code: 1, stdout: '', stderr: 'DEPS_NOT_SHIPPED' } : { ok: true, code: 0, stdout: '', stderr: '' };
+      }
+      return { ok: true, code: 0, stdout: '', stderr: '' };
+    },
+  });
+  const row = await runner.iteration(opts, h.deps);
+  assert.deepEqual(claims, ['4242', '4343'], 'the refusal must not end the pass');
+  assert.equal(row.event, 'worked');
+  assert.equal(row.task_id, 4343);
+  const refused = h.rows.find((r) => r.event === 'claim_failed');
+  assert.equal(refused.task_id, 4242, 'the refusal is still logged, with its reason');
+  assert.ok(refused.set_aside_s > 0, 'and says the task is set aside');
+});
+
+test('a set-aside task is not re-tried on the next wake, and comes back once the set-aside expires', async () => {
+  let t = 1_000_000;
+  const state = runner.newRunnerState();
+  const claims = [];
+  const mk = () => harness({
+    state, now: () => t, pickTask: pickAorB,
+    run: async (bin, args) => {
+      if (scriptOf(args) === 'claim.js') { claims.push(args[1]); return { ok: false, code: 1, stdout: '', stderr: 'nope' }; }
+      return { ok: true, code: 0, stdout: '', stderr: '' };
+    },
+  });
+  await runner.iteration(opts, mk().deps);
+  assert.deepEqual(claims, ['4242', '4343']);
+  const second = await runner.iteration(opts, mk().deps);
+  assert.deepEqual(claims, ['4242', '4343'], 'no claim is re-attempted while both are set aside');
+  assert.equal(second.event, 'nothing_claimable');
+  assert.deepEqual(second.set_aside.map((s) => s.id).sort(), ['4242', '4343']);
+  t += runner.CLAIM_SET_ASIDE_MS + 1;
+  await runner.iteration(opts, mk().deps);
+  assert.deepEqual(claims.slice(2), ['4242', '4343'], 'after the set-aside they are tried again');
+});
+
+test('when EVERY candidate is refused, the last failure is returned so a real outage still escalates', async () => {
+  const h = harness({
+    pickTask: pickAorB,
+    run: async (bin, args) => (scriptOf(args) === 'claim.js'
+      ? { ok: false, code: 1, stdout: '', stderr: 'fetch failed' }
+      : { ok: true, code: 0, stdout: '', stderr: '' }),
+  });
+  const row = await runner.iteration(opts, h.deps);
+  assert.equal(row.event, 'claim_failed', 'returning "nothing claimable" here would hide a network outage as idle');
+  assert.equal(h.rows.filter((r) => r.event === 'claim_failed').length, 2);
+});
+
+test('a queue-wide gate WAITS, names the stranded task, and makes no claim until it lands', async () => {
+  const state = runner.newRunnerState();
+  let status = 'confirmed';
+  let gated = true;
+  const claims = [];
+  const api = { tasks: { getTasksId: async ({ id }) => ({ ok: true, data: { task: { id, status } } }) } };
+  const mk = () => harness({
+    state, api, pickTask: pickAorB,
+    run: async (bin, args) => {
+      if (scriptOf(args) === 'claim.js') {
+        claims.push(args[1]);
+        return gated ? { ok: false, code: runner.QUEUE_GATED_EXIT, stdout: '', stderr: gatedCard } : { ok: true, code: 0, stdout: '', stderr: '' };
+      }
+      return { ok: true, code: 0, stdout: '', stderr: '' };
+    },
+  });
+
+  const first = await runner.iteration(opts, mk().deps);
+  assert.equal(first.event, 'queue_gated');
+  assert.deepEqual(first.waiting_on, ['777'], 'the wait names what it is waiting on');
+  assert.deepEqual(claims, ['4242'], 'a gate refuses every claim, so trying the next task is pointless');
+
+  const second = await runner.iteration(opts, mk().deps);
+  assert.equal(second.event, 'queue_gated');
+  assert.deepEqual(claims, ['4242'], 'no claim is attempted while the strand is still confirmed');
+
+  status = 'shipped'; gated = false;
+  const third = await runner.iteration(opts, mk().deps);
+  assert.equal(third.event, 'worked', 'once the strand lands the runner resumes by itself');
+  assert.deepEqual(claims, ['4242', '4242']);
+  assert.equal(state.queueGate, null, 'the gate is forgotten');
+});
+
+test('a gate whose stranded task cannot be read back keeps waiting rather than guessing', async () => {
+  const state = runner.newRunnerState();
+  state.queueGate = { owed: ['777'], since: Date.now(), reason: 'x' };
+  let claimed = false;
+  const h = harness({
+    state, pickTask: pickAorB,
+    api: { tasks: { getTasksId: async () => ({ ok: false, status: 502 }) } },
+    run: async (bin, args) => { if (scriptOf(args) === 'claim.js') claimed = true; return { ok: true, code: 0, stdout: '', stderr: '' }; },
+  });
+  const row = await runner.iteration(opts, h.deps);
+  assert.equal(row.event, 'queue_gated');
+  assert.equal(claimed, false);
+});
+
+test('the runner and claim.js agree on the queue-gated exit code', () => {
+  const claim = require('../scripts/gds/claim.js');
+  assert.equal(runner.QUEUE_GATED_EXIT, claim.QUEUE_GATED_EXIT);
+  assert.notEqual(runner.QUEUE_GATED_EXIT, 1, 'it must differ from the generic refusal, or the runner cannot tell them apart');
+});
+
 test('a worker that cannot finish frees the claim; one that really shipped does not', async () => {
   // Which of these happens is now decided by the LEDGER, not by the worker's own
   // verdict: a stuck worker leaves the task still `active`, a finished one leaves
@@ -695,119 +836,132 @@ test('workerEnv passes Claude auth through, and still refuses the rest', () => {
     assert.equal(env[leak], undefined, `${leak} must never reach a bypassPermissions worker`);
   }
 });
-// --- a derived gauge buys BOUNDED work (task 1004178) -----------------------
+// --- usage is judged continuously; hitting the limit sleeps to its reset (task 1004454) ---
 //
-// `derived` retires a reading whose window has reset. That is sound for the
-// five-hour window, which turns over during a night. The SEVEN-day one does
-// not, so its stale reading is dropped and the weekly pace check — what the
-// module's notes call the thing that actually binds a heavy week — does not run
-// at all on a derived reading. The task cap is what stands in for it, so the
-// cap has to work, and it has to survive a restart: the count comes from the
-// run log, not from memory.
+// Owner ruling, 2026-09-30: no fixed cap. The derived-gauge cap (task 1004178)
+// held the runner after two tasks on an inferred reading — 776 holds in one
+// 2026-09-26..29 run — for a risk the owner accepts: "if you hit usage limits
+// that's fine, but then restart once the limit resets". So the gauge is still
+// read before every task, a derived reading proceeds, and the limit itself is
+// the stop: a worker cut off by it puts the runner to sleep until the reset.
 
 import { mkdtempSync, writeFileSync, readFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
-const derivedLog = () => {
-  const dir = mkdtempSync(join(tmpdir(), 'autobongos-cap-'));
-  return join(dir, 'runs.jsonl');
-};
-
-test('countWorkedSince counts only worked rows at or after the mark', () => {
-  const p = derivedLog();
-  process.env.AUTOBONGOS_LOG_FILE = p;
+test('a derived gauge keeps WORKING however many tasks it has already done — there is no cap', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'autobongos-nocap-'));
+  process.env.AUTOBONGOS_LOG_FILE = join(dir, 'runs.jsonl');
   const at = (s) => new Date(s * 1000).toISOString();
-  writeFileSync(p, [
-    JSON.stringify({ at: at(1000), event: 'worked', task_id: '1' }),   // before the mark
-    JSON.stringify({ at: at(3000), event: 'hold' }),                   // not a worked row
-    JSON.stringify({ at: at(3100), event: 'worked', task_id: '2' }),
-    '{ this line is torn',                                             // costs one row, not the count
-    JSON.stringify({ at: at(3200), event: 'worked', task_id: '3' }),
-  ].join('\n'));
-  assert.equal(runner.countWorkedSince(2000), 2);
-  assert.equal(runner.countWorkedSince(0), 0, 'a zero/absent mark counts nothing rather than everything');
-  delete process.env.AUTOBONGOS_LOG_FILE;
-});
-
-test('countWorkedSince treats an unreadable log as zero, not as a refusal', () => {
-  process.env.AUTOBONGOS_LOG_FILE = join(tmpdir(), 'autobongos-cap-nope', 'missing.jsonl');
-  assert.equal(runner.countWorkedSince(1), 0,
-    'the fence and the gauge are the gates; a bound that bricks the runner when its own log is gone is worse');
-  delete process.env.AUTOBONGOS_LOG_FILE;
-});
-
-test('a derived gauge HOLDS once the cap is reached, and the reason says why', async () => {
-  const p = derivedLog();
-  process.env.AUTOBONGOS_LOG_FILE = p;
-  process.env.AUTOBONGOS_DERIVED_TASK_CAP = '2';
-  const at = (s) => new Date(s * 1000).toISOString();
-  writeFileSync(p, [
-    JSON.stringify({ at: at(5100), event: 'worked', task_id: '1' }),
-    JSON.stringify({ at: at(5200), event: 'worked', task_id: '2' }),
-  ].join('\n'));
-
+  const rows = [];
+  for (let i = 0; i < 6; i++) rows.push(JSON.stringify({ at: at(5100 + i), event: 'worked', task_id: String(i) }));
+  writeFileSync(process.env.AUTOBONGOS_LOG_FILE, rows.join('\n'));
+  let reachedPicker = false;
   const events = [];
   await runner.iteration({ goals: [], maxTasks: 1 }, {
+    state: runner.newRunnerState(),
     readFence: async () => ({ raw: { enabled: true, goals: [{ goal_id: 7 }] }, graderBypassed: false }),
     gauge: () => ({ decision: { go: true, unknown: false, derived: true, derivedSince: 5000, reason: 'derived' } }),
-    pickTask: async () => { throw new Error('CAP BREACHED: reached the picker'); },
+    pickTask: async () => { reachedPicker = true; return { none: true, skipped: [] }; },
     record: (row) => { events.push(row); return row; },
-    run: async () => { throw new Error('CAP BREACHED: ran a command'); },
-    spawnWorker: async () => { throw new Error('CAP BREACHED: spawned a worker'); },
   });
-  assert.equal(events[0].event, 'hold');
-  assert.equal(events[0].derived, true);
-  assert.equal(events[0].worked_since_derived, 2);
-  assert.match(events[0].reason, /cap is 2/);
-  delete process.env.AUTOBONGOS_LOG_FILE; delete process.env.AUTOBONGOS_DERIVED_TASK_CAP;
-});
-
-test('a derived gauge still WORKS while under the cap', async () => {
-  const p = derivedLog();
-  process.env.AUTOBONGOS_LOG_FILE = p;
-  process.env.AUTOBONGOS_DERIVED_TASK_CAP = '2';
-  writeFileSync(p, JSON.stringify({ at: new Date(5100 * 1000).toISOString(), event: 'worked', task_id: '1' }));
-  let reachedPicker = false;
+  assert.equal(reachedPicker, true, 'six tasks since the reset must not stop the seventh');
+  assert.ok(!events.some((e) => e.event === 'hold'), 'no hold on a derived reading');
+  delete process.env.AUTOBONGOS_LOG_FILE;
+});
+
+test('the gauge is still read before EVERY task, and a real hold still holds', async () => {
+  let reads = 0;
   const events = [];
-  await runner.iteration({ goals: [], maxTasks: 1 }, {
+  const d = {
+    state: runner.newRunnerState(),
     readFence: async () => ({ raw: { enabled: true, goals: [{ goal_id: 7 }] }, graderBypassed: false }),
-    gauge: () => ({ decision: { go: true, unknown: false, derived: true, derivedSince: 5000, reason: 'derived' } }),
-    pickTask: async () => { reachedPicker = true; return { none: true, skipped: [] }; },
+    gauge: () => { reads += 1; return { decision: { go: false, unknown: false, reason: 'five-hour burn 80% is past the ceiling', sleepUntil: 1790218521 } }; },
+    pickTask: async () => { throw new Error('picked past a hold'); },
     record: (row) => { events.push(row); return row; },
-  });
-  assert.equal(reachedPicker, true, 'one task done against a cap of two must still proceed');
-  delete process.env.AUTOBONGOS_LOG_FILE; delete process.env.AUTOBONGOS_DERIVED_TASK_CAP;
+  };
+  await runner.iteration({ goals: [], maxTasks: 1 }, d);
+  await runner.iteration({ goals: [], maxTasks: 1 }, d);
+  assert.equal(reads, 2);
+  assert.equal(events[1].event, 'hold');
+  assert.equal(events[1].sleep_until, 1790218521);
 });
 
-test('countWorkedSince is bounded: a huge log does not mean a huge scan', () => {
-  const p = derivedLog();
-  process.env.AUTOBONGOS_LOG_FILE = p;
-  const at = (s) => new Date(s * 1000).toISOString();
-  // 40k old rows, then the two that matter. A whole-file parse would touch
-  // every one of them on EVERY iteration of a loop that never exits.
-  const old = [];
-  for (let i = 0; i < 40000; i++) old.push(JSON.stringify({ at: at(1000 + i), event: 'worked', task_id: String(i) }));
-  old.push(JSON.stringify({ at: at(900000), event: 'worked', task_id: 'recent-1' }));
-  old.push(JSON.stringify({ at: at(900100), event: 'worked', task_id: 'recent-2' }));
-  writeFileSync(p, old.join('\n'));
-  const t0 = Date.now();
-  assert.equal(runner.countWorkedSince(800000), 2, 'only the rows at or after the mark count');
-  assert.ok(Date.now() - t0 < 500, 'and it must not walk the whole log to say so');
-  delete process.env.AUTOBONGOS_LOG_FILE;
+test('usageLimitHit reads the reset second out of the CLI\'s own limit message', () => {
+  const env = JSON.stringify({ type: 'result', subtype: 'success', is_error: true, result: 'Claude AI usage limit reached|1790300000' });
+  assert.deepEqual(usageLimitHit({ envelope: env }), { resetAt: 1790300000 });
 });
 
-test('countWorkedSince stops at the first row older than the mark', () => {
-  const p = derivedLog();
-  process.env.AUTOBONGOS_LOG_FILE = p;
-  const at = (s) => new Date(s * 1000).toISOString();
-  writeFileSync(p, [
-    JSON.stringify({ at: at(100), event: 'worked', task_id: 'ancient' }),
-    JSON.stringify({ at: at(5000), event: 'worked', task_id: 'before-mark' }),
-    JSON.stringify({ at: at(9000), event: 'worked', task_id: 'after-mark' }),
-  ].join('\n'));
-  assert.equal(runner.countWorkedSince(8000), 1);
-  delete process.env.AUTOBONGOS_LOG_FILE;
+test('usageLimitHit recognises a limit message with no machine-readable time, and says so', () => {
+  const env = JSON.stringify({ type: 'result', is_error: true, result: "You've hit your limit · resets 3am (America/New_York)" });
+  assert.deepEqual(usageLimitHit({ envelope: env }), { resetAt: null });
+  assert.deepEqual(usageLimitHit({ envelope: '', stderr: '5-hour limit reached ∙ resets 3pm' }), { resetAt: null });
+});
+
+test('usageLimitHit ignores the word "limit" in a worker that FINISHED', () => {
+  // A worker that fixed a GitHub rate-limit bug writes about rate limits in its
+  // verdict. Only an ERROR envelope, or a run with no envelope at all, can be a
+  // limit hit — anything else would put the runner to sleep for doing its job.
+  const env = JSON.stringify({ type: 'result', is_error: false, result: 'Claude AI usage limit reached|1790300000 is the banner text I fixed', structured_output: { outcome: 'shipped', what_happened: 'fixed the usage limit reached banner' } });
+  assert.equal(usageLimitHit({ envelope: env }), null);
+  assert.equal(usageLimitHit({ envelope: JSON.stringify({ is_error: true, result: 'API Error: 500' }) }), null);
+});
+
+function limitHarness(state, now, envelopeText) {
+  const rows = [];
+  const deps = {
+    state, now: () => now.t,
+    gauge: () => ({ decision: { go: true, unknown: false, derived: true, derivedSince: 1, reason: 'derived' } }),
+    readFence: async () => ({ raw: { enabled: true, goals: [{ goal_id: 1000119 }] }, graderBypassed: false }),
+    api: {},
+    verifyDeps: {
+      task: { id: 4242, status: 'active', updated_at: new Date().toISOString() },
+      probeArtifact: async () => ({ checked: true, onMain: false }),
+      fileBlocker: async () => ({ filed: false }),
+    },
+    release: async () => ({ ok: true, code: 0, stdout: '', stderr: '' }),
+    pickTask: async () => ({ task: { id: 4242, title: 't', kind: 'feature', description: 'd'.repeat(300), goal_id: 1000119, touches: [] }, goalId: 1000119, skipped: [] }),
+    worktreeName: () => 'autobongos-4242-abc123',
+    record: (r) => { rows.push(r); return r; },
+    run: async () => ({ ok: true, code: 0, stdout: '', stderr: '' }),
+    spawnWorker: async () => ({ envelope: envelopeText, exitCode: 1, sessionId: 's' }),
+  };
+  return { deps, rows };
+}
+
+test('a worker cut off by the usage limit puts the runner to sleep until the reset, then it resumes by itself', async () => {
+  const state = runner.newRunnerState();
+  const now = { t: 1_790_290_000_000 };
+  const env = JSON.stringify({ type: 'result', is_error: true, result: 'Claude AI usage limit reached|1790300000' });
+  const h = limitHarness(state, now, env);
+
+  const worked = await runner.iteration(opts, h.deps);
+  assert.equal(worked.event, 'worked');
+  assert.deepEqual(worked.usage_limit, { reset_at: 1790300000 }, 'the row says the limit was hit and when it resets');
+
+  let picked = false;
+  const asleep = await runner.iteration(opts, { ...h.deps, pickTask: async () => { picked = true; return { none: true }; } });
+  assert.equal(asleep.event, 'hold');
+  assert.equal(asleep.sleep_until, 1790300000, 'it sleeps to the reset second the CLI named');
+  assert.match(asleep.reason, /usage limit/);
+  assert.equal(picked, false, 'no task is taken while the limit is spent');
+
+  now.t = 1_790_300_001_000;
+  const awake = await runner.iteration(opts, { ...h.deps, pickTask: async () => { picked = true; return { none: true, skipped: [] }; } });
+  assert.equal(picked, true, 'past the reset it picks again without anyone touching it');
+  assert.equal(awake.event, 'nothing_claimable');
+  assert.equal(state.limitUntil, null);
+});
+
+test('a limit hit with no stated reset sleeps a bounded while and then tries again', async () => {
+  const state = runner.newRunnerState();
+  const now = { t: 2_000_000_000_000 };
+  const h = limitHarness(state, now, JSON.stringify({ is_error: true, result: '5-hour limit reached ∙ resets 3pm' }));
+  const worked = await runner.iteration(opts, h.deps);
+  assert.deepEqual(worked.usage_limit, { reset_at: null });
+  const asleep = await runner.iteration(opts, h.deps);
+  assert.equal(asleep.event, 'hold');
+  assert.equal(asleep.sleep_until, Math.round((now.t + runner.LIMIT_UNKNOWN_RESET_MS) / 1000));
 });
 
 // --- a --forever runner must be able to take a fix (task 1004374) -----------

package/tests/autonomy_digest.mjs

@@ -97,6 +97,16 @@ test('shipped is the LEDGER’s answer, never the worker’s', () => {
   assert.deepEqual(d.onHold.ranButDidNotShip.map((r) => r.shape), ['still_held', 'shipped_no_artifact']);
 });
 
+test('a queue-gate wait is a hold that names the stranded task, not an unrecognised event (task 1004396)', () => {
+  const d = buildDigest([
+    { at: at(0), event: 'queue_gated', waiting_on: ['777'], reason: 'every claim is refused until task 777 lands — waiting, not claiming (x)' },
+    { at: at(5), event: 'queue_gate_cleared', waited_on: ['777'], waited_s: 300 },
+  ], { nowEpochS: NOW_S });
+  assert.equal(d.runner.unrecognised, 0);
+  assert.equal(d.onHold.held.length, 1);
+  assert.match(d.onHold.held[0].reason, /task 777/);
+});
+
 test('an unworkable queue is reported as a queue problem, not as breakage', () => {
   const d = buildDigest([{ at: at(0), event: 'nothing_claimable', skipped: [{ id: 9, reasons: ['needs_migration'] }] }], { nowEpochS: NOW_S });
   assert.equal(d.onHold.unworkable.length, 1);

package/tests/claim_error_surface.mjs

@@ -231,6 +231,13 @@ t('REBASE_REQUIRED: names the owed tasks and relays the server hint', () => {
     'must not fall through to the bare code echo');
 });
 
+t('REBASE_REQUIRED exits with its OWN code, so an unattended caller can tell a queue gate from a task refusal (task 1004396)', () => {
+  const { QUEUE_GATED_EXIT } = require('../scripts/gds/claim.js');
+  assert.equal(formatClaimFailure(envelope('REBASE_REQUIRED', {}), 5).exit, QUEUE_GATED_EXIT);
+  assert.notEqual(QUEUE_GATED_EXIT, 1);
+  assert.equal(formatClaimFailure(envelope('ALREADY_CLAIMED', {}), 5).exit, 1, 'a per-task refusal keeps exit 1');
+});
+
 t('REBASE_REQUIRED: still guides when the server sends no hint and no task list', () => {
   const out = text(formatClaimFailure(envelope('REBASE_REQUIRED', {}), 5));
   assert.match(out, /gated/i, 'must say the queue is gated');

package/tests/cli_exit_no_abort.mjs

@@ -348,7 +348,12 @@ test('land-watch.js exits 0 after a REAL request — the teardown that aborted 3
 // throwaway session, so no real API is touched and the developer's own config is
 // never read or written. `--here` because CI may check out the MAIN checkout,
 // where the worktree guard would refuse at exit 2 before any request is made.
-test('claim.js exits 1 without aborting on a REFUSED claim — measured 3/3 aborting before', async () => {
+// The stub refuses with REBASE_REQUIRED, the queue-wide gate, which exits with its
+// own code since task 1004396 (QUEUE_GATED_EXIT) so an unattended caller can tell a
+// gate from a task refusal. The abort this guards against shows as 127 either way.
+const { QUEUE_GATED_EXIT } = createRequire(import.meta.url)('../scripts/gds/claim.js');
+
+test('claim.js exits with its refusal code without aborting on a REFUSED claim — measured 3/3 aborting before', async () => {
   const { proc, port } = await startStub({ claimStatus: 409 });
   try {
     const home = makeHome({ apiBase: `http://127.0.0.1:${port}` });
@@ -361,7 +366,7 @@ test('claim.js exits 1 without aborting on a REFUSED claim — measured 3/3 abor
       });
       assert.notEqual(r.signal, 'SIGTERM', `run ${i + 1} timed out — draining left a handle armed`);
       assert.doesNotMatch(r.stderr || '', ABORT_RE, `run ${i + 1} aborted natively:\n${r.stderr}`);
-      assert.equal(r.status, 1, `a refused claim must exit 1, got ${r.status} (127 = the abort); stderr: ${r.stderr}`);
+      assert.equal(r.status, QUEUE_GATED_EXIT, `a queue-gated claim must exit ${QUEUE_GATED_EXIT}, got ${r.status} (127 = the abort); stderr: ${r.stderr}`);
       // End-to-end proof that the new REBASE_REQUIRED rendering reaches a terminal,
       // not just the unit test: the stub refuses with that exact envelope.
       //