@bongos/core 1.21.4 → 1.21.6

package/tests/autobongos_loop.mjs

@@ -619,9 +619,22 @@ test('a mid-ship strand is named in the run log and blocked, but not released',
   }
 });
 
-test('a ship with no artifact on main is recorded as unverified', async () => {
+test('a fresh ship with nothing on main yet is pending_land: unverified, no blocker (task 1004538)', async () => {
+  // The harness ledger shipped just now — well inside the land grace window.
   const h = harness({ probeArtifact: async () => ({ checked: true, onMain: false, sha: null, subject: null }) });
   const row = await runner.iteration(opts, h.deps);
+  assert.equal(row.ledger_shape, 'pending_land', 'the run log row is what the next loop re-probes from');
+  assert.equal(row.verified, false);
+  assert.deepEqual(h.blockers, [], 'a slow land is not an owner problem yet');
+});
+
+test('a ship with no artifact on main is recorded as unverified', async () => {
+  const h = harness({
+    probeArtifact: async () => ({ checked: true, onMain: false, sha: null, subject: null }),
+    // Shipped two days ago: past the land grace window.
+    ledger: { id: 4242, status: 'shipped', shipped_at: new Date(Date.now() - 48 * 3600_000).toISOString() },
+  });
+  const row = await runner.iteration(opts, h.deps);
   assert.equal(row.ledger_status, 'shipped');
   assert.equal(row.ledger_shape, 'shipped_no_artifact');
   assert.equal(row.verified, false);
@@ -1379,3 +1392,219 @@ test('the server heartbeat carries the goal the current task came from', async (
   assert.ok(b, 'the beat after a worked row must name its task');
   assert.equal(b.working_goal_id, 1000090);
 });
+
+// ── the grade cap (task 1004536) ────────────────────────────────────────────────
+// Owner rule: a task that fails the grade twice goes to the owner. The prompt
+// asked for it and was ignored (task 1004512: $63.81 over three rounds), so the
+// supervisor reads the run's grade ledger itself.
+const gradeCapLib = require('../scripts/gds/autobongos-grade-cap.js');
+const fakeGrade = (passed, outage = false) => ({ passed, score: passed ? 8 : 5, signals: { panel_outcome: outage ? 'unavailable' : (passed ? 'pass' : 'fail') } });
+function ledgerHarness(grades, { ledgerStatus = 'completed' } = {}) {
+  const file = join(mkdtempSync(join(tmpdir(), 'abgcap-')), 'run.jsonl');
+  let handed = null;
+  const h = harness({
+    ledger: { id: 4242, status: ledgerStatus, updated_at: new Date().toISOString() },
+    spawnWorker: async (a) => {
+      handed = a.gradeLedger;
+      // What ship.js does inside the worker: one row per graded round.
+      for (const g of grades) gradeCapLib.recordGradeOutcome({ taskId: 4242, grade: g, env: { [gradeCapLib.LEDGER_ENV]: a.gradeLedger } });
+      // ...and the worker IGNORING its brief, claiming a ship anyway.
+      return { envelope: { is_error: false, result: '', structured_output: {
+        outcome: 'shipped', task_id: 4242, what_happened: 'fixed and re-graded', undetermined_decisions: [],
+      } }, exitCode: 0 };
+    },
+  });
+  h.deps.gradeLedgerPath = () => file;
+  return { h, file, handed: () => handed };
+}
+
+test('the brief states the grade cap: one re-grade, then cannot_complete; an outage does not count', () => {
+  const p = buildWorkerPrompt({ task: { id: 7, title: 't', description: 'd' } });
+  assert.match(p, /at most ONE re-grade/);
+  assert.match(p, /fails twice, STOP/);
+  assert.match(p, /GRADER UNAVAILABLE[^.]*does not count/);
+});
+
+test('two graded FAILs in one run end it as needs_human, whatever the worker claims', async () => {
+  const { h, file, handed } = ledgerHarness([fakeGrade(false), fakeGrade(false)]);
+  const row = await runner.iteration(opts, h.deps);
+  assert.equal(handed(), file, 'the supervisor picks the ledger and hands it to the worker');
+  assert.equal(row.outcome, 'needs_human', 'the worker said "shipped"; the ledger says the grade failed twice');
+  assert.match(row.reason, /failed 2 times/);
+  assert.equal(row.grade_rounds, 2);
+  assert.equal(row.grade_cap_reached, true);
+  assert.equal(h.blockers.length, 1, 'the owner gets a blocker — the existing needs_human path');
+  assert.throws(() => readFileSync(file), /ENOENT/, 'the per-run ledger is removed once read; its counts are in the row');
+});
+
+test('a grader outage between two rounds does not end the run', async () => {
+  const { h } = ledgerHarness([fakeGrade(false), fakeGrade(false, true), fakeGrade(true)], { ledgerStatus: 'shipped' });
+  const row = await runner.iteration(opts, h.deps);
+  assert.equal(row.outcome, 'claims_shipped');
+  assert.equal(row.grade_rounds, 2);
+  assert.equal(row.grade_outages, 1);
+  assert.equal(row.grade_cap_reached, false);
+});
+
+// The grader's hacker finding on the first cut: the local ledger lives in the
+// worker's env and filesystem, so a worker can clear it. The supervisor's count
+// comes from the server's grade_attempts, which the worker cannot write.
+const attempt = (at, passed, { outage = false } = {}) => ({
+  attempted_at: at, passed,
+  workers: ['narc', 'quality', 'hacker', 'efficiency'].map((kind) => ({
+    kind, verdict: outage ? null : (passed ? 'pass' : 'fail'), error: outage && kind !== 'narc' ? 'SUBAGENT_SPAWN_FAILED' : null, severities: [],
+  })),
+});
+function serverApi(before, during) {
+  let calls = 0;
+  return { tasks: { getTasksId: async ({ query }) => {
+    assert.match(query.include, /grade_attempts/);
+    const attempts = calls++ === 0 ? before : during;
+    return { ok: true, status: 200, data: { task: { id: 4242 }, grade: { attempts } } };
+  } } };
+}
+
+test('a worker that clears the local ledger is still capped by the server count', async () => {
+  const old = attempt('2026-10-01T09:00:00.000Z', false);   // a PREVIOUS run's round — not this run's
+  const h = harness({
+    ledger: { id: 4242, status: 'completed', updated_at: new Date().toISOString() },
+    api: serverApi([old], [old, attempt('2026-10-02T10:00:00.000Z', false), attempt('2026-10-02T10:20:00.000Z', false)]),
+    // Records NOTHING locally — as if it ran ship.js with the ledger env cleared.
+    spawnWorker: async () => ({ envelope: { is_error: false, result: '', structured_output: {
+      outcome: 'shipped', task_id: 4242, what_happened: 'kept going', undetermined_decisions: [],
+    } }, exitCode: 0 }),
+  });
+  h.deps.gradeLedgerPath = () => join(mkdtempSync(join(tmpdir(), 'abgcap-')), 'run.jsonl');
+  const row = await runner.iteration(opts, h.deps);
+  assert.equal(row.outcome, 'needs_human');
+  assert.equal(row.grade_count_source, 'server');
+  assert.equal(row.grade_rounds, 2, 'the round from before this run started is not counted');
+  assert.equal(row.grade_cap_reached, true);
+});
+
+test('server rounds where every gating worker errored are outages, not fails', async () => {
+  const h = harness({
+    ledger: { id: 4242, status: 'completed', updated_at: new Date().toISOString() },
+    api: serverApi([], [attempt('2026-10-02T10:00:00.000Z', false), attempt('2026-10-02T10:05:00.000Z', false, { outage: true })]),
+  });
+  h.deps.gradeLedgerPath = () => join(mkdtempSync(join(tmpdir(), 'abgcap-')), 'run.jsonl');
+  const row = await runner.iteration(opts, h.deps);
+  assert.notEqual(row.outcome, 'needs_human');
+  assert.equal(row.grade_rounds, 1);
+  assert.equal(row.grade_outages, 1);
+  assert.equal(row.grade_cap_reached, false);
+});
+
+test('spawnWorker hands the ledger to the worker in env and stops it once the cap is reached', async () => {
+  const { EventEmitter } = await import('node:events');
+  const file = join(mkdtempSync(join(tmpdir(), 'abgcap-')), 'run.jsonl');
+  let env = null; let killed = false;
+  const spawn = (_bin, _args, o) => {
+    env = o.env;
+    const child = new EventEmitter();
+    child.stdout = new EventEmitter(); child.stderr = new EventEmitter();
+    child.stdin = { end: () => {
+      // The worker's ship.js records its second graded FAIL, then the worker keeps going.
+      for (const g of [fakeGrade(false), fakeGrade(false)]) gradeCapLib.recordGradeOutcome({ taskId: 4242, grade: g, env: o.env });
+    } };
+    child.kill = () => { killed = true; setImmediate(() => child.emit('close', null)); };
+    return child;
+  };
+  const capCheck = async () => gradeCapLib.gradeCapState(gradeCapLib.readLedger(file), 4242);
+  const res = await runner.spawnWorker({
+    task: aTask, model: 'm', timeoutMs: 60_000, cwd: process.cwd(), gradeLedger: file, capCheck,
+    deps: { spawn, resolveBin: () => ({ bin: 'claude', shell: false }), sessionId: 's', capWatchMs: 5 },
+  });
+  assert.equal(env[gradeCapLib.LEDGER_ENV], file);
+  assert.equal(killed, true, 'a worker past the cap is stopped, not left to keep paying for rounds');
+  assert.equal(res.gradeCapped, true);
+  assert.equal(res.timedOut, false);
+});
+
+// ── slow lands are re-checked every loop, across restarts (task 1004538) ──────
+
+test('forever re-checks pending lands once per loop, and a failing check never stops it', async () => {
+  let calls = 0;
+  const rows = [];
+  const code = await runner.forever({ goals: [], maxTasks: 1, maxLoops: 3 }, {
+    iteration: async () => ({ event: 'hold', reason: 'test' }),
+    reconcileLeftoverClaims: async () => ({ event: 'boot_reconcile', ok: true }),
+    waitOrJump: async () => ({ waited: 0, jumped: false }),
+    writeHeartbeat: () => true,
+    postHeartbeat: async () => true,
+    emit: () => {},
+    record: (r) => { rows.push(r); return r; },
+    codeDrifted: async () => false,
+    loadedHead: async () => null,
+    recheckLands: async () => { calls += 1; if (calls === 2) throw new Error('fetch failed'); return {}; },
+  });
+  assert.equal(code, 0);
+  assert.equal(calls, 3, 'every loop, not just at boot');
+  assert.ok(rows.some((r) => r.event === 'land_recheck_failed' && /fetch failed/.test(r.errors.join(' '))));
+});
+
+test('main() arms the land re-check for --forever', () => {
+  const src = readFileSync(new URL('../scripts/gds/autobongos-run.js', import.meta.url), 'utf8');
+  const line = src.split('\n').find((l) => l.includes('if (opts.forever) return forever('));
+  assert.match(line, /recheckLands: true/, 'without this the runner never re-probes a slow land');
+});
+
+test('a pending land survives a restart: the run log names it, the ledger clocks it, the blocker closes', async () => {
+  // A FRESH process: nothing in memory. Only the run log on disk says task 77
+  // was pending, and only the database says blocker 500 is open for task 78.
+  const dir = mkdtempSync(join(tmpdir(), 'autobongos-lands-'));
+  process.env.AUTOBONGOS_LOG_FILE = join(dir, 'runs.jsonl');
+  try {
+    writeFileSync(process.env.AUTOBONGOS_LOG_FILE, [
+      JSON.stringify({ event: 'worked', task_id: '77', ledger_shape: 'pending_land' }),
+      JSON.stringify({ event: 'worked', task_id: '76', ledger_shape: 'shipped' }),
+      '{"event":"worked","task_id":"75","ledger_sh',   // the half line a kill -9 leaves
+    ].join('\n'));
+    const recorded = [];
+    const resolved = [];
+    const probed = [];
+    const api = {
+      tasks: { getTasksId: async ({ id }) => ({ ok: true, data: { task: { id: String(id), status: 'shipped', shipped_at: new Date(Date.now() - 3600_000).toISOString() } } }) },
+      blockers: {
+        getBlockers: async () => ({ ok: true, data: { blockers: [{ id: '500', source: 'autobongos', source_ref: 'task-78-shipped_no_artifact', status: 'open' }] } }),
+        postBlockersIdResolve: async ({ id }) => { resolved.push(String(id)); return { ok: true, data: {} }; },
+      },
+    };
+    await runner.recheckPendingLands({
+      api,
+      state: runner.newRunnerState(),
+      record: (r) => { recorded.push(r); return r; },
+      landDeps: { probeArtifact: async (id) => { probed.push(String(id)); return { checked: true, onMain: true, sha: 'abc123def456', subject: `Merge from x/task-${id}` }; } },
+    });
+    assert.deepEqual(probed.sort(), ['77', '78'], 'only the pending task and the open blocker are probed');
+    const re = recorded.find((r) => r.event === 'land_recheck');
+    assert.equal(re.task_id, '77');
+    assert.equal(re.ledger_shape, 'shipped', 'the land arrived, so the next pass drops it from the pending list');
+    assert.deepEqual(resolved, ['500']);
+    assert.ok(recorded.some((r) => r.event === 'land_blocker_resolved' && r.blocker_id === '500'));
+  } finally { delete process.env.AUTOBONGOS_LOG_FILE; }
+});
+
+test('the blocker sweep runs at most hourly; with nothing pending, the loops between cost nothing', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'autobongos-sweep-'));
+  process.env.AUTOBONGOS_LOG_FILE = join(dir, 'runs.jsonl');   // empty: nothing pending
+  try {
+    let lists = 0;
+    let now = 1_000_000_000_000;
+    const deps = {
+      state: runner.newRunnerState(),
+      now: () => now,
+      record: (r) => r,
+      api: { tasks: {}, blockers: { getBlockers: async () => { lists += 1; return { ok: true, data: { blockers: [] } }; } } },
+      landDeps: { probeArtifact: async () => notOnMainRow },
+    };
+    const notOnMainRow = { checked: true, onMain: false, sha: null, subject: null };
+    await runner.recheckPendingLands(deps);
+    now += 5 * 60 * 1000;
+    await runner.recheckPendingLands(deps);
+    assert.equal(lists, 1, 'a second sweep five minutes later is wasted I/O');
+    now += runner.LAND_SWEEP_MS;
+    await runner.recheckPendingLands(deps);
+    assert.equal(lists, 2, 'an hour on, it sweeps again');
+  } finally { delete process.env.AUTOBONGOS_LOG_FILE; }
+});

package/tests/autobongos_verify.mjs

@@ -102,7 +102,9 @@ test('an unparseable updated_at still gets a shape — quiet is the wrong failur
 // ── the incident this exists for ───────────────────────────────────────────────
 
 test('shipped with nothing on main is called out, not celebrated', () => {
-  const v = classifyLedger({ task: task(), artifact: notOnMain, nowMs: NOW });
+  // Past the land grace window (task 1004538) — inside it the same facts are
+  // `pending_land`, covered below.
+  const v = classifyLedger({ task: task({ shipped_at: '2026-09-16T12:00:00.000Z' }), artifact: notOnMain, nowMs: NOW });
   assert.equal(v.shape, 'shipped_no_artifact');
   assert.equal(v.verified, false);
   assert.equal(v.fileBlocker, true);
@@ -199,16 +201,44 @@ test('the artifact probe reads main, fixed-string, for the ship-commit conventio
   const git = async (args) => {
     calls.push(args);
     if (args[0] === 'fetch') return { ok: true, stdout: '', stderr: '' };
-    return { ok: true, stdout: 'deadbeefcafe1234 feat: the thing (task 42)\n', stderr: '' };
+    return { ok: true, stdout: 'deadbeefcafe1234\x1ffeat: the thing (task 42)\x1f\x1e\n', stderr: '' };
   };
   const r = await probeArtifact(42, { git });
   assert.deepEqual(r, { checked: true, onMain: true, sha: 'deadbeefcafe1234', subject: 'feat: the thing (task 42)' });
   assert.deepEqual(calls[0], ['fetch', '-q', 'origin', 'main']);
   assert.ok(calls[1].includes('-F'), 'the pattern is a fixed string, not a regex');
-  assert.ok(calls[1].includes('--grep=(task 42)'));
+  assert.ok(calls[1].includes('--grep=42'), 'git narrows by the bare id; the exact match is made in JS');
   assert.ok(calls[1].includes('FETCH_HEAD'), 'read what was just fetched, not a stale local ref');
 });
 
+// task 1004538 — the commits PR 1456 landed for task 1004513 never wrote the
+// literal `(task 1004513)`: the merge subject names the BRANCH
+// (`…/autobongos-1004513-978953`) and a body line says "task 1004513 makes…".
+// The old `(task N)`-only grep therefore said "no artifact" even AFTER the land,
+// so no grace window alone could ever have cleared that blocker.
+test('the probe recognises a ship branch in a merge subject and a body mention', async () => {
+  const log = (rows) => async (args) => (args[0] === 'fetch'
+    ? { ok: true, stdout: '', stderr: '' }
+    : { ok: true, stdout: rows.map(([h, s, b]) => `${h}\x1f${s}\x1f${b || ''}\x1e\n`).join(''), stderr: '' });
+  const merge = await probeArtifact(1004513, { git: log([['3d50a6289', 'Merge pull request #1456 from octo/autobongos-1004513-978953']]) });
+  assert.equal(merge.onMain, true);
+  assert.equal(merge.sha, '3d50a6289');
+  const manual = await probeArtifact(1004440, { git: log([['a55b7707e', 'Merge pull request #1471 from octo/task-1004440']]) });
+  assert.equal(manual.onMain, true);
+  const body = await probeArtifact(1004513, { git: log([['301df048f', 'docs(lifecycle): a note', 'Fixes the goal close.\n\nRefs (task 1004513).']]) });
+  assert.equal(body.onMain, true, 'the `(task N)` convention still counts in a body');
+  // A body that merely DISCUSSES the task is another task's commit talking about
+  // it — not an artifact. (This task's own commits mention task 1004513.)
+  const talk = await probeArtifact(1004513, { git: log([['dddd', 'fix(verify): slow lands (task 1004538)', 'task 1004513 was flagged too early']]) });
+  assert.equal(talk.onMain, false);
+  // A longer id that merely STARTS with this one is not this task.
+  const prefix = await probeArtifact(1004513, { git: log([['aaaa', 'fix: thing (task 10045139)'], ['bbbb', 'Merge from x/task-10045130']]) });
+  assert.equal(prefix.onMain, false);
+  // Nor is a bare number with no `task` before it (a PR number, a row count).
+  const bare = await probeArtifact(1004513, { git: log([['cccc', 'chore: bump 1004513 rows']]) });
+  assert.equal(bare.onMain, false);
+});
+
 test('a failed fetch reports `checked: false`, never `onMain: false`', async () => {
   const git = async (args) => (args[0] === 'fetch'
     ? { ok: false, stdout: '', stderr: 'fatal: could not read from remote' }
@@ -345,3 +375,209 @@ test('a thrown client error is a read failure, not a crash', async () => {
   assert.equal(out.halt, true);
   assert.match(out.read_error, /fetch failed/);
 });
+
+// ── a slow land is not a missing artifact (task 1004538) ───────────────────────
+//
+// Task 1004513 was flagged `shipped_no_artifact` at 22:24Z and its merge landed
+// ~11 hours later; the owner got a false alarm (blocker 1000185). A shipped task
+// with nothing on main is first `pending_land`. The clock is the LEDGER's
+// `shipped_at`, so a runner restart cannot reset it.
+
+const { LAND_GRACE_MS, recheckLands, pendingLandIds } = verify;
+const shippedAgo = (ms) => task({ shipped_at: new Date(NOW - ms).toISOString(), updated_at: new Date(NOW - ms).toISOString() });
+
+test('(1) inside the grace window, a missing artifact is pending_land and files NO blocker', async () => {
+  assert.ok(LAND_GRACE_MS >= 12 * 3600_000, 'the land pipeline can take hours on a red main — 1004513 took ~11');
+  const v = classifyLedger({ task: shippedAgo(11 * 3600_000), artifact: notOnMain, nowMs: NOW });
+  assert.equal(v.shape, 'pending_land');
+  assert.equal(v.verified, false, 'not yet a fact');
+  assert.equal(v.fileBlocker, false);
+  assert.equal(v.releaseClaim, false);
+  assert.equal(v.halt, false);
+
+  let filed = 0;
+  const out = await verifyShip({ taskId: 1003903 }, {
+    api: fakeApi(), task: shippedAgo(60_000), nowMs: NOW,
+    probeArtifact: async () => notOnMain,
+    fileBlocker: async () => { filed += 1; return { filed: true, blockerId: 9 }; },
+  });
+  assert.equal(out.shape, 'pending_land');
+  assert.equal(filed, 0, 'no owner blocker for a land that is merely slow');
+  assert.equal(out.blocker, null);
+});
+
+test('(2) past the grace window, a still-missing artifact files the blocker', async () => {
+  const v = classifyLedger({ task: shippedAgo(LAND_GRACE_MS + 60_000), artifact: notOnMain, nowMs: NOW });
+  assert.equal(v.shape, 'shipped_no_artifact');
+  assert.equal(v.fileBlocker, true);
+
+  const rows = [];
+  const out = await verifyShip({ taskId: 1003903 }, {
+    api: fakeApi(), task: shippedAgo(LAND_GRACE_MS + 60_000), nowMs: NOW,
+    probeArtifact: async () => notOnMain,
+    fileBlocker: async (_a, row) => { rows.push(row); return { filed: true, blockerId: 9 }; },
+  });
+  assert.equal(out.shape, 'shipped_no_artifact');
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].source_ref, 'task-1003903-shipped_no_artifact', 'the dedupe key the resolve sweep matches on');
+});
+
+test('the grace clock is shipped_at, and an unreadable clock does not hide a missing artifact', () => {
+  // updated_at moves on every touch; shipped_at is when the ship happened.
+  const t = task({ shipped_at: new Date(NOW - LAND_GRACE_MS - 1000).toISOString(), updated_at: new Date(NOW - 1000).toISOString() });
+  assert.equal(classifyLedger({ task: t, artifact: notOnMain, nowMs: NOW }).shape, 'shipped_no_artifact');
+  const undated = task({ shipped_at: null, updated_at: 'not a date' });
+  assert.equal(classifyLedger({ task: undated, artifact: notOnMain, nowMs: NOW }).shape, 'shipped_no_artifact',
+    'with no clock the grace cannot be measured, so this stays as strict as it was');
+});
+
+test('a pending land that later appears on main verifies as shipped', () => {
+  assert.equal(classifyLedger({ task: shippedAgo(3600_000), artifact: onMain, nowMs: NOW }).shape, 'shipped');
+});
+
+// ── re-probing across iterations, and across a restart ─────────────────────────
+
+test('pendingLandIds reads the run log: the LATEST verdict per task decides', () => {
+  const rows = [
+    { event: 'worked', task_id: '1', ledger_shape: 'pending_land' },
+    { event: 'worked', task_id: '2', ledger_shape: 'pending_land' },
+    { event: 'land_recheck', task_id: '2', ledger_shape: 'shipped' },
+    { event: 'worked', task_id: '3', ledger_shape: 'shipped' },
+    { event: 'land_recheck', task_id: '4', ledger_shape: 'pending_land' },
+    { event: 'cadence', mode: 'full' },
+    { event: 'worked', task_id: '5', ledger_shape: 'pending_land' },
+    { event: 'land_recheck', task_id: '5', ledger_shape: 'shipped_no_artifact' },
+    null, 'garbage',
+  ];
+  assert.deepEqual(pendingLandIds(rows).sort(), ['1', '4']);
+  assert.deepEqual(pendingLandIds([]), []);
+});
+
+const blockerApi = (open, resolved) => ({
+  tasks: { getTasksId: async ({ id }) => ({ ok: true, data: { task: { ...shippedAgo(3600_000), id: String(id) } } }) },
+  blockers: {
+    getBlockers: async () => ({ ok: true, data: { blockers: open } }),
+    postBlockersIdResolve: async ({ id, body }) => { resolved.push({ id: String(id), note: body.resolution_note }); return { ok: true, data: {} }; },
+  },
+});
+
+test('(3) an already-filed no-artifact blocker is resolved once main carries the commit', async () => {
+  const resolved = [];
+  const open = [
+    { id: '1000185', source: 'autobongos', source_ref: 'task-1004513-shipped_no_artifact', status: 'open' },
+    { id: '1000186', source: 'autobongos', source_ref: 'task-1004514-shipped_no_artifact', status: 'open' },
+    { id: '1000187', source: 'autobongos', source_ref: 'task-1004515-still_held', status: 'open' },
+    { id: '1000188', source: 'manual', source_ref: 'task-1004516-shipped_no_artifact', status: 'open' },
+  ];
+  const probed = [];
+  const out = await recheckLands({ pendingIds: [] }, {
+    api: blockerApi(open, resolved), nowMs: NOW,
+    probeArtifact: async (id) => {
+      probed.push(String(id));
+      return String(id) === '1004513'
+        ? { checked: true, onMain: true, sha: '3d50a6289abc', subject: 'Merge pull request #1456 from octo/autobongos-1004513-978953' }
+        : notOnMain;
+    },
+  });
+  assert.deepEqual(resolved.map((r) => r.id), ['1000185'], 'only the autobongos no-artifact blocker whose commit is now on main');
+  assert.match(resolved[0].note, /3d50a628/);
+  assert.match(resolved[0].note, /task 1004513/);
+  assert.deepEqual(probed.sort(), ['1004513', '1004514'], 'other shapes and other sources are not this sweep’s business');
+  assert.deepEqual(out.resolved.map((r) => r.blocker_id), ['1000185']);
+});
+
+test('a probe that could not run never resolves a blocker', async () => {
+  const resolved = [];
+  await recheckLands({ pendingIds: [] }, {
+    api: blockerApi([{ id: '7', source: 'autobongos', source_ref: 'task-42-shipped_no_artifact' }], resolved), nowMs: NOW,
+    probeArtifact: async () => ({ checked: false, reason: 'no network' }),
+  });
+  assert.deepEqual(resolved, []);
+});
+
+test('recheckLands re-verifies each pending task: quiet inside the window, a blocker after it', async () => {
+  const filed = [];
+  const deps = (ageMs) => ({
+    api: {
+      tasks: { getTasksId: async ({ id }) => ({ ok: true, data: { task: { ...shippedAgo(ageMs), id: String(id) } } }) },
+      blockers: { getBlockers: async () => ({ ok: true, data: { blockers: [] } }) },
+    },
+    nowMs: NOW, probeArtifact: async () => notOnMain,
+    fileBlocker: async (_a, row) => { filed.push(row.source_ref); return { filed: true, blockerId: 11 }; },
+  });
+  const early = await recheckLands({ pendingIds: ['42'] }, deps(3600_000));
+  assert.deepEqual(early.rechecked.map((r) => r.ledger_shape), ['pending_land']);
+  assert.deepEqual(filed, []);
+  const late = await recheckLands({ pendingIds: ['42'] }, deps(LAND_GRACE_MS + 1000));
+  assert.deepEqual(late.rechecked.map((r) => r.ledger_shape), ['shipped_no_artifact']);
+  assert.deepEqual(filed, ['task-42-shipped_no_artifact']);
+  assert.equal(late.rechecked[0].blocker_id, 11);
+});
+
+test('one pass fetches main ONCE, however many tasks and blockers it probes', async () => {
+  const calls = [];
+  const git = async (args) => {
+    calls.push(args[0]);
+    if (args[0] === 'fetch') return { ok: true, stdout: '', stderr: '' };
+    const id = args.find((a) => a.startsWith('--grep=')).slice(7);
+    return { ok: true, stdout: `abc${id}\x1fMerge from x/task-${id}\x1f\x1e\n`, stderr: '' };
+  };
+  const resolved = [];
+  const api = blockerApi([
+    { id: '1', source: 'autobongos', source_ref: 'task-201-shipped_no_artifact' },
+    { id: '2', source: 'autobongos', source_ref: 'task-202-shipped_no_artifact' },
+  ], resolved);
+  await recheckLands({ pendingIds: ['101', '102', '201'] }, { api, git, nowMs: NOW });
+  assert.equal(calls.filter((c) => c === 'fetch').length, 1, 'one fetch per pass, not one per id');
+  assert.equal(calls.filter((c) => c === 'log').length, 4, 'one log per DISTINCT id (201 is both pending and blocked)');
+  assert.deepEqual(resolved.map((r) => r.id).sort(), ['1', '2']);
+});
+
+test('nothing to probe means no git at all, and a failed fetch resolves nothing', async () => {
+  let gitCalls = 0;
+  await recheckLands({ pendingIds: [], sweepBlockers: false }, {
+    api: { tasks: {}, blockers: {} }, git: async () => { gitCalls += 1; return { ok: true, stdout: '' }; }, nowMs: NOW,
+  });
+  assert.equal(gitCalls, 0);
+
+  const resolved = [];
+  const out = await recheckLands({ pendingIds: [] }, {
+    api: blockerApi([{ id: '9', source: 'autobongos', source_ref: 'task-301-shipped_no_artifact' }], resolved), nowMs: NOW,
+    git: async (args) => (args[0] === 'fetch' ? { ok: false, stderr: 'fatal: unreachable' } : { ok: true, stdout: 'x\x1fMerge from x/task-301\x1f\x1e' }),
+  });
+  assert.deepEqual(resolved, [], 'not looking is not evidence the commit landed either');
+  assert.deepEqual(out.resolved, []);
+});
+
+test('the blocker list pages by the route’s total, and says so when it gives up', async () => {
+  let gets = 0;
+  const paged = {
+    tasks: {},
+    blockers: {
+      getBlockers: async ({ query }) => {
+        gets += 1;
+        const rows = query.offset === 0
+          ? Array.from({ length: 200 }, (_, i) => ({ id: String(i), source: 'manual', source_ref: null }))
+          : [{ id: '900', source: 'autobongos', source_ref: 'task-55-shipped_no_artifact' }];
+        return { ok: true, data: { blockers: rows, page: { limit: 200, offset: query.offset, total: 201 } } };
+      },
+      postBlockersIdResolve: async () => ({ ok: true }),
+    },
+  };
+  const probed = [];
+  await recheckLands({ pendingIds: [] }, { api: paged, nowMs: NOW, probeArtifact: async (id) => { probed.push(id); return notOnMain; } });
+  assert.equal(gets, 2, 'page two holds the 201st row');
+  assert.deepEqual(probed, ['55']);
+
+  const endless = { tasks: {}, blockers: { getBlockers: async ({ query }) => ({ ok: true, data: { blockers: Array.from({ length: 200 }, (_, i) => ({ id: String(query.offset + i), source: 'manual' })), page: { total: 1e9 } } }) } };
+  const out = await recheckLands({ pendingIds: [] }, { api: endless, nowMs: NOW, probeArtifact: async () => notOnMain });
+  assert.match(out.errors.join(' '), /stopped paging/, 'a cap that is hit must say so, not read as "looked everywhere"');
+});
+
+test('an unreadable blocker list is reported, not thrown', async () => {
+  const out = await recheckLands({ pendingIds: [] }, {
+    api: { tasks: {}, blockers: { getBlockers: async () => { throw new Error('fetch failed'); } } }, nowMs: NOW,
+    probeArtifact: async () => notOnMain,
+  });
+  assert.match(out.errors.join(' '), /fetch failed/);
+});