@rtorcato/repo-tooling 3.44.0 → 4.0.0

package/dist/cli/commands/loop-env.js

@@ -1,76 +0,0 @@
-import path from 'node:path';
-import { LOGIN } from '../../base/agent-user.js';
-import { realGitExec } from '../../base/git-identity.js';
-import { realGhExec } from '../../base/github-settings.js';
-import { configuredAgentUser, defaultWorktreeRoot } from './loop-guard.js';
-export async function ghOut(gh, args) {
-    const r = await gh(args);
-    return r.ok ? r.stdout.trim() : '';
-}
-export async function resolveLoopEnv(options = {}) {
-    const dir = path.resolve(options.dir ?? process.cwd());
-    const git = options.git ?? ((args) => realGitExec(args, dir));
-    const gh = options.gh ?? ((args, stdin) => realGhExec(args, stdin, dir));
-    const env = options.env ?? process.env;
-    const warnings = [];
-    // Absolute, so the common dir is `<main checkout>/.git` from anywhere.
-    const common = (await git(['rev-parse', '--path-format=absolute', '--git-common-dir']))?.trim();
-    const root = common ? path.resolve(common, '..') : '';
-    if (!root)
-        warnings.push('not a git repository');
-    const worktreeRoot = root ? defaultWorktreeRoot(root) : '';
-    const ownerRepo = await ghOut(gh, [
-        'repo',
-        'view',
-        '--json',
-        'nameWithOwner',
-        '--jq',
-        '.nameWithOwner',
-    ]);
-    if (!ownerRepo)
-        warnings.push('could not resolve the GitHub repo from the working directory');
-    let agentUser = env.AI_LOOP_AGENT?.trim() || (root ? await configuredAgentUser(root) : '') || '';
-    // LOGIN is the injection boundary — the login goes into an API path.
-    if (agentUser &&
-        (!ownerRepo ||
-            !LOGIN.test(agentUser) ||
-            !(await gh(['api', `repos/${ownerRepo}/assignees/${agentUser}`, '--silent'])).ok)) {
-        warnings.push(`agentUser '${agentUser}' is not an assignable collaborator — assigning nothing`);
-        agentUser = '';
-    }
-    const humanUser = ownerRepo
-        ? await ghOut(gh, [
-            'api',
-            `repos/${ownerRepo}`,
-            '--jq',
-            'if .owner.type == "User" then .owner.login else "" end',
-        ])
-        : '';
-    const me = await ghOut(gh, ['api', 'user', '--jq', '.login']);
-    return { root, worktreeRoot, ownerRepo, agentUser, humanUser, me, warnings };
-}
-const VARS = [
-    ['ROOT', 'root'],
-    ['WT_ROOT', 'worktreeRoot'],
-    ['OWNER_REPO', 'ownerRepo'],
-    ['AGENT_USER', 'agentUser'],
-    ['HUMAN_USER', 'humanUser'],
-    ['ME', 'me'],
-];
-/** `KEY='value'` lines, single-quoted so `eval "$(… loop env)"` is safe. */
-export function toShell(env) {
-    return VARS.map(([name, key]) => `${name}='${env[key].replaceAll("'", `'\\''`)}'`).join('\n');
-}
-export async function loopEnvCommand(options) {
-    const env = await resolveLoopEnv(options);
-    if (options.json) {
-        console.log(JSON.stringify(env, null, 2));
-    }
-    else {
-        for (const w of env.warnings)
-            console.error(`⚠ ${w}`);
-        console.log(toShell(env));
-    }
-    // Nothing downstream works without both — the skill bails on either.
-    process.exitCode = env.root && env.ownerRepo ? 0 : 1;
-}

package/dist/cli/commands/loop-guard.js

@@ -1,232 +0,0 @@
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import chalk from 'chalk';
-import fs from 'fs-extra';
-import { realGitExec } from '../../base/git-identity.js';
-import { realGhExec } from '../../base/github-settings.js';
-/**
- * The invariant table from the skill, verified on git 2.55.0:
- *
- * | repo state | `--is-inside-work-tree` | `.git` |
- * |---|---|---|
- * | healthy checkout | `true`, exit 0 | directory |
- * | **wrongly bare** | `false`, **exit 0** | directory |
- * | genuinely bare | `false`, exit 0 | absent |
- * | linked worktree | `true`, exit 0 | file |
- *
- * Two things it encodes. **Stdout, not the exit code** — `rev-parse
- * --is-inside-work-tree` exits `0` either way and only *prints* the answer, so
- * an exit-code probe is dead code (`insideWorkTree` is `null` only when git
- * itself failed, i.e. there is no repo here). And **`.git` must be a directory
- * before repairing** — a genuinely bare repo prints `false` too, and nothing
- * else separates the two. This ships to consumers' machines, where "repairing"
- * someone's real bare clone is the damage rather than the fix.
- */
-export function classifyRoot(insideWorkTree, gitEntry) {
-    if (insideWorkTree === null)
-        return 'not-a-repo';
-    if (insideWorkTree.trim() === 'true')
-        return 'work-tree';
-    if (gitEntry === 'directory')
-        return 'wrongly-bare';
-    // A linked worktree's `.git` is a file; its main checkout is where a repair
-    // belongs, and that is not the path we were handed.
-    if (gitEntry === 'file')
-        return 'linked-worktree';
-    return 'genuinely-bare';
-}
-const LOCKFILE = '.repo-tooling.json';
-/**
- * `rules.aiLoop.agentUser`, with the flat pre-v4 fallback — the same pair the
- * skill's `jq` reads. Read raw rather than through `readLockfile`, whose parser
- * requires a `record.config`: a hand-written rules-only lockfile is exactly the
- * file this has to see.
- */
-export async function configuredAgentUser(root) {
-    const raw = await fs.readJson(path.join(root, LOCKFILE)).catch(() => null);
-    const user = raw?.rules?.aiLoop?.agentUser ?? raw?.aiLoop?.agentUser;
-    return typeof user === 'string' && user.trim() !== '' ? user.trim() : undefined;
-}
-/**
- * Declared intent that is not met is a misconfiguration, not a degraded mode —
- * so this halts, unlike the assignability check in `base/agent-user.ts`, which
- * warns and carries on. That check can never catch this: `agentUser` is
- * assignable regardless of who is calling.
- */
-export async function checkAgentIdentity(configured, gh) {
-    if (!configured) {
-        return {
-            verdict: 'not-configured',
-            message: `no aiLoop.agentUser in ${LOCKFILE} — identity check skipped`,
-        };
-    }
-    const r = await gh(['api', 'user', '--jq', '.login']);
-    const effective = r.ok ? r.stdout.trim() : '';
-    // GitHub logins are case-insensitive, so a case difference is one account.
-    if (effective !== '' && effective.toLowerCase() === configured.toLowerCase()) {
-        return {
-            verdict: 'match',
-            message: `gh is authenticated as ${effective} — the configured agent account`,
-        };
-    }
-    return {
-        verdict: 'mismatch',
-        message: `⚠ agentUser is ${configured} but gh authenticates as ${effective || '(gh could not say — unauthenticated or missing)'} — the tick would commit, push and review as the wrong account. Run \`npx @rtorcato/repo-tooling fix ai-loop-identity\` in this checkout, then relaunch the Claude session`,
-    };
-}
-/**
- * `--frozen-lockfile` forbids re-resolution, so neither `pnpm-lock.yaml` nor a
- * `pnpm-workspace.yaml` carve-out moves as a side effect of a cleanup.
- * `--config.confirmModulesPurge=false` gets past
- * `ERR_PNPM_ABORTED_REMOVE_MODULES_DIR_NO_TTY` — which is why a bare `pnpm
- * install` cannot repair this.
- */
-export const REBUILD_ARGS = [
-    'install',
-    '--frozen-lockfile',
-    '--config.confirmModulesPurge=false',
-];
-const realInstall = (cwd) => new Promise((resolve) => {
-    // stdout stays clean for the `--json` payload; pnpm's diagnostics are
-    // still visible on stderr.
-    const child = spawn('pnpm', [...REBUILD_ARGS], {
-        cwd,
-        stdio: ['ignore', 'ignore', 'inherit'],
-    });
-    child.on('close', (code) => resolve(code === 0));
-    child.on('error', () => resolve(false));
-});
-async function gitEntryKind(root) {
-    // lstat, not stat: the file/directory distinction is the whole discriminator.
-    try {
-        const stat = await fs.lstat(path.join(root, '.git'));
-        return stat.isDirectory() ? 'directory' : 'file';
-    }
-    catch {
-        return 'absent';
-    }
-}
-/** `ai-*` directories one level down, in either place worktrees are kept. */
-export async function findLive(dirs) {
-    const live = [];
-    for (const dir of dirs) {
-        // A missing worktree root is the normal case, not an error.
-        const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
-        for (const entry of entries) {
-            if (entry.isDirectory() && entry.name.startsWith('ai-'))
-                live.push(path.join(dir, entry.name));
-        }
-    }
-    return live;
-}
-/** The sibling layout the skill uses: `<parent>/<name>-worktrees`. */
-export function defaultWorktreeRoot(root) {
-    return path.join(path.dirname(root), `${path.basename(root)}-worktrees`);
-}
-const stamp = () => new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
-const UNUSABLE = {
-    'genuinely-bare': 'main checkout is a genuinely bare repository (.git absent) — refusing to flip core.bare on a real bare clone',
-    'linked-worktree': '--root points at a linked worktree (.git is a file), not the main checkout — repair belongs on the main checkout',
-    'not-a-repo': 'not a git repository',
-};
-/**
- * One tick's worth of guarding, as data. The command wrapper prints it and
- * sets the exit code; tests call this directly.
- */
-export async function runLoopGuard(options = {}) {
-    const root = path.resolve(options.root ?? process.cwd());
-    const worktreeRoot = options.worktreeRoot
-        ? path.resolve(options.worktreeRoot)
-        : defaultWorktreeRoot(root);
-    const git = options.git ?? ((args) => realGitExec(args, root));
-    const gh = options.gh ?? ((args, stdin) => realGhExec(args, stdin, root));
-    const install = options.install ?? realInstall;
-    const messages = [];
-    const state = classifyRoot(await git(['rev-parse', '--is-inside-work-tree']), await gitEntryKind(root));
-    let bare = 'healthy';
-    let exitCode = 0;
-    if (state === 'wrongly-bare') {
-        messages.push(`⚠ main checkout bare at ${stamp()} — repairing`);
-        // Writes $ROOT/.git/config, which a restrictive sandbox refuses with
-        // `error: could not lock config file .git/config`. Aborting beats
-        // reporting a healthy repo while it stays broken.
-        if ((await git(['config', 'core.bare', 'false'])) === null) {
-            bare = 'repair-failed';
-            exitCode = 1;
-            messages.push('⚠ repair FAILED — main checkout still bare');
-        }
-        else {
-            bare = 'repaired';
-            messages.push('main checkout repaired — core.bare is false');
-        }
-    }
-    else if (state !== 'work-tree') {
-        bare = 'unrepairable';
-        exitCode = 2;
-        messages.push(`⚠ ${UNUSABLE[state]}`);
-    }
-    else {
-        messages.push('main checkout is a work tree');
-    }
-    const { verdict: identity, message: identityMessage } = await checkAgentIdentity(await configuredAgentUser(root), gh);
-    messages.push(identityMessage);
-    // A failed repair (1) is the more specific verdict, so it keeps the code.
-    if (identity === 'mismatch' && exitCode === 0)
-        exitCode = 2;
-    const live = await findLive([worktreeRoot, path.join(root, '.claude', 'worktrees')]);
-    const rebuild = await decideRebuild({ root, removed: options.removed === true, exitCode, live });
-    let outcome = rebuild;
-    if (rebuild === 'deferred') {
-        messages.push(`rebuild deferred — ${live.length} worktree(s) still live`);
-    }
-    else if (rebuild === 'rebuilt') {
-        messages.push('rebuilding the main checkout’s node_modules');
-        if (!(await install(root))) {
-            outcome = 'rebuild-failed';
-            // Not fatal: a broken .bin cannot corrupt a commit the way a bare
-            // checkout does. Loud, though — a silent skip is the breakage this
-            // guard exists to end.
-            messages.push('⚠ node_modules rebuild FAILED — main checkout may be unbuildable');
-        }
-        else {
-            messages.push('node_modules rebuilt');
-        }
-    }
-    return { root, worktreeRoot, state, bare, identity, rebuild: outcome, live, exitCode, messages };
-}
-/**
- * The three load-bearing conditions, kept separate from the run so a test can
- * assert them without a pnpm install:
- *
- * - **`removed`** — set by every removal path, merged-PR cleanup *and* stall
- *   reaping. A reaped worktree needs this most: its agent died mid-command.
- * - **`pnpm-lock.yaml`** — non-pnpm repos skip the whole thing.
- * - **no live worktrees** — the rebuild *purges* the shared modules dir, which
- *   would be yanked out from under any agent still running in a surviving
- *   worktree. Deferring costs a broken main checkout until the last worktree
- *   clears; not deferring costs a live implementer run.
- */
-export async function decideRebuild(input) {
-    if (!input.removed)
-        return 'not-requested';
-    // Nothing runs against a root we are about to halt the tick over.
-    if (input.exitCode !== 0)
-        return 'skipped-root-unusable';
-    if (!(await fs.pathExists(path.join(input.root, 'pnpm-lock.yaml'))))
-        return 'skipped-no-lockfile';
-    return input.live.length > 0 ? 'deferred' : 'rebuilt';
-}
-export async function loopGuardCommand(options) {
-    const result = await runLoopGuard(options);
-    if (options.json) {
-        console.log(JSON.stringify(result, null, 2));
-    }
-    else {
-        console.log();
-        for (const line of result.messages) {
-            console.log(`  ${line.startsWith('⚠') ? chalk.yellow(line) : chalk.gray(line)}`);
-        }
-        console.log();
-    }
-    process.exitCode = result.exitCode;
-}

package/dist/cli/commands/loop-marker.js

@@ -1,169 +0,0 @@
-import path from 'node:path';
-import fs from 'fs-extra';
-import { realGhExec } from '../../base/github-settings.js';
-import { ghOut } from './loop-env.js';
-/**
- * `repo-tooling loop comment` and `loop verdict` — the ai-issue-loop skill's
- * two hidden-marker protocols, moved out of prose-with-jq (#619):
- *
- * - **comment** upserts the one `<!-- ai-issue-loop:decision -->` comment on a
- *   PR (Pass 1), so a PR left over a weekend gets one edited comment, not one
- *   per tick.
- * - **verdict** reads a reviewer arm's `<!-- ai-issue-loop:verdict:… -->`
- *   marker back off the PR's reviews (Pass 3), so a reviewer that posted and
- *   died before labelling is adopted rather than re-spawned.
- *
- * Both gate on the loop's own login — anyone can comment on or review a public
- * PR, and a stranger's marker would otherwise own the slot or override a
- * genuine `CHANGES`. Login, not `author_association`, which wobbles with repo
- * ownership. Bodies travel to gh as JSON on stdin, never through a shell.
- */
-export const DECISION_MARKER = '<!-- ai-issue-loop:decision -->';
-async function resolveTarget(dir, gh) {
-    const cwd = path.resolve(dir ?? process.cwd());
-    const exec = gh ?? ((args, stdin) => realGhExec(args, stdin, cwd));
-    const ownerRepo = await ghOut(exec, [
-        'repo',
-        'view',
-        '--json',
-        'nameWithOwner',
-        '--jq',
-        '.nameWithOwner',
-    ]);
-    if (!ownerRepo)
-        return 'could not resolve the GitHub repo from the working directory';
-    const me = await ghOut(exec, ['api', 'user', '--jq', '.login']);
-    if (!me)
-        return 'could not resolve the gh login';
-    return { ownerRepo, me, gh: exec };
-}
-/** The PR number goes into an API path — digits only. */
-function prNumber(pr) {
-    const s = String(pr);
-    return /^[1-9]\d*$/.test(s) ? Number(s) : null;
-}
-/** `--paginate --slurp` yields one array per page; `--jq` would run per page. */
-async function slurp(gh, route) {
-    const r = await gh(['api', route, '--paginate', '--slurp']);
-    if (!r.ok)
-        return null;
-    try {
-        return JSON.parse(r.stdout).flat();
-    }
-    catch {
-        return null;
-    }
-}
-export async function runLoopComment(pr, options) {
-    const n = prNumber(pr);
-    const fail = (error) => ({
-        pr: n,
-        action: 'failed',
-        commentId: null,
-        error,
-    });
-    if (n === null)
-        return fail(`not a PR number: ${pr}`);
-    const text = options.text.trim();
-    if (!text)
-        return fail('empty comment body');
-    const target = await resolveTarget(options.dir, options.gh);
-    if (typeof target === 'string')
-        return fail(target);
-    const { ownerRepo, me, gh } = target;
-    const comments = await slurp(gh, `repos/${ownerRepo}/issues/${n}/comments`);
-    // A failed read must not fall through to "create" — that is the duplicate.
-    if (comments === null)
-        return fail('could not list PR comments');
-    const existing = comments.find((c) => c.user?.login === me && (c.body ?? '').startsWith(DECISION_MARKER));
-    const input = JSON.stringify({ body: `${DECISION_MARKER}\n${text}` });
-    const r = existing
-        ? await gh(['api', '-X', 'PATCH', `repos/${ownerRepo}/issues/comments/${existing.id}`, '--input', '-'], input)
-        : await gh(['api', `repos/${ownerRepo}/issues/${n}/comments`, '--input', '-'], input);
-    if (!r.ok)
-        return fail(r.stderr.trim() || 'gh api failed');
-    let id = existing?.id ?? null;
-    try {
-        id = JSON.parse(r.stdout).id ?? id;
-    }
-    catch { }
-    return { pr: n, action: existing ? 'updated' : 'created', commentId: id };
-}
-export async function runLoopVerdict(pr, options) {
-    const n = prNumber(pr);
-    const { arm } = options;
-    const fail = (error) => ({
-        pr: n,
-        arm,
-        head: null,
-        verdict: null,
-        error,
-    });
-    if (n === null)
-        return fail(`not a PR number: ${pr}`);
-    if (arm !== 'code' && arm !== 'sec')
-        return fail(`--arm must be code or sec, got ${arm}`);
-    const target = await resolveTarget(options.dir, options.gh);
-    if (typeof target === 'string')
-        return fail(target);
-    const { ownerRepo, me, gh } = target;
-    const head = await ghOut(gh, [
-        'pr',
-        'view',
-        String(n),
-        '-R',
-        ownerRepo,
-        '--json',
-        'headRefOid',
-        '--jq',
-        '.headRefOid',
-    ]);
-    if (!head)
-        return fail('could not resolve the PR head commit');
-    // `issues/<N>/comments` would never see these — `gh pr review --comment`
-    // creates a review.
-    const reviews = await slurp(gh, `repos/${ownerRepo}/pulls/${n}/reviews`);
-    if (reviews === null)
-        return { ...fail('could not list PR reviews'), head };
-    const marker = new RegExp(`<!-- ai-issue-loop:verdict:${arm}:(PASS-NOTES|PASS|CHANGES) -->`);
-    let verdict = null;
-    for (const r of reviews) {
-        // The head gate: a verdict expires with the diff it read.
-        if (r.user?.login !== me || r.commit_id !== head)
-            continue;
-        const m = (r.body ?? '').match(marker);
-        if (m)
-            verdict = m[1];
-    }
-    return { pr: n, arm, head, verdict };
-}
-export async function loopCommentCommand(pr, options) {
-    let text;
-    try {
-        text = fs.readFileSync(options.bodyFile === '-' ? 0 : options.bodyFile, 'utf8');
-    }
-    catch (err) {
-        console.error(`✖ cannot read ${options.bodyFile}: ${err.message}`);
-        process.exitCode = 1;
-        return;
-    }
-    const result = await runLoopComment(pr, { dir: options.dir, text });
-    if (options.json)
-        console.log(JSON.stringify(result, null, 2));
-    else if (result.error)
-        console.error(`✖ ${result.error}`);
-    else
-        console.log(`${result.action} comment ${result.commentId} on #${result.pr}`);
-    process.exitCode = result.action === 'failed' ? 1 : 0;
-}
-export async function loopVerdictCommand(pr, options) {
-    const result = await runLoopVerdict(pr, options);
-    if (options.json)
-        console.log(JSON.stringify(result, null, 2));
-    else if (result.error)
-        console.error(`✖ ${result.error}`);
-    // Empty line for "none", so `VERDICT=$(… loop verdict …)` needs no null check.
-    else
-        console.log(result.verdict ?? '');
-    process.exitCode = result.error ? 1 : 0;
-}

package/dist/cli/commands/loop-reap.js

@@ -1,196 +0,0 @@
-import path from 'node:path';
-import chalk from 'chalk';
-import { realGhExec } from '../../base/github-settings.js';
-import { defaultWorktreeRoot, findLive } from './loop-guard.js';
-/**
- * `repo-tooling loop reap` — the ai-issue-loop skill's Pass 2 stalled-agent
- * table, moved out of prose (#618). Nothing can time out an agent, so a label
- * that sat `STALE_MINUTES` past its last application (per the timeline) marks
- * a dead one:
- *
- * - **implementer** — issue `ai-wip`, no PR for `ai-<N>-*` → `block`.
- * - **reviewer** — PR `ai-reviewing-code|sec` with no matching `ai-ok-*` and
- *   no `ai-changes` → `drop-label` that claim, or `block` at ≥3 applications.
- * - **fixer** — PR `ai-fixing` still `ai-changes` → `drop-label`, or `block`.
- * - **orphan** — `ai-<N>-*` worktree whose issue is not `ai-wip` and has no
- *   open PR → `remove-worktree`.
- *
- * Read-only: it reports verdicts, the skill applies them — the label, assign
- * and comment of an `ai-blocked`, and the call on whether a stall was benign.
- * Exit `1` when a gh query failed, so the report is incomplete.
- */
-/** Three ticks. Generous: a live agent must never be reaped out from under itself. */
-export const STALE_MINUTES = 45;
-/** A claim applied this many times is not one more spawn away from working. */
-export const MAX_APPLICATIONS = 3;
-// ponytail: newest 200 PRs; an ai-wip issue's PR older than that reads as "no PR".
-const PR_WINDOW = 200;
-/** `ai-<N>-slug`, or the legacy `worktree-ai-<N>-slug`. */
-const issueOf = (name) => Number(name.match(/^(?:worktree-)?ai-(\d+)-/)?.[1]) || null;
-const REVIEW_CLAIMS = {
-    'ai-reviewing-code': 'ai-ok-code',
-    'ai-reviewing-sec': 'ai-ok-sec',
-};
-export async function runLoopReap(options = {}) {
-    const root = path.resolve(options.root ?? process.cwd());
-    const worktreeRoot = options.worktreeRoot
-        ? path.resolve(options.worktreeRoot)
-        : defaultWorktreeRoot(root);
-    const gh = options.gh ?? ((args, stdin) => realGhExec(args, stdin, root));
-    const now = (options.now ?? new Date()).getTime();
-    const errors = [];
-    const stalled = [];
-    const list = async (args) => {
-        const r = await gh(args);
-        if (!r.ok) {
-            errors.push(`gh ${args.slice(0, 2).join(' ')} failed: ${r.stderr.trim()}`);
-            return null;
-        }
-        return JSON.parse(r.stdout || '[]');
-    };
-    /** Every application of `label` on issue/PR `n`, oldest first. */
-    const applications = async (n, label) => {
-        const r = await gh([
-            'api',
-            `repos/{owner}/{repo}/issues/${n}/timeline`,
-            '--paginate',
-            '--jq',
-            '.[] | select(.event=="labeled") | [.label.name, .created_at] | @tsv',
-        ]);
-        if (!r.ok) {
-            errors.push(`timeline for #${n} failed: ${r.stderr.trim()}`);
-            return null;
-        }
-        return r.stdout
-            .split('\n')
-            .map((line) => line.split('\t'))
-            .filter(([name]) => name === label)
-            .map(([, at]) => Date.parse(at))
-            .sort((a, b) => a - b);
-    };
-    /** Age and count of `label` on `n`, or null when it is not stale yet (or unknown). */
-    const stale = async (n, label) => {
-        const times = await applications(n, label);
-        const last = times?.at(-1);
-        if (last === undefined)
-            return null;
-        const minutes = Math.floor((now - last) / 60_000);
-        return minutes >= STALE_MINUTES ? { minutes, applications: times?.length ?? 0 } : null;
-    };
-    const wip = await list([
-        'issue',
-        'list',
-        '--label',
-        'ai-wip',
-        '--state',
-        'open',
-        '--limit',
-        '100',
-        '--json',
-        'number',
-    ]);
-    const prs = await list([
-        'pr',
-        'list',
-        '--state',
-        'all',
-        '--limit',
-        String(PR_WINDOW),
-        '--json',
-        'number,state,headRefName,labels',
-    ]);
-    const dirs = await findLive([worktreeRoot, path.join(root, '.claude', 'worktrees')]);
-    const worktreeOf = (issue) => dirs.find((d) => issueOf(path.basename(d)) === issue) ?? null;
-    // Without both lists a "no PR" or "not ai-wip" verdict would be a guess.
-    if (wip && prs) {
-        const wipSet = new Set(wip.map((i) => i.number));
-        const prIssues = (state) => new Set(prs.filter((p) => !state || p.state === state).map((p) => issueOf(p.headRefName)));
-        const anyPr = prIssues();
-        const openPr = prIssues('OPEN');
-        for (const issue of wipSet) {
-            if (anyPr.has(issue))
-                continue;
-            const s = await stale(issue, 'ai-wip');
-            if (!s)
-                continue;
-            stalled.push({
-                kind: 'implementer',
-                issue,
-                pr: null,
-                label: 'ai-wip',
-                ...s,
-                action: 'block',
-                worktree: worktreeOf(issue),
-                reason: `ai-wip for ${s.minutes}min and no PR`,
-            });
-        }
-        for (const pr of prs.filter((p) => p.state === 'OPEN')) {
-            const labels = new Set(pr.labels.map((l) => l.name));
-            const issue = issueOf(pr.headRefName);
-            const claims = Object.entries(REVIEW_CLAIMS)
-                .filter(([claim, ok]) => labels.has(claim) && !labels.has(ok) && !labels.has('ai-changes'))
-                .map(([claim]) => ({ kind: 'reviewer', claim }));
-            if (labels.has('ai-fixing') && labels.has('ai-changes'))
-                claims.push({ kind: 'fixer', claim: 'ai-fixing' });
-            for (const { kind, claim } of claims) {
-                const s = await stale(pr.number, claim);
-                if (!s)
-                    continue;
-                const block = s.applications >= MAX_APPLICATIONS;
-                stalled.push({
-                    kind,
-                    issue,
-                    pr: pr.number,
-                    label: claim,
-                    ...s,
-                    action: block ? 'block' : 'drop-label',
-                    worktree: null,
-                    reason: `${claim} for ${s.minutes}min, applied ${s.applications}×`,
-                });
-            }
-        }
-        for (const dir of dirs) {
-            const issue = issueOf(path.basename(dir));
-            if (issue === null || wipSet.has(issue) || openPr.has(issue))
-                continue;
-            stalled.push({
-                kind: 'orphan',
-                issue,
-                pr: null,
-                label: null,
-                minutes: null,
-                applications: null,
-                action: 'remove-worktree',
-                worktree: dir,
-                reason: 'issue not ai-wip and no open PR',
-            });
-        }
-    }
-    return {
-        root,
-        worktreeRoot,
-        staleMinutes: STALE_MINUTES,
-        stalled,
-        errors,
-        exitCode: errors.length > 0 ? 1 : 0,
-    };
-}
-export async function loopReapCommand(options) {
-    const result = await runLoopReap(options);
-    if (options.json) {
-        console.log(JSON.stringify(result, null, 2));
-    }
-    else {
-        console.log();
-        if (result.stalled.length === 0)
-            console.log(chalk.gray('  nothing stalled'));
-        for (const s of result.stalled) {
-            const target = s.pr ? `PR #${s.pr}` : `#${s.issue}`;
-            console.log(`  ${chalk.yellow(s.action.padEnd(15))} ${target} (${s.kind}) — ${s.reason}`);
-        }
-        for (const e of result.errors)
-            console.log(`  ${chalk.red(e)}`);
-        console.log();
-    }
-    process.exitCode = result.exitCode;
-}