@bongos/core 1.21.175 → 1.21.177

package/scripts/gds/stale-worktrees.js

@@ -1,212 +1,7 @@
 #!/usr/bin/env node
-// scripts/gds/stale-worktrees.js — the worktrees whose work already landed.
-//
-// Worktree-per-claim (task 1642, enforced at claim time by worktree-claim-guard.js)
-// means every shipped task leaves a `.claude/worktrees/task-N` behind unless someone
-// removes it. Nothing did: the 2026-08-29 audit (task 1003365) found 74 dirs for 70
-// shipped tasks. A stale worktree costs disk, slows `git worktree list`, and — the
-// real hazard — tempts a builder into `git worktree remove`, which follows the
-// node_modules junction into the SHARED node_modules (task 1002809).
-//
-// "Stale" needs no API call: a worktree is stale when its branch is already an
-// ancestor of origin/main (the land happened) or its branch is gone (the ship
-// deleted it). Both are pure git facts, so this runs in well under a second at
-// SessionStart. The primary checkout is never listed.
-//
-// THE THIRD LEAK — UNSTARTED CLAIM TREES (task 1003912). "Ancestor of origin/main"
-// is also true of a branch that is origin/main, which is exactly what
-// `worktree.js add` leaves behind: it branches off origin/main and commits
-// nothing. So between `worktree.js add` and the builder's FIRST COMMIT, a live
-// claim's worktree was reported as "merged into main". Observed 2026-09-13: the
-// session working task 1002594 saw its own tree listed as stale. The classifier
-// had the git fact right and the intent wrong — nothing had landed, nothing had
-// even started.
-//
-// That window is small and the consequence is not: /worktree-clean removes every
-// name on the stale list, so a cleanup run by another session (or the SessionStart
-// nag) inside it would take a live claim's tree. `worktree.js remove` refuses a
-// dirty tree, which bounds the damage — but a claim worktree that is still empty
-// is precisely the one that is NOT dirty, so the guard does not cover this case.
-//
-// The fix stays a pure git fact, keeping the "no API call" property this header is
-// explicit about wanting: a branch whose TIP EQUALS origin/main is zero commits
-// ahead, so it cannot have landed anything, and is reported live-but-unstarted.
-// The alternative — cross-checking branch names against active claims — would put
-// a network round trip in a SessionStart probe to learn something git already
-// knows.
-//
-// THE SECOND LEAK — HUSKS (task 1002594). Under OneDrive, `git worktree remove`
-// often errors 'Permission denied' / 'Device or resource busy' but still
-// DEREGISTERS the worktree, so `worktree.js remove` treats deregistration as
-// success and tells the builder the locked directory "deletes on its own later".
-// Nothing ever deleted it. That residue is invisible to the scan above BY
-// CONSTRUCTION: a deregistered husk is, by definition, absent from
-// `git worktree list`, which is the only thing classifyWorktrees reads. Measured
-// on 2026-09-13 in this checkout: 20 directories under .claude/worktrees/, 13
-// registered — 7 husks that no probe had ever named. So the husk scan reads the
-// DISK and subtracts what git knows: the mirror image of the stale scan.
-//
-// Usage:
-//   node scripts/gds/stale-worktrees.js --line   # ONE line, or nothing; always exit 0
-//   node scripts/gds/stale-worktrees.js --json   # { stale: [...], live: [...], husks: [...] }
-//   node scripts/gds/stale-worktrees.js          # human report; exit 0 clean, 1 stale/husks found
-//
-// Removal is deliberately NOT here — `/worktree-clean` walks these lists through
-// `node scripts/gds/worktree.js remove <name>` and `worktree.js prune-husks`,
-// the junction-safe paths.
-
+// scripts/gds/stale-worktrees.js — @bongos-forwarder (task 1004848). Generated by
+// scripts/bongos/codemod-rename-scripts-gds.js; do not edit.
+// The real script is scripts/bongos/stale-worktrees.js. This forwarder keeps callers that still name
+// the old path working, and warns once so they get repointed. Task 1003706 removes it.
 'use strict';
-
-const { execFileSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-const MAIN_REF = 'origin/main';
-// Where worktree.js add puts a worktree by default; the only place husks collect.
-const WORKTREES_SUBDIR = path.join('.claude', 'worktrees');
-
-function git(args, cwd) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
-}
-
-// Parse `git worktree list --porcelain` into [{path, branch|null, isMain}].
-function parseWorktreeList(porcelain) {
-  const out = [];
-  let cur = null;
-  for (const raw of String(porcelain).split('\n')) {
-    const line = raw.trim();
-    if (line.startsWith('worktree ')) {
-      cur = { path: line.slice('worktree '.length), branch: null, isMain: out.length === 0 };
-      out.push(cur);
-    } else if (cur && line.startsWith('branch ')) {
-      cur.branch = line.slice('branch '.length).replace(/^refs\/heads\//, '');
-    }
-  }
-  return out;
-}
-
-// Pure classifier so the decision is unit-testable without a repo: `isMerged(branch)`
-// and `branchExists(branch)` are the two git facts it needs.
-// `isUnstarted(branch)` is the task 1003912 guard: branch tip === origin/main tip.
-// It is checked BEFORE isMerged because every unstarted branch is also trivially
-// "merged" — that coincidence is the whole bug, and order is what separates them.
-// Optional, so a caller that does not supply it gets the old behaviour rather than
-// a crash.
-function classifyWorktrees(worktrees, { isMerged, branchExists, isUnstarted = () => false }) {
-  const stale = [];
-  const live = [];
-  for (const wt of worktrees) {
-    if (wt.isMain) continue;
-    const name = path.basename(wt.path);
-    if (!wt.branch) { live.push({ name, path: wt.path, branch: null }); continue; } // detached: not ours to judge
-    if (!branchExists(wt.branch)) stale.push({ name, path: wt.path, branch: wt.branch, why: 'branch gone' });
-    else if (isUnstarted(wt.branch)) live.push({ name, path: wt.path, branch: wt.branch, why: 'unstarted (no commits yet)' });
-    else if (isMerged(wt.branch)) stale.push({ name, path: wt.path, branch: wt.branch, why: 'merged into main' });
-    else live.push({ name, path: wt.path, branch: wt.branch });
-  }
-  return { stale, live };
-}
-
-// Directories sitting in .claude/worktrees/ that git does not list as a worktree —
-// the deregister-then-never-delete residue. Pure (the directory listing and the
-// registered paths are both injected) so the set arithmetic is testable without
-// creating directories. Case- and separator-insensitive on both sides, because the
-// porcelain and fs.readdirSync disagree about drive-letter case on Windows.
-function classifyHusks({ dirNames, worktreePaths, worktreesRoot }) {
-  const norm = (p) => path.resolve(p).replace(/\\/g, '/').toLowerCase();
-  const registered = new Set(worktreePaths.map(norm));
-  return dirNames
-    .filter((name) => !registered.has(norm(path.join(worktreesRoot, name))))
-    .sort()
-    .map((name) => ({ name, path: path.join(worktreesRoot, name) }));
-}
-
-// FOUR git calls total, whatever the worktree count: the worktree list, every local
-// branch WITH ITS TIP (one read, both facts — task 1003912), every branch already
-// merged into origin/main, and origin/main's own tip. Per-worktree subprocesses
-// would be N+1 over exactly the number this probe exists to shrink.
-function refNames(out) {
-  return new Set(String(out).split('\n').map((s) => s.trim()).filter(Boolean));
-}
-
-function scan(cwd) {
-  const worktrees = parseWorktreeList(git(['worktree', 'list', '--porcelain'], cwd));
-  // ONE read of refs/heads/, carrying both facts it is asked for: which branches
-  // exist, and where each one points. The tip is what the task 1003912 guard needs
-  // (equal to origin/main's ⇒ zero commits ahead ⇒ nothing has landed from it,
-  // because nothing has been written in it) and asking for it separately would
-  // have spawned a second subprocess over the identical ref set — in the one file
-  // whose header makes a promise about its git-call count.
-  const tipOf = new Map();
-  for (const line of git(['for-each-ref', '--format=%(refname:short) %(objectname)', 'refs/heads/'], cwd).split('\n')) {
-    const [name, sha] = line.trim().split(/\s+/);
-    if (name && sha) tipOf.set(name, sha);
-  }
-  const existing = new Set(tipOf.keys());
-  let merged;
-  try { merged = refNames(git(['branch', '--merged', MAIN_REF, '--format=%(refname:short)'], cwd)); }
-  catch { merged = new Set(); } // no origin/main yet (fresh clone, no fetch) → nothing is provably stale
-  let mainTip = null;
-  try { mainTip = git(['rev-parse', MAIN_REF], cwd).trim(); }
-  catch { mainTip = null; } // same fail-open as `merged`: unknown ⇒ claim nothing
-  const r = classifyWorktrees(worktrees, {
-    branchExists: (b) => existing.has(b),
-    isMerged: (b) => merged.has(b),
-    isUnstarted: (b) => Boolean(mainTip) && tipOf.get(b) === mainTip,
-  });
-  // The main checkout is always the first porcelain entry, so the husk directory is
-  // derivable without a second git call.
-  const mainRoot = worktrees.length ? worktrees[0].path : cwd;
-  const worktreesRoot = path.join(mainRoot, WORKTREES_SUBDIR);
-  let dirNames = [];
-  try {
-    dirNames = fs.readdirSync(worktreesRoot, { withFileTypes: true })
-      .filter((d) => d.isDirectory()).map((d) => d.name);
-  } catch { dirNames = []; } // no worktrees dir yet → no husks, not an error
-  r.husks = classifyHusks({ dirNames, worktreePaths: worktrees.map((w) => w.path), worktreesRoot });
-  return r;
-}
-
-function namesOf(list) {
-  const names = list.slice(0, 6).map((s) => s.name).join(', ');
-  return names + (list.length > 6 ? ` +${list.length - 6} more` : '');
-}
-
-function lineFor(r) {
-  const husks = r.husks || [];
-  const parts = [];
-  if (r.stale.length) {
-    parts.push(`Stale worktrees: ${r.stale.length} whose work already landed (${namesOf(r.stale)}). `
-      + 'Run /worktree-clean — never `git worktree remove` (it follows the node_modules junction).');
-  }
-  if (husks.length) {
-    parts.push(`Worktree husks: ${husks.length} deregistered dir(s) still on disk (${namesOf(husks)}). `
-      + 'Run node scripts/gds/worktree.js prune-husks.');
-  }
-  return parts.join(' ');
-}
-
-function main() {
-  const argv = process.argv.slice(2);
-  const cwd = process.cwd();
-  let r;
-  try { r = scan(cwd); } catch (e) {
-    if (argv.includes('--line')) process.exit(0); // fail-open: a probe never blocks a session
-    console.error(`stale-worktrees: undetermined — ${e.message || e}`);
-    process.exit(2);
-  }
-  if (argv.includes('--json')) { console.log(JSON.stringify(r, null, 2)); return; }
-  if (argv.includes('--line')) { const l = lineFor(r); if (l) console.log(l); return; }
-  const husks = r.husks || [];
-  console.log(`  Worktrees: ${r.live.length} live, ${r.stale.length} stale, ${husks.length} husks`);
-  for (const s of r.stale) console.log(`    stale  ${s.name}  (${s.why})`);
-  for (const h of husks) console.log(`    husk   ${h.name}  (on disk, not registered)`);
-  for (const l of r.live) console.log(`    live   ${l.name}  [${l.branch || 'detached'}]${l.why ? `  (${l.why})` : ''}`);
-  if (r.stale.length) console.log('  Remove with: node scripts/gds/worktree.js remove <name>   (or /worktree-clean)');
-  if (husks.length) console.log('  Sweep husks with: node scripts/gds/worktree.js prune-husks');
-  if (r.stale.length || husks.length) process.exit(1);
-}
-
-if (require.main === module) main();
-
-module.exports = { parseWorktreeList, classifyWorktrees, classifyHusks, lineFor };
+require('../bongos/forwarder.js').forward(module, 'stale-worktrees.js');

package/scripts/gds/start-goals.js

@@ -1,102 +1,6 @@
-// scripts/gds/start-goals.js — /builder-start, goal-first (task 1002852).
-//
-// WHY. Work is organised in goals, but /builder-start opened on a flat list of
-// tasks, so a builder saw "task 1002852" and never which goal it served or which of
-// their own goals had work waiting. This leads with the goals the builder has
-// JOINED, then shows the same claimable table grouped under each task's goal.
-//
-// The owner's two rules (2026-10-08, WA6 chain kickoff):
-//   - the goals sit ABOVE the claimable table and never replace it, so nothing
-//     claimable is hidden from a builder who has joined no goal;
-//   - a task with no goal is listed under "Other work". Nothing is backfilled.
-//
-// PURE: no I/O. start.js fetches GET /goals (best-effort: a failed read groups by
-// goal id with a generic name and lists no joined goals) and hands both lists in.
-
+// scripts/gds/start-goals.js — @bongos-forwarder (task 1004848). Generated by
+// scripts/bongos/codemod-rename-scripts-gds.js; do not edit.
+// The real script is scripts/bongos/start-goals.js. This forwarder keeps callers that still name
+// the old path working, and warns once so they get repointed. Task 1003706 removes it.
 'use strict';
-
-const OTHER_WORK = 'Other work';
-const JOINED_SHOWN = 5;
-
-// The open goals this builder is a member of, in the board's own order (version,
-// sort order). `viewer_is_member` is the server's answer, never re-derived here.
-function joinedGoals(goals) {
-  return (Array.isArray(goals) ? goals : [])
-    .filter((g) => g && g.viewer_is_member === true && g.status === 'open');
-}
-
-function goalName(id, byId) {
-  const g = byId.get(String(id));
-  return (g && g.title) || `Goal ${id}`;
-}
-
-// Group claimable rows by goal, keeping each row's place in the server's order
-// (priority, then estimate) inside its group. Groups run: the builder's joined
-// goals first (board order), then every other goal by its first row, then
-// "Other work" last. Every row lands in exactly one group, so the grouped table
-// lists precisely the rows the flat one did.
-function groupByGoal(rows, goals) {
-  const list = Array.isArray(rows) ? rows : [];
-  const byId = new Map((Array.isArray(goals) ? goals : []).map((g) => [String(g.id), g]));
-  const joinedOrder = joinedGoals(goals).map((g) => String(g.id));
-  const groups = new Map();
-  for (const t of list) {
-    const key = t.goal_id == null ? null : String(t.goal_id);
-    if (!groups.has(key)) {
-      groups.set(key, {
-        goal_id: key,
-        title: key == null ? OTHER_WORK : goalName(key, byId),
-        joined: key != null && joinedOrder.includes(key),
-        rows: [],
-      });
-    }
-    groups.get(key).rows.push(t);
-  }
-  const all = [...groups.values()];
-  const joined = joinedOrder.map((id) => groups.get(id)).filter(Boolean);
-  const others = all.filter((g) => g.goal_id != null && !g.joined);
-  const other = groups.get(null);
-  return [...joined, ...others, ...(other ? [other] : [])];
-}
-
-// The "Your goals" lines above the table: each joined goal and how many tasks in
-// it are claimable for this builder right now (from the FULL filtered set, not
-// the capped card rows, so a count never under-reports). Empty when the builder
-// has joined no open goal; the table below still lists everything.
-function yourGoals(goals, claimable) {
-  const counts = new Map();
-  for (const t of Array.isArray(claimable) ? claimable : []) {
-    if (t.goal_id == null) continue;
-    const k = String(t.goal_id);
-    counts.set(k, (counts.get(k) || 0) + 1);
-  }
-  const joined = joinedGoals(goals);
-  return {
-    goals: joined.slice(0, JOINED_SHOWN).map((g) => ({
-      id: String(g.id),
-      title: g.title || `Goal ${g.id}`,
-      claimable: counts.get(String(g.id)) || 0,
-    })),
-    more: Math.max(0, joined.length - JOINED_SHOWN),
-  };
-}
-
-// Goal-first ordering for the capped card: rows in a goal the builder joined come
-// first, everything else after, each half keeping the server's order. Without it
-// the card's top rows were the board's top rows and a builder's own goals could
-// show "5 to claim" above a table holding none of them. A stable partition, so it
-// only moves rows, never drops one.
-function joinedFirst(rows, goals) {
-  const list = Array.isArray(rows) ? rows : [];
-  const joined = new Set(joinedGoals(goals).map((g) => String(g.id)));
-  const mine = [];
-  const rest = [];
-  for (const t of list) (t.goal_id != null && joined.has(String(t.goal_id)) ? mine : rest).push(t);
-  return mine.concat(rest);
-}
-
-function claimableWord(n) {
-  return n === 0 ? 'nothing to claim right now' : `${n} to claim`;
-}
-
-module.exports = { OTHER_WORK, joinedGoals, joinedFirst, groupByGoal, yourGoals, claimableWord };
+require('../bongos/forwarder.js').forward(module, 'start-goals.js');