@bongos/core 1.21.112 → 1.21.114

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/autobongos-verify.js

@@ -39,6 +39,7 @@ const path = require('node:path');
 const { execFile } = require('node:child_process');
 
 const { classifyStrand, WATCHED } = require('./strand-watch.js');
+const { postWithAsk } = require('./ask.js');
 
 // failureReason — what a failed child process said, fit for one run-log field
 // (task 1004180).
@@ -264,6 +265,23 @@ function blockerFor(v, { taskId, taskTitle = null, worker = null } = {}) {
     body_md: lines.join('\n'),
     source: 'autobongos',
     source_ref: `task-${taskId}-${v.shape}`,
+    ask: blockerAsk(v, { taskId }),
+  };
+}
+
+// The card a person answers (task 1004704): the shape as one decidable question.
+// fileBlocker sends it beside the row and files without it if it is refused.
+function blockerAsk(v, { taskId }) {
+  const shape = String((v && v.shape) || 'unfinished').replace(/_/g, ' ');
+  return {
+    question: `Requeue task ${taskId}, which came back ${shape}?`,
+    options: [
+      { key: 'requeue', label: 'Requeue it', result: 'The blocker closes and a runner may pick it up again.', act: 'go ahead' },
+      { key: 'keep', label: 'Keep it out', result: 'It stays out of the pool until someone looks.', act: 'not now' },
+    ],
+    recommend: { key: 'keep', why: 'Read the run log first; a second run may fail the same way.' },
+    waits_on: 'lead:automation',
+    if_nobody_answers: 'The task stays out of the pool.',
   };
 }
 
@@ -351,7 +369,8 @@ async function fetchTask(api, taskId) {
 async function fileBlocker(api, row, { taskId, link }) {
   let created = null;
   try {
-    const r = await api.blockers.postBlockers({ body: row });
+    const { ask, ...body } = row;
+    const r = await postWithAsk((b) => api.blockers.postBlockers({ body: b }), body, ask);
     if (!r || !r.ok) return { filed: false, reason: `POST /blockers → ${r ? r.status : 'no response'}`, linked: false };
     if (r.data && r.data.skipped) return { filed: false, duplicate: true, reason: 'this task already carries a blocker of this shape', linked: false };
     created = r.data && r.data.blocker;
@@ -594,6 +613,6 @@ if (require.main === module) {
 }
 
 module.exports = {
-  classifyLedger, blockerFor, probeArtifact, fileBlocker, verifyShip, failureReason,
+  classifyLedger, blockerFor, blockerAsk, probeArtifact, fileBlocker, verifyShip, failureReason,
   LAND_GRACE_MS, namesTask, pendingLandIds, recheckLands,
 };

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();