@rtorcato/repo-tooling 3.45.0 → 4.0.0

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

@@ -1,202 +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',
-};
-/** Every application of `label` on issue/PR `n`, oldest first — or why it could not be read. */
-export async function labelApplications(gh, 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)
-        return `timeline for #${n} failed: ${r.stderr.trim()}`;
-    return r.stdout
-        .split('\n')
-        .map((line) => line.split('\t'))
-        .filter(([name]) => name === label)
-        .map(([, at]) => Date.parse(at))
-        .sort((a, b) => a - b);
-}
-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 || '[]');
-    };
-    const applications = async (n, label) => {
-        const times = await labelApplications(gh, n, label);
-        if (typeof times === 'string') {
-            errors.push(times);
-            return null;
-        }
-        return times;
-    };
-    /** 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;
-}

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

@@ -1,349 +0,0 @@
-import path from 'node:path';
-import chalk from 'chalk';
-import { realGitExec } from '../../base/git-identity.js';
-import { realGhExec, releaseGated } from '../../base/github-settings.js';
-import { runLoopCleanup } from './loop-cleanup.js';
-import { resolveLoopEnv } from './loop-env.js';
-import { runLoopGuard } from './loop-guard.js';
-import { runLoopVerdict } from './loop-marker.js';
-import { labelApplications, MAX_APPLICATIONS, runLoopReap } from './loop-reap.js';
-/**
- * `repo-tooling loop tick` — one ai-issue-loop tick's mechanics as one work
- * list (#620). It composes `loop env`, `loop guard`, `loop cleanup`,
- * `loop reap` and `loop verdict` with the Pass 1 merge-state and CI reads, the
- * Pass 0 PR-adoption query, the Pass 2 `ai-suggested` decay and the Pass 4
- * eligibility query, and says what to do. The skill applies it: every label,
- * assignee, comment, merge and agent spawn stays the agent's call.
- *
- * It writes no GitHub state. Its only local writes are the ones the helpers it
- * composes already make — `loop guard`'s bare repair and gated `node_modules`
- * rebuild, and `loop cleanup`'s removal of worktrees whose PR landed or closed.
- *
- * Exit non-zero only to halt the tick: `loop guard`'s own code (`1`/`2`), or `1`
- * when the checkout or its GitHub repo cannot be resolved. A failed gh read is
- * not a halt — the lists it feeds are left empty, it lands in `errors`, and the
- * summary leads with `⚠error`.
- */
-/** Issues in flight at once. */
-export const MAX_IN_FLIGHT = 6;
-/** `ai-suggested` issues untouched this long are closed. */
-export const DECAY_DAYS = 30;
-const TRUSTED = new Set(['OWNER', 'MEMBER', 'COLLABORATOR']);
-/** Merge states that name something to fix; any other non-CLEAN state waits. */
-const SEND_BACK_STATES = new Set(['BEHIND', 'DIRTY', 'BLOCKED']);
-const ARMS = ['code', 'sec'];
-const issueOf = (head) => Number(head.match(/^(?:worktree-)?ai-(\d+)-/)?.[1]) || null;
-function empty(env) {
-    return {
-        env,
-        halt: null,
-        idle: false,
-        releaseGated: false,
-        adopt: [],
-        disarm: [],
-        handoffs: [],
-        sendBacks: [],
-        stripMergeReady: [],
-        dependabotCiRed: [],
-        dependabotChanges: [],
-        cleaned: [],
-        stalled: [],
-        decay: [],
-        verdicts: [],
-        reviewsToSpawn: [],
-        fixRounds: [],
-        slots: 0,
-        pickups: [],
-        rebuild: 'not-requested',
-        summary: '',
-        errors: [],
-        exitCode: 0,
-    };
-}
-export async function runLoopTick(options = {}) {
-    const dir = path.resolve(options.root ?? process.cwd());
-    const env = await resolveLoopEnv({ dir, git: options.git, gh: options.gh, env: options.env });
-    const result = empty(env);
-    if (!env.root || !env.ownerRepo) {
-        result.halt = env.warnings.join('; ') || 'could not resolve the checkout';
-        result.exitCode = 1;
-        return result;
-    }
-    const { root, ownerRepo } = env;
-    const git = options.git ?? ((args) => realGitExec(args, root, 120_000));
-    const gh = options.gh ?? ((args, stdin) => realGhExec(args, stdin, root));
-    const now = (options.now ?? new Date()).getTime();
-    const errors = result.errors;
-    const seams = { root, git: options.git, gh: options.gh };
-    const guard = await runLoopGuard({ ...seams, install: options.install });
-    if (guard.exitCode !== 0) {
-        result.halt = guard.messages.filter((m) => m.startsWith('⚠')).join('; ') || 'loop guard failed';
-        result.exitCode = guard.exitCode;
-        return result;
-    }
-    // Best-effort: Pass 4 branches worktrees off origin/main.
-    await git(['fetch', '--prune', 'origin']);
-    const cleanup = await runLoopCleanup(seams);
-    result.cleaned = cleanup.worktrees.filter((w) => w.action === 'removed');
-    for (const w of cleanup.worktrees.filter((w) => w.action === 'remove-failed'))
-        errors.push(`could not remove ${w.path}`);
-    let live = guard.live;
-    if (cleanup.removed) {
-        const again = await runLoopGuard({ ...seams, install: options.install, removed: true });
-        if (again.exitCode !== 0) {
-            result.halt =
-                again.messages.filter((m) => m.startsWith('⚠')).join('; ') || 'loop guard failed';
-            result.exitCode = again.exitCode;
-            return result;
-        }
-        result.rebuild = again.rebuild;
-        live = again.live;
-    }
-    const reap = await runLoopReap({ root, gh: options.gh, now: options.now });
-    result.stalled = reap.stalled;
-    errors.push(...reap.errors);
-    const json = async (args) => {
-        const r = await gh(args);
-        if (r.ok) {
-            try {
-                return JSON.parse(r.stdout || 'null');
-            }
-            catch { }
-        }
-        errors.push(`gh ${args.slice(0, 3).join(' ')} failed: ${r.stderr.trim()}`);
-        return null;
-    };
-    const prs = await json([
-        'pr',
-        'list',
-        '--state',
-        'open',
-        '--limit',
-        '100',
-        '--json',
-        'number,headRefName,labels,autoMergeRequest,author,body,statusCheckRollup',
-    ]);
-    const wip = await json([
-        'issue',
-        'list',
-        '--label',
-        'ai-wip',
-        '--state',
-        'open',
-        '--limit',
-        '100',
-        '--json',
-        'number',
-    ]);
-    result.releaseGated = await releaseGated(gh, ownerRepo, root);
-    for (const pr of prs ?? []) {
-        const labels = new Set(pr.labels.map((l) => l.name));
-        const has = (l) => labels.has(l);
-        const issue = issueOf(pr.headRefName);
-        if (pr.headRefName.startsWith('dependabot/')) {
-            const red = (pr.statusCheckRollup ?? []).some((c) => c.conclusion === 'FAILURE');
-            if (pr.autoMergeRequest && red)
-                result.dependabotCiRed.push(pr.number);
-            if (has('ai-changes'))
-                result.dependabotChanges.push(pr.number);
-            continue;
-        }
-        const loopPr = has('merge-ready') || [...labels].some((l) => l.startsWith('ai-'));
-        if (!loopPr) {
-            // The 🤖 header is the discriminator: every agent is the owner's login.
-            const mine = pr.author?.login.toLowerCase() === env.me.toLowerCase();
-            if (env.me && mine && (pr.body ?? '').startsWith('🤖 '))
-                result.adopt.push(pr.number);
-            continue;
-        }
-        const passed = (has('ai-ok-code') && has('ai-ok-sec')) || has('merge-ready');
-        if (pr.autoMergeRequest && !passed)
-            result.disarm.push(pr.number);
-        const claimed = has('ai-reviewing-code') || has('ai-reviewing-sec');
-        // CI red is a send-back, except mid-review or when one is already out.
-        if (!claimed && !has('ai-changes')) {
-            const r = await gh([
-                'pr',
-                'checks',
-                String(pr.number),
-                '--required',
-                '--json',
-                'name,state,link',
-            ]);
-            // Exits non-zero whenever a check fails or is pending; stdout is still the answer.
-            let checks = [];
-            try {
-                checks = JSON.parse(r.stdout || '[]');
-            }
-            catch { }
-            const failing = checks
-                .filter((c) => c.state === 'FAILURE')
-                .map(({ name, link }) => ({ name, link }));
-            if (failing.length > 0) {
-                result.sendBacks.push({ pr: pr.number, issue, reason: 'ci-red', failing });
-                continue;
-            }
-        }
-        if (has('ai-changes')) {
-            if (has('merge-ready'))
-                result.stripMergeReady.push(pr.number);
-        }
-        else if (passed) {
-            const view = await json([
-                'pr',
-                'view',
-                String(pr.number),
-                '--json',
-                'mergeStateStatus',
-            ]);
-            const s = view?.mergeStateStatus ?? 'UNKNOWN';
-            if (s === 'CLEAN') {
-                const notes = has('ai-notes');
-                result.handoffs.push({
-                    pr: pr.number,
-                    issue,
-                    notes,
-                    autoMerge: result.releaseGated && !notes,
-                });
-            }
-            else if (SEND_BACK_STATES.has(s)) {
-                result.sendBacks.push({
-                    pr: pr.number,
-                    issue,
-                    reason: s,
-                    failing: [],
-                });
-            }
-            else if (s !== 'UNKNOWN' && has('merge-ready')) {
-                result.stripMergeReady.push(pr.number);
-            }
-            continue;
-        }
-        if (has('ai-review') && !has('ai-changes')) {
-            const spawn = [];
-            let changes = false;
-            for (const arm of ARMS) {
-                if (has(`ai-ok-${arm}`) || has(`ai-reviewing-${arm}`))
-                    continue;
-                const v = await runLoopVerdict(pr.number, { dir: root, arm, gh: options.gh });
-                if (v.error)
-                    errors.push(`verdict ${arm} on #${pr.number}: ${v.error}`);
-                else if (v.verdict) {
-                    result.verdicts.push({ pr: pr.number, arm, verdict: v.verdict });
-                    changes ||= v.verdict === 'CHANGES';
-                }
-                else
-                    spawn.push(arm);
-            }
-            // A CHANGES about to be applied sends the PR back; a review now is wasted.
-            if (!changes)
-                for (const arm of spawn)
-                    result.reviewsToSpawn.push({ pr: pr.number, issue, arm });
-        }
-        if (has('ai-changes') && !has('ai-fixing')) {
-            const times = await labelApplications(gh, pr.number, 'ai-changes');
-            if (typeof times === 'string') {
-                errors.push(times);
-                continue;
-            }
-            const slug = pr.headRefName.replace(/^worktree-/, '');
-            const worktree = live.find((d) => path.basename(d) === slug) ?? null;
-            const atCap = times.length >= MAX_APPLICATIONS;
-            result.fixRounds.push({
-                pr: pr.number,
-                issue,
-                worktree,
-                applications: times.length,
-                action: atCap || !worktree ? 'block' : 'spawn',
-                reason: atCap
-                    ? `ai-changes applied ${times.length}× — round cap reached`
-                    : worktree
-                        ? `round ${times.length}`
-                        : 'no worktree to fix in',
-            });
-        }
-    }
-    const suggested = await json([
-        'issue',
-        'list',
-        '--label',
-        'ai-suggested',
-        '--state',
-        'open',
-        '--limit',
-        '100',
-        '--json',
-        'number,updatedAt,labels',
-    ]);
-    const cutoff = now - DECAY_DAYS * 86_400_000;
-    result.decay = (suggested ?? [])
-        // A promoted suggestion keeps its label; closing a queued one is unrecoverable.
-        .filter((i) => !i.labels.some((l) => ['ai-ready', 'ai-wip', 'holding'].includes(l.name)))
-        .filter((i) => Date.parse(i.updatedAt) < cutoff)
-        .map((i) => i.number);
-    // ponytail: first 100 ai-ready issues; paginate if a queue ever outgrows that.
-    const queue = await json([
-        'api',
-        `repos/${ownerRepo}/issues?labels=ai-ready&state=open&per_page=100`,
-    ]);
-    result.pickups = (queue ?? [])
-        .filter((i) => !i.pull_request)
-        .filter((i) => !i.labels.some((l) => ['ai-wip', 'ai-blocked', 'holding'].includes(l.name)))
-        // The label is the hard gate; association is the backstop.
-        .filter((i) => TRUSTED.has(i.author_association))
-        .map(({ number, title, body }) => ({ number, title, body: body ?? '' }));
-    // Slots count what is still in flight once this tick's cleanup and reaping land.
-    const freed = new Set([
-        ...result.cleaned.map((w) => w.issue),
-        ...result.stalled.filter((s) => s.kind === 'implementer').map((s) => s.issue),
-    ]);
-    const inFlight = (wip ?? []).filter((i) => !freed.has(i.number)).length;
-    result.slots = wip ? Math.max(0, MAX_IN_FLIGHT - inFlight) : 0;
-    const loopPrs = (prs ?? []).filter((p) => !p.headRefName.startsWith('dependabot/') &&
-        p.labels.some((l) => l.name === 'merge-ready' || l.name.startsWith('ai-')));
-    result.idle =
-        errors.length === 0 &&
-            loopPrs.length === 0 &&
-            live.length === 0 &&
-            [result.adopt, result.pickups, result.stalled, result.decay, result.dependabotCiRed].every((l) => l.length === 0);
-    result.summary = summarize(result, inFlight, loopPrs.length);
-    return result;
-}
-/** `⚠` segments first, so a truncated phone banner still leads with the stall. */
-export function summarize(r, inFlight, loopPrs) {
-    if (r.idle)
-        return 'idle';
-    const blocked = r.stalled.filter((s) => s.action === 'block').length +
-        r.fixRounds.filter((f) => f.action === 'block').length;
-    const ciRed = r.sendBacks.filter((s) => s.reason === 'ci-red').length + r.dependabotCiRed.length;
-    const wip = inFlight + Math.min(r.slots, r.pickups.length);
-    const ready = r.handoffs.length;
-    const segments = [
-        [r.errors.length > 0, '⚠error'],
-        [blocked, `⚠${blocked}blocked`],
-        [ciRed, `⚠${ciRed}ci-red`],
-        [r.rebuild === 'deferred' || r.rebuild === 'rebuild-failed', '⚠rebuild'],
-        [wip, `${wip}wip`],
-        [loopPrs - ready, `${loopPrs - ready}rev`],
-        [ready, `${ready}ready`],
-    ];
-    return (segments
-        .filter(([n]) => n)
-        .map(([, s]) => s)
-        .join('·') || 'idle');
-}
-export async function loopTickCommand(options) {
-    const result = await runLoopTick(options);
-    if (options.json) {
-        console.log(JSON.stringify(result, null, 2));
-    }
-    else if (result.halt) {
-        console.error(chalk.red(`✖ halt: ${result.halt}`));
-    }
-    else {
-        console.log(result.summary);
-        for (const e of result.errors)
-            console.log(`  ${chalk.yellow(e)}`);
-    }
-    process.exitCode = result.exitCode;
-}

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

@@ -1,132 +0,0 @@
-import path from 'node:path';
-import chalk from 'chalk';
-import fs from 'fs-extra';
-import { realGitExec } from '../../base/git-identity.js';
-import { defaultWorktreeRoot } from './loop-guard.js';
-/**
- * `repo-tooling loop worktree add` — the ai-issue-loop skill's Pass 4
- * worktree creation, moved into code (#616): `git worktree add`, linking every
- * `worktree.symlinkDirectories` entry, the `.git/info/exclude` line, and the
- * assertion that nothing was left unlinked.
- *
- * The prose version iterated `for d in $DIRS`, which zsh does not word-split,
- * so it silently linked nothing (#585). An array has no such failure mode.
- *
- * Exit `0` means the worktree is ready for an implementer. Exit `1` means do
- * not spawn one — either the worktree was not created, or an entry that exists
- * in the main checkout has no link in the worktree. `needsInstall` (exit `0`)
- * means the repo declares no symlink list, so nothing was linked and a real
- * install in the worktree is safe.
- */
-/** `ai-<issue>-<kebab words>` — it becomes a branch name and a path segment. */
-export const SLUG = /^ai-\d+-[a-z0-9]+(?:-[a-z0-9]+)*$/;
-/**
- * Relative and inside the checkout, or dropped: the list comes from a
- * committed file, and `../x` would otherwise link outside both trees.
- */
-function safeEntry(entry) {
-    if (typeof entry !== 'string' || entry.trim() === '')
-        return false;
-    const n = path.normalize(entry);
-    return !path.isAbsolute(n) && n !== '..' && !n.startsWith(`..${path.sep}`);
-}
-export async function symlinkDirectories(root) {
-    const settings = await fs.readJson(path.join(root, '.claude', 'settings.json')).catch(() => null);
-    const dirs = settings?.worktree?.symlinkDirectories;
-    return Array.isArray(dirs) ? dirs.filter(safeEntry) : [];
-}
-/**
- * `node_modules/` with a trailing slash does not match a symlink, so a
- * `git add -A` would commit every link. No slash matches at any depth. The
- * exclude file is shared by every worktree and never committed.
- */
-async function ensureExcluded(root) {
-    const file = path.join(root, '.git', 'info', 'exclude');
-    const current = await fs.readFile(file, 'utf8').catch(() => '');
-    if (current.split('\n').includes('node_modules'))
-        return false;
-    await fs.outputFile(file, `${current}${current && !current.endsWith('\n') ? '\n' : ''}node_modules\n`);
-    return true;
-}
-async function isSymlink(p) {
-    return fs
-        .lstat(p)
-        .then((s) => s.isSymbolicLink())
-        .catch(() => false);
-}
-export async function runLoopWorktreeAdd(slug, options = {}) {
-    const root = path.resolve(options.root ?? process.cwd());
-    const worktreeRoot = options.worktreeRoot
-        ? path.resolve(options.worktreeRoot)
-        : defaultWorktreeRoot(root);
-    const worktree = path.join(worktreeRoot, slug);
-    // A checkout of a real repo takes longer than realGitExec's 5s default.
-    const git = options.git ?? ((args) => realGitExec(args, root, 120_000));
-    const result = {
-        root,
-        worktree,
-        branch: slug,
-        linked: [],
-        missing: [],
-        needsInstall: false,
-        exitCode: 1,
-        messages: [],
-    };
-    if (!SLUG.test(slug)) {
-        result.messages.push(`⚠ '${slug}' is not ai-<issue>-<kebab-slug>`);
-        return result;
-    }
-    const base = options.base ?? 'origin/main';
-    // Goes to git as an argument; a leading dash would be read as an option.
-    if (base.startsWith('-')) {
-        result.messages.push(`⚠ '${base}' is not a ref`);
-        return result;
-    }
-    await fs.ensureDir(worktreeRoot);
-    if ((await git(['worktree', 'add', worktree, '-b', slug, base])) === null) {
-        result.messages.push(`⚠ git worktree add failed — does branch ${slug} or ${worktree} already exist?`);
-        return result;
-    }
-    result.messages.push(`created ${worktree} on ${slug}`);
-    // Before linking, so the links are never momentarily untracked-and-addable.
-    if (await ensureExcluded(root))
-        result.messages.push('added node_modules to .git/info/exclude');
-    const dirs = await symlinkDirectories(root);
-    if (dirs.length === 0) {
-        result.needsInstall = true;
-        result.messages.push('no worktree.symlinkDirectories — run a real install in the worktree (`fix ai` restores the fast path)');
-    }
-    for (const d of dirs) {
-        const source = path.join(root, d);
-        // An entry pointing at nothing links nothing, and is not missing.
-        if (!(await fs.pathExists(source)))
-            continue;
-        const target = path.join(worktree, d);
-        await fs.ensureDir(path.dirname(target));
-        await fs.symlink(source, target).catch(() => { });
-        if (await isSymlink(target))
-            result.linked.push(d);
-        else
-            result.missing.push(d);
-    }
-    if (result.missing.length > 0) {
-        result.messages.push(`⚠ FATAL: no symlink for ${result.missing.join(', ')} — do not spawn an implementer`);
-        return result;
-    }
-    if (result.linked.length > 0)
-        result.messages.push(`linked ${result.linked.join(', ')}`);
-    result.exitCode = 0;
-    return result;
-}
-export async function loopWorktreeAddCommand(slug, options) {
-    const result = await runLoopWorktreeAdd(slug, options);
-    if (options.json) {
-        console.log(JSON.stringify(result, null, 2));
-    }
-    else {
-        for (const line of result.messages) {
-            console.log(`  ${line.startsWith('⚠') ? chalk.yellow(line) : chalk.gray(line)}`);
-        }
-    }
-    process.exitCode = result.exitCode;
-}