@rtorcato/repo-tooling 3.44.0 → 4.0.0

package/dist/cli/index.js

@@ -5,12 +5,6 @@ import { Command } from 'commander';
 import fs from 'fs-extra';
 import { doctorCommand } from './commands/doctor.js';
 import { fixCommand } from './commands/fix.js';
-import { loopCleanupCommand } from './commands/loop-cleanup.js';
-import { loopEnvCommand } from './commands/loop-env.js';
-import { loopGuardCommand } from './commands/loop-guard.js';
-import { loopCommentCommand, loopVerdictCommand } from './commands/loop-marker.js';
-import { loopReapCommand } from './commands/loop-reap.js';
-import { loopWorktreeAddCommand } from './commands/loop-worktree.js';
 import { setupProject } from './commands/setup.js';
 import { copyPreset, PRESETS } from './utils/copy-preset.js';
 import { getToolVersion } from './utils/version.js';
@@ -296,12 +290,6 @@ const TOOL_CATALOG = [
         exports: [],
         fixTarget: 'ai',
     },
-    {
-        name: 'Claude skills',
-        description: 'Install the ai-issue-loop skill into ~/.claude/skills (user-global, opt-in — see --skills-dir)',
-        exports: [],
-        fixTarget: 'claude-skills',
-    },
 ];
 program
     .command('list')
@@ -325,9 +313,6 @@ program
     .description('🩺 Diagnose project alignment with @rtorcato/repo-tooling presets')
     .option('-d, --directory <path>', 'Target directory to diagnose', process.cwd())
     .option('--json', 'Emit machine-readable JSON output')
-    // The read side of `fix --skills-dir` (#485). No --yes/--json requirement
-    // here: doctor never writes, so an unresolved directory is just reported.
-    .option('--skills-dir <path>', 'Where `fix claude-skills` installs user-global agent skills (default: ~/.claude/skills). Pass the same path `fix` was given, or the skill reports as not installed')
     // Rules are per-repo (#563): this compares them against another repo's, and
     // only reports. Never drift, never a fixer, never part of the exit code.
     .option('--rules-from <owner/repo>', "Report how this repo's config and rules differ from that repo's .repo-tooling.json (informational; read via `gh`)")
@@ -342,11 +327,6 @@ program
     .option('--list', 'List all registered fix targets and exit')
     .option('--resync', 'Re-scaffold every file recorded in .repo-tooling.json')
     .option('--diff', 'Show a unified diff of each change before confirming')
-    .option('--skills-dir <path>', 'Where `fix claude-skills` installs user-global agent skills (default: ~/.claude/skills). Required with --yes/--json when that directory does not exist')
-    // Deliberately not folded into --yes: unattended runs pass --yes, and this is
-    // the one overwrite that destroys work living outside the repo (#480).
-    .option('--force-skills', 'Let `fix claude-skills` overwrite a locally modified skill instead of refusing')
-    .option('--gh-config-dir <path>', 'gh profile signed in as rules.aiLoop.agentUser, for `fix ai-loop-identity` (default: ~/.config/gh-<agentUser>)')
     .action((target, options) => fixCommand(target, {
     directory: options.directory,
     yes: options.yes,
@@ -355,80 +335,21 @@ program
     list: options.list,
     resync: options.resync,
     diff: options.diff,
-    skillsDir: options.skillsDir,
-    forceSkills: options.forceSkills,
-    ghConfigDir: options.ghConfigDir,
 }));
-// Mechanics the ai-issue-loop skill used to describe in prose-with-shell (#519).
-// Deliberately outside the isSelfRepo hook below: the loop runs against this
-// repo like any other, and a guard that refuses here would guard nothing.
-const loop = program.command('loop').description('🔁 ai-issue-loop mechanics as tested commands');
-loop
-    .command('guard')
-    .description('🛡️  Repair a wrongly-bare main checkout and gate the node_modules rebuild')
-    .option('--root <path>', 'Main checkout the loop branches worktrees from', process.cwd())
-    .option('--worktree-root <path>', 'Where ai-* worktrees live (default: <root>-worktrees)')
-    .option('--removed', 'A worktree was removed this tick — consider rebuilding node_modules')
-    .option('--json', 'Emit machine-readable JSON output')
-    .addHelpText('after', '\nExit codes:\n' +
-    '  0  root is a usable work tree (healthy, or repaired in place) — continue the tick\n' +
-    '  1  repair was attempted and failed; the root is still bare — halt the tick\n' +
-    '  2  root is not a repairable main checkout (bare clone, linked worktree, or not a repo) — halt the tick\n')
-    .action(loopGuardCommand);
-loop
-    .command('env')
-    .description('🧭 Resolve ROOT, WT_ROOT, OWNER_REPO, AGENT_USER, HUMAN_USER and ME once')
-    .option('-d, --dir <path>', 'Directory to resolve from — main checkout or any worktree', process.cwd())
-    .option('--json', 'Emit machine-readable JSON output')
-    .addHelpText('after', "\nWithout --json, prints KEY='value' lines for eval. Empty means none.\n" +
-    'Exits 1 when the checkout or its GitHub repo cannot be resolved.\n')
-    .action(loopEnvCommand);
-loop
-    .command('cleanup')
-    .description('🧹 Remove ai-* worktrees whose PR landed on main or was closed')
-    .option('--root <path>', 'Main checkout the loop branches worktrees from', process.cwd())
-    .option('--worktree-root <path>', 'Where ai-* worktrees live (default: <root>-worktrees)')
-    .option('--json', 'Emit machine-readable JSON output')
-    .addHelpText('after', '\nPass `removed` from --json to `loop guard --removed`.\n' +
-    'Exits 1 when a worktree removal failed.\n')
-    .action(loopCleanupCommand);
-loop
-    .command('worktree')
-    .description('🌳 Loop worktree mechanics')
-    .command('add <slug>')
-    .description('🌱 Create ai-<issue>-<slug> off origin/main, link its deps, assert none are missing')
-    .option('--root <path>', 'Main checkout to branch the worktree from', process.cwd())
-    .option('--worktree-root <path>', 'Where ai-* worktrees live (default: <root>-worktrees)')
-    .option('--base <ref>', 'Ref to branch from', 'origin/main')
-    .option('--json', 'Emit machine-readable JSON output')
-    .addHelpText('after', '\nExit 1 when the worktree was not created or a symlinkDirectories entry is left\n' +
-    'unlinked — do not spawn an implementer. needsInstall means no list was declared.\n')
-    .action(loopWorktreeAddCommand);
-loop
-    .command('reap')
-    .description('🪦 Report agents stalled past 45 minutes and what to do about each')
-    .option('--root <path>', 'Main checkout the loop branches worktrees from', process.cwd())
-    .option('--worktree-root <path>', 'Where ai-* worktrees live (default: <root>-worktrees)')
-    .option('--json', 'Emit machine-readable JSON output')
-    .addHelpText('after', '\nRead-only: prints a verdict per stall (block / drop-label / remove-worktree).\n' +
-    'Exits 1 when a gh query failed and the report is incomplete.\n')
-    .action(loopReapCommand);
-loop
-    .command('comment <pr>')
-    .description("💬 Upsert the loop's one decision-marker comment on a PR")
-    .requiredOption('--body-file <path>', 'Comment text, without the marker (- for stdin)')
-    .option('-d, --dir <path>', 'Directory to resolve the GitHub repo from', process.cwd())
-    .option('--json', 'Emit machine-readable JSON output')
-    .action(loopCommentCommand);
-loop
-    .command('verdict <pr>')
-    .description("⚖️  Read a reviewer arm's verdict marker for the PR's current head")
-    .requiredOption('--arm <arm>', 'Reviewer arm: code or sec')
-    .option('-d, --dir <path>', 'Directory to resolve the GitHub repo from', process.cwd())
-    .option('--json', 'Emit machine-readable JSON output')
-    .addHelpText('after', '\nPrints PASS, PASS-NOTES, CHANGES, or an empty line when none is posted.\n' +
-    'Exits 1 when the PR or its reviews cannot be read.\n')
-    .action(loopVerdictCommand);
+// The ai-issue-loop pipeline moved to @rtorcato/repo-ai (#658). Kept as a
+// pointer so a stale skill calling `repo-tooling loop …` fails loudly with the
+// fix, instead of commander's generic "unknown command".
+program
+    .command('loop', { hidden: true })
+    .argument('[args...]')
+    .allowUnknownOption()
+    .helpOption(false)
+    .action(() => {
+    console.error(chalk.red('`repo-tooling loop` moved to @rtorcato/repo-ai.') +
+        '\n  Run `npx @rtorcato/repo-ai loop …`, and refresh the skills with' +
+        '\n  `npx @rtorcato/repo-ai fix claude-skills --force-skills`.');
+    process.exitCode = 1;
+});
 program.hook('preAction', async (_, actionCommand) => {
     const name = actionCommand.name();
     if (name === 'setup' || name === 'doctor' || name === 'fix') {

package/dist/cli/utils/lockfile.js

@@ -1,7 +1,6 @@
 import path from 'node:path';
 import fs from 'fs-extra';
 import { CONFIG_SCHEMA, validateProjectConfig } from '../commands/setup-presets.js';
-import { SHIPPED_SKILLS } from '../generators/claude-skills.js';
 import { getToolVersion } from './version.js';
 export const LOCKFILE_NAME = '.repo-tooling.json';
 // Package and bin name used before the js-tooling→repo-tooling rename (#272).
@@ -51,9 +50,8 @@ export const DEFAULT_RULES = {
  * `pnpm schema:generate` and gated by tests/cli/utils/lockfile-schema.test.ts.
  *
  * A function, not a const: lockfile.ts sits in an import cycle with
- * setup-presets.ts (via the swift scaffolder) and with claude-skills.ts (via
- * copy-preset.ts), so CONFIG_SCHEMA and SHIPPED_SKILLS are both in their TDZ
- * while this module evaluates. Reading them here, at call time, is safe.
+ * setup-presets.ts (via the swift scaffolder), so CONFIG_SCHEMA is in its TDZ
+ * while this module evaluates. Reading it here, at call time, is safe.
  */
 // ponytail: key sets are compiler-checked against the type; a changed field
 // *type* (string → number) still needs both lines edited by hand.
@@ -113,7 +111,7 @@ export function lockfileSchema() {
                     aiLoop: {
                         type: 'object',
                         additionalProperties: false,
-                        description: 'Settings for the ai-issue-loop skills. Repo-scoped on purpose: committed here they travel with the repo and survive a new laptop.',
+                        description: 'Settings for the ai-issue-loop skills from @rtorcato/repo-ai. Repo-scoped on purpose: committed here they travel with the repo and survive a new laptop.',
                         properties: {
                             agentUser: {
                                 type: 'string',
@@ -123,8 +121,8 @@ export function lockfileSchema() {
                     },
                     requiredSkills: {
                         type: 'array',
-                        items: { type: 'string', enum: SHIPPED_SKILLS },
-                        description: 'Agent skills this repo\'s workflows depend on. doctor compares each installed copy\'s stamped hash against the shipped one and reports a missing or stale skill — always as "not configured", never drift, because it probes the machine rather than the repo. It never runs the fixer for you.',
+                        items: { type: 'string' },
+                        description: "Agent skills this repo's workflows depend on. Audited by `npx @rtorcato/repo-ai doctor`, which reports a missing or stale installed copy; it never installs one for you.",
                     },
                     mcp: {
                         type: 'object',

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rtorcato/repo-tooling",
-	"version": "3.44.0",
+	"version": "4.0.0",
 	"description": "One CLI to scaffold, audit and fix your repo's whole toolchain — linting, tests, commits, releases & CI.",
 	"type": "module",
 	"keywords": [

package/dist/base/agent-user.js

@@ -1,68 +0,0 @@
-import path from 'node:path';
-import fs from 'fs-extra';
-import { realGhExec } from './github-settings.js';
-/**
- * `aiLoop.agentUser` assignability (#530). The skills that consume the option
- * (`ai-issue-loop`, `ai-workflow`) verify it at runtime and *silently assign
- * nothing* on failure — by design, so a deleted bot account or a bot never
- * added as a collaborator degrades the loop with no visible symptom. This
- * check is where that failure becomes visible.
- *
- * Read-only, on the same `gh` seam as labels.ts and milestones.ts. Everything
- * derives from the consuming repo: the login from its lockfile, the repo from
- * its own remote via gh's `{owner}/{repo}` placeholders.
- */
-const CHECK = 'AI loop agent';
-/**
- * GitHub login shape: 1–39 chars, alphanumerics and single hyphens, no leading
- * or trailing hyphen. The injection boundary — the login is interpolated into
- * the API path below.
- */
-export const LOGIN = /^[a-zA-Z0-9](?:-?[a-zA-Z0-9]){0,38}$/;
-const skip = (reason) => ({
-    check: CHECK,
-    status: 'ok',
-    detail: `skipped — ${reason}`,
-});
-export async function checkAgentUser(dir, agentUser, exec) {
-    // Absent field ⇒ not applicable — the single-identity model is the default,
-    // not a requirement (#521).
-    if (!agentUser) {
-        return {
-            check: CHECK,
-            status: 'ok',
-            detail: 'not applicable — no rules.aiLoop.agentUser in .repo-tooling.json',
-        };
-    }
-    if (!LOGIN.test(agentUser)) {
-        return {
-            check: CHECK,
-            status: 'drift',
-            detail: `rules.aiLoop.agentUser "${agentUser}" is not a valid GitHub login`,
-            hint: 'Fix or remove rules.aiLoop.agentUser in .repo-tooling.json',
-        };
-    }
-    // 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));
-    // 204 when the login can be assigned issues on this repo, 404 otherwise.
-    const r = await gh(['api', `repos/{owner}/{repo}/assignees/${agentUser}`]);
-    if (r.ok) {
-        return {
-            check: CHECK,
-            status: 'ok',
-            detail: `rules.aiLoop.agentUser "${agentUser}" is an assignable collaborator`,
-        };
-    }
-    if (/HTTP 404/.test(r.stderr)) {
-        return {
-            check: CHECK,
-            status: 'drift',
-            detail: `rules.aiLoop.agentUser "${agentUser}" is not an assignable collaborator — the loop skills will silently assign nothing`,
-            hint: `Add the account as a collaborator (\`gh api -X PUT repos/{owner}/{repo}/collaborators/${agentUser}\`) or remove rules.aiLoop.agentUser from .repo-tooling.json`,
-        };
-    }
-    // Offline, unauthenticated, or gh missing — not evidence of drift.
-    return skip('could not verify assignability');
-}

package/dist/base/ai-loop-identity.js

@@ -1,80 +0,0 @@
-/**
- * `fix ai-loop-identity` (#638): point this checkout's Claude sessions at a gh
- * profile signed in as `rules.aiLoop.agentUser`, so `loop guard` stops halting
- * on `identity: mismatch`. `.repo-tooling.json` (committed) says *who* the agent
- * is; the profile path is machine-specific, so it lands in the gitignored,
- * per-checkout `.claude/settings.local.json`.
- */
-import path from 'node:path';
-import fs from 'fs-extra';
-import { configuredAgentUser } from '../cli/commands/loop-guard.js';
-import { LOGIN } from './agent-user.js';
-import { FixerAbort } from './fixers.js';
-import { realGhExec } from './github-settings.js';
-export const SETTINGS_LOCAL = '.claude/settings.local.json';
-/** The profile dir the fixer looks in when `--gh-config-dir` is not given. */
-export function defaultGhConfigDir(agentUser, home) {
-    return path.join(home, '.config', `gh-${agentUser}`);
-}
-/**
- * Returns the files written. Writes nothing — and aborts with the `gh auth
- * login` command as the hint — unless the profile really is the agent account.
- */
-export async function setupAgentIdentity(targetDir, opts) {
-    const agentUser = await configuredAgentUser(targetDir);
-    if (!agentUser) {
-        console.error('   nothing to do — no rules.aiLoop.agentUser in .repo-tooling.json');
-        return [];
-    }
-    // The login comes from a committed file and becomes a path segment below.
-    if (!LOGIN.test(agentUser)) {
-        throw new FixerAbort('invalid-agent-user', `rules.aiLoop.agentUser "${agentUser}" is not a valid GitHub login`, 'Fix or remove rules.aiLoop.agentUser in .repo-tooling.json');
-    }
-    const dir = path.resolve(opts.ghConfigDir ?? defaultGhConfigDir(agentUser, opts.home));
-    const gh = opts.gh ?? ((args, env) => realGhExec(args, undefined, targetDir, env));
-    const login = (await fs.pathExists(dir))
-        ? await gh(['api', 'user', '--jq', '.login'], { GH_CONFIG_DIR: dir }).then((r) => r.ok ? r.stdout.trim() : '')
-        : '';
-    // GitHub logins are case-insensitive, so a case difference is one account.
-    if (login.toLowerCase() !== agentUser.toLowerCase()) {
-        throw new FixerAbort('agent-identity-unavailable', `${dir} is ${login ? `signed in as ${login}, not ${agentUser}` : `not signed in to gh as ${agentUser}`} — nothing written`, `Sign in once, in a browser logged in as ${agentUser}, then re-run:\n   GH_CONFIG_DIR=${dir} gh auth login --hostname github.com --web --scopes repo`);
-    }
-    const written = [];
-    const settingsPath = path.join(targetDir, SETTINGS_LOCAL);
-    let settings = {};
-    if (await fs.pathExists(settingsPath)) {
-        try {
-            settings = await fs.readJson(settingsPath);
-        }
-        catch {
-            throw new FixerAbort('settings-local-unparseable', `${SETTINGS_LOCAL} is not valid JSON — not overwriting it`, `Fix the file by hand, or add "env": {"GH_CONFIG_DIR": "${dir}"} to it yourself`);
-        }
-    }
-    const env = (settings.env ?? {});
-    if (env.GH_CONFIG_DIR !== dir) {
-        await fs.outputJson(settingsPath, { ...settings, env: { ...env, GH_CONFIG_DIR: dir } }, { spaces: 2 });
-        written.push(SETTINGS_LOCAL);
-    }
-    if (await ensureIgnored(targetDir))
-        written.push('.gitignore');
-    return written;
-}
-// ponytail: exact-line match on the usual spellings; a glob that happens to
-// cover the file gets a redundant (harmless) line. `git check-ignore` if that bites.
-const IGNORE_LINES = new Set([
-    SETTINGS_LOCAL,
-    `/${SETTINGS_LOCAL}`,
-    '.claude',
-    '.claude/',
-    '/.claude',
-    '/.claude/',
-]);
-async function ensureIgnored(targetDir) {
-    const file = path.join(targetDir, '.gitignore');
-    const existing = (await fs.pathExists(file)) ? await fs.readFile(file, 'utf-8') : '';
-    if (existing.split('\n').some((l) => IGNORE_LINES.has(l.trim())))
-        return false;
-    const separator = existing === '' || existing.endsWith('\n') ? '' : '\n';
-    await fs.writeFile(file, `${existing}${separator}${SETTINGS_LOCAL}\n`);
-    return true;
-}

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