@rtorcato/repo-tooling 3.45.0 → 4.1.0

package/dist/base/labels.js

@@ -1,220 +0,0 @@
-import path from 'node:path';
-import chalk from 'chalk';
-import fs from 'fs-extra';
-import { realGhExec } from './github-settings.js';
-/**
- * `ai-issue-loop` label hygiene (#446). Same class of GitHub-side drift as
- * github-settings.ts and milestones.ts, on the same `gh` seam.
- *
- * The bug this exists for: the skill's bootstrap uses `gh label create`, which
- * *errors as a no-op* when the label already exists. It can add a missing label
- * but can never repair an existing one, so a hand-created `ai-ready` keeps
- * whatever colour the web picker gave it forever. Measured across eight repos,
- * six had `ai-ready` at `B60205` — byte-identical to `ai-blocked`, so "an agent
- * should pick this up" and "an agent gave up" rendered the same. Repair here
- * goes through `gh label edit`, which is the whole point of the fixer.
- *
- * This table is the single source of truth for the label set. The bootstrap
- * block in skills/ai-issue-loop/SKILL.md is asserted against it in
- * tests/base/labels.test.ts, so the two cannot drift apart.
- */
-const CHECK = 'AI loop labels';
-export const LOOP_LABELS = [
-    {
-        name: 'holding',
-        color: '5319e7',
-        description: 'Gate/holding issue — human judgement, never auto-picked',
-    },
-    { name: 'ai-ready', color: '0e8a16', description: 'Eligible for an AI agent to implement' },
-    { name: 'ai-wip', color: 'fbca04', description: 'Claimed by an agent; worktree exists' },
-    { name: 'ai-blocked', color: 'b60205', description: 'Agent gave up; needs a human' },
-    { name: 'ai-review', color: '1d76db', description: 'PR awaiting agent review' },
-    { name: 'ai-reviewing-code', color: 'c5def5', description: 'code-reviewer claimed and running' },
-    { name: 'ai-reviewing-sec', color: 'c5def5', description: 'security-expert claimed and running' },
-    { name: 'ai-ok-code', color: '0e8a16', description: 'code-reviewer passed' },
-    { name: 'ai-ok-sec', color: '0e8a16', description: 'security-expert passed' },
-    { name: 'ai-changes', color: 'd93f0b', description: 'Reviewer requested changes' },
-    {
-        name: 'ai-fixing',
-        color: '006b75',
-        description: 'Fix-round implementer claimed and running',
-    },
-    {
-        name: 'ai-notes',
-        color: 'fbca04',
-        description: 'Passed, but a reviewer left something to read before merging',
-    },
-    {
-        name: 'merge-ready',
-        color: '8250df',
-        description: 'Both agent reviews passed and the PR is mergeable — waiting on a human',
-    },
-    {
-        name: 'ai-suggested',
-        color: 'c2e0c6',
-        description: 'Follow-up surfaced by an agent review — triage queue, never auto-picked',
-    },
-];
-/**
- * How many of the set have to exist before this repo counts as running the
- * loop. A repo with none has opted out, not drifted — creating fourteen labels it
- * will never use is the nag this threshold exists to prevent. One alone is the
- * observed half-state (`cf-common` has only `ai-ready`, applied by hand), which
- * is likewise not evidence the pipeline runs there.
- */
-const IN_USE_THRESHOLD = 2;
-const skip = (reason) => ({
-    check: CHECK,
-    status: 'ok',
-    detail: `skipped — ${reason}`,
-});
-/**
- * Case-insensitive, `#`-insensitive. The drift that started this was uppercase
- * `B60205` against lowercase `b60205` — GitHub's colour picker writes uppercase,
- * `gh` writes lowercase, and the two render identically. Comparing raw would
- * report every hand-created label as drift forever and have the fixer PATCH a
- * colour that was already correct.
- */
-const normalizeColor = (c) => c.trim().replace(/^#/, '').toLowerCase();
-async function readLabels(gh) {
-    const r = await gh(['label', 'list', '--json', 'name,color,description', '--limit', '200']);
-    if (!r.ok)
-        return null;
-    try {
-        const parsed = JSON.parse(r.stdout);
-        if (!Array.isArray(parsed))
-            return null;
-        const byName = new Map();
-        for (const l of parsed) {
-            if (typeof l?.name !== 'string')
-                continue;
-            byName.set(l.name, {
-                name: l.name,
-                color: typeof l.color === 'string' ? l.color : '',
-                description: typeof l.description === 'string' ? l.description : '',
-            });
-        }
-        return byName;
-    }
-    catch {
-        return null;
-    }
-}
-export function classifyLabels(existing) {
-    const deltas = { present: [], missing: [], wrongColor: [], wrongDescription: [] };
-    for (const spec of LOOP_LABELS) {
-        const actual = existing.get(spec.name);
-        if (!actual) {
-            deltas.missing.push(spec);
-            continue;
-        }
-        deltas.present.push(spec);
-        if (normalizeColor(actual.color) !== normalizeColor(spec.color))
-            deltas.wrongColor.push({ spec, actual: normalizeColor(actual.color) });
-        if (actual.description.trim() !== spec.description)
-            deltas.wrongDescription.push(spec);
-    }
-    return deltas;
-}
-const names = (specs) => specs.map((s) => `\`${s.name}\``).join(', ');
-export async function checkLoopLabels(dir, exec) {
-    // Cheap gate first: no .git → never spawn (keeps tmp-dir doctor runs offline).
-    if (!(await fs.pathExists(path.join(dir, '.git'))))
-        return skip('not a git repository');
-    const gh = exec ?? ((args, stdin) => realGhExec(args, stdin, dir));
-    const existing = await readLabels(gh);
-    if (!existing)
-        return skip('could not read labels');
-    const { present, missing, wrongColor, wrongDescription } = classifyLabels(existing);
-    if (present.length < IN_USE_THRESHOLD)
-        return {
-            check: CHECK,
-            status: 'ok',
-            detail: 'not applicable — repo does not use the ai-issue-loop labels',
-        };
-    const deltas = [];
-    for (const { spec, actual } of wrongColor)
-        deltas.push(`\`${spec.name}\` is #${actual}, should be #${spec.color}`);
-    if (wrongDescription.length)
-        deltas.push(`wrong description: ${names(wrongDescription)}`);
-    if (missing.length)
-        deltas.push(`missing: ${names(missing)}`);
-    if (deltas.length)
-        return {
-            check: CHECK,
-            status: 'drift',
-            detail: deltas.join('; '),
-            hint: 'Run `npx @rtorcato/repo-tooling fix labels` to repair them with `gh label edit` — `gh label create` cannot change an existing label, which is how this drifted',
-        };
-    return {
-        check: CHECK,
-        status: 'ok',
-        detail: `${present.length} ai-issue-loop label(s) match spec`,
-    };
-}
-/**
- * Repairs colour and description with `gh label edit`, and creates the labels
- * the set is missing. Only on a repo already running the loop (the same
- * `IN_USE_THRESHOLD` gate the check uses) — otherwise a plain `fix --yes` would
- * push fourteen labels into every repo it touches.
- *
- * Idempotent: an aligned repo is a no-op, and a label whose only difference is
- * the hex case is not touched at all.
- *
- * Advisories go to `console.error`; stdout carries the `--json` payload (#357).
- */
-export async function applyLoopLabels(dir, exec) {
-    if (!(await fs.pathExists(path.join(dir, '.git')))) {
-        console.error(chalk.gray('   skipped — not a git repository'));
-        return [];
-    }
-    const gh = exec ?? ((args, stdin) => realGhExec(args, stdin, dir));
-    const existing = await readLabels(gh);
-    if (!existing) {
-        console.error(chalk.gray('   skipped — could not read labels'));
-        return [];
-    }
-    const { present, missing, wrongColor, wrongDescription } = classifyLabels(existing);
-    if (present.length < IN_USE_THRESHOLD) {
-        console.error(chalk.gray('   skipped — repo does not use the ai-issue-loop labels'));
-        return [];
-    }
-    // One edit per drifted label, whichever field drifted — the API takes both.
-    const toEdit = new Set([...wrongColor.map((w) => w.spec), ...wrongDescription]);
-    const applied = [];
-    for (const spec of toEdit) {
-        // `edit`, not `create`: create errors as a no-op on an existing label, so a
-        // fixer built on it would silently repair nothing (#446).
-        const r = await gh([
-            'label',
-            'edit',
-            spec.name,
-            '--color',
-            spec.color,
-            '--description',
-            spec.description,
-        ]);
-        if (r.ok)
-            applied.push(`repaired label "${spec.name}"`);
-        else
-            console.error(chalk.yellow(`   could not repair "${spec.name}": ${r.stderr.trim() || 'gh error'}`));
-    }
-    for (const spec of missing) {
-        const r = await gh([
-            'label',
-            'create',
-            spec.name,
-            '--color',
-            spec.color,
-            '--description',
-            spec.description,
-        ]);
-        if (r.ok)
-            applied.push(`created label "${spec.name}"`);
-        else
-            console.error(chalk.yellow(`   could not create "${spec.name}": ${r.stderr.trim() || 'gh error'}`));
-    }
-    if (applied.length === 0)
-        console.error(chalk.gray('   labels already match spec'));
-    return applied;
-}

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

@@ -1,100 +0,0 @@
-import path from 'node:path';
-import chalk from 'chalk';
-import { realGitExec } from '../../base/git-identity.js';
-import { realGhExec } from '../../base/github-settings.js';
-import { defaultWorktreeRoot, findLive } from './loop-guard.js';
-/** How far back to look for the squash subject. */
-const SQUASH_WINDOW = 200;
-async function findPr(gh, heads) {
-    for (const head of heads) {
-        const r = await gh(['pr', 'list', '--head', head, '--state', 'all', '--json', 'number,state']);
-        if (!r.ok)
-            continue;
-        const [pr] = JSON.parse(r.stdout || '[]');
-        if (pr)
-            return pr;
-    }
-    return null;
-}
-export async function runLoopCleanup(options = {}) {
-    const root = path.resolve(options.root ?? process.cwd());
-    const worktreeRoot = options.worktreeRoot
-        ? path.resolve(options.worktreeRoot)
-        : defaultWorktreeRoot(root);
-    // Fetch and `worktree remove` outlast the 5s probe timeout on a real repo.
-    const git = options.git ?? ((args) => realGitExec(args, root, 120_000));
-    const gh = options.gh ?? ((args, stdin) => realGhExec(args, stdin, root));
-    const dirs = await findLive([worktreeRoot, path.join(root, '.claude', 'worktrees')]);
-    let subjects = null;
-    const worktrees = [];
-    for (const dir of dirs) {
-        const slug = path.basename(dir);
-        const issue = Number(slug.match(/^ai-(\d+)-/)?.[1]) || null;
-        // `worktree-` is the prefix EnterWorktree once gave branches — legacy.
-        const heads = [slug, `worktree-${slug}`];
-        const branch = (await git(['branch', '--list', ...heads, '--format=%(refname:short)']))
-            ?.split('\n')[0]
-            ?.trim() || null;
-        const pr = await findPr(gh, heads);
-        const entry = {
-            path: dir,
-            issue,
-            branch,
-            pr: pr?.number ?? null,
-            prState: pr?.state ?? null,
-            action: 'kept',
-            reason: '',
-        };
-        worktrees.push(entry);
-        if (!pr || pr.state === 'OPEN') {
-            entry.reason = pr ? 'PR still open' : 'no PR';
-            continue;
-        }
-        if (pr.state === 'MERGED') {
-            if (subjects === null) {
-                // Best-effort: a failed fetch leaves origin/main stale, which can
-                // only keep a worktree, never remove one wrongly.
-                await git(['fetch', '--prune', 'origin']);
-                const log = await git(['log', 'origin/main', `-n${SQUASH_WINDOW}`, '--format=%s']);
-                subjects = log ? log.split('\n') : [];
-            }
-            if (!subjects.some((s) => s.trimEnd().endsWith(`(#${pr.number})`))) {
-                entry.reason = `squash for #${pr.number} not on origin/main`;
-                continue;
-            }
-        }
-        if ((await git(['worktree', 'remove', '--force', dir])) === null) {
-            entry.action = 'remove-failed';
-            entry.reason = 'git worktree remove failed';
-            continue;
-        }
-        if (branch)
-            await git(['branch', '-D', branch]);
-        entry.action = 'removed';
-        entry.reason = pr.state === 'MERGED' ? `#${pr.number} landed on main` : `#${pr.number} closed`;
-    }
-    return {
-        root,
-        worktreeRoot,
-        removed: worktrees.some((w) => w.action === 'removed'),
-        worktrees,
-        exitCode: worktrees.some((w) => w.action === 'remove-failed') ? 1 : 0,
-    };
-}
-export async function loopCleanupCommand(options) {
-    const result = await runLoopCleanup(options);
-    if (options.json) {
-        console.log(JSON.stringify(result, null, 2));
-    }
-    else {
-        console.log();
-        if (result.worktrees.length === 0)
-            console.log(chalk.gray('  no ai-* worktrees'));
-        for (const w of result.worktrees) {
-            const line = `${w.action.padEnd(13)} ${path.basename(w.path)} — ${w.reason}`;
-            console.log(`  ${w.action === 'remove-failed' ? chalk.yellow(line) : chalk.gray(line)}`);
-        }
-        console.log();
-    }
-    process.exitCode = result.exitCode;
-}

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;
-}