@rtorcato/repo-tooling 3.45.0 → 4.1.0

package/AGENTS.md

@@ -8,6 +8,8 @@ A one-package JavaScript / TypeScript tooling distribution. Ships every preset (
 
 **Swift** repos (detected via `Package.swift`) are covered end to end: `setup --preset swift-library` scaffolds a SwiftPM package, and `doctor`/`fix` run the language-agnostic checks plus SwiftLint / Periphery / `.gitignore` / `Package.swift`. **Python** repos (detected via `pyproject.toml` / `setup.py`) get `doctor`/`fix` — Ruff / mypy / pytest / `.gitignore` / CI / git hooks — but no `setup` preset yet. **Perl** distributions (detected via `cpanfile` / `Makefile.PL` / `dist.ini`) get the same deal: Perl::Critic / perltidy / `.gitignore` / CI / git hooks, no `setup` preset. See `src/languages/` — one directory per language module, `src/base/` for what's shared.
 
+The **ai-issue-loop** pipeline (the `loop` commands, its skills, and the label / agent-user / skills checks) lives in [`@rtorcato/repo-ai`](https://github.com/rtorcato/repo-ai) since #658. `repo-tooling loop` now only prints a pointer there. Its settings still sit in this package's `.repo-tooling.json` under `rules.aiLoop` and `rules.requiredSkills`, which repo-tooling carries forward without reading.
+
 ## CLI surface (agent-friendly)
 
 Every command supports `--json` and a non-interactive mode. Combine with `--yes` for fully autonomous use.
@@ -26,12 +28,6 @@ Every command supports `--json` and a non-interactive mode. Combine with `--yes`
 | `fix --dry-run` | ✅ | ✅ | Print what each fixer would write without writing. Combine with `--json`. |
 | `list --json` | ✅ | ✅ | Enumerate the library's surface area. Each entry has `{ name, description, exports, fixTarget }`. |
 | `copy <name>` | ✅ | text only | Copy a single preset (`biome`, `tsconfig`) into the current directory. |
-| `loop guard --root <path>` | ✅ | ✅ | Guard an `ai-issue-loop` tick: repair a wrongly-bare main checkout, gate the `node_modules` rebuild (`--removed`), and assert `gh` authenticates as the declared `rules.aiLoop.agentUser`. Exit `0` continue, `1` repair failed, `2` root is not a repairable checkout or the agent identity is wrong — both non-zero halt the tick. |
-| `loop env` | ✅ | ✅ | Resolve an `ai-issue-loop` tick's variables once: `root` (main checkout, correct from inside a worktree), `worktreeRoot`, `ownerRepo`, `agentUser` (empty unless an assignable collaborator), `humanUser` (empty for org repos), `me`. Without `--json`, prints `KEY='value'` lines for `eval`. Exit `1` when the checkout or its GitHub repo cannot be resolved. |
-| `loop worktree add <ai-N-slug>` | ✅ | ✅ | Create an `ai-issue-loop` worktree at `<root>-worktrees/<slug>` on a new branch off `origin/main` (`--base`), symlink every `worktree.symlinkDirectories` entry from `.claude/settings.json`, and add `node_modules` to `.git/info/exclude`. `needsInstall: true` when no list is declared. Exit `1` when the worktree was not created or an entry is left unlinked — do not spawn an implementer. |
-| `loop reap --json` | ✅ | ✅ | Report the `ai-issue-loop` Pass 2 stalls: a label that sat ≥45 minutes past its last application (per the issue timeline). Each entry is `{ kind, issue, pr, label, minutes, applications, action, worktree, reason }` — `kind` is `implementer` / `reviewer` / `fixer` / `orphan`, `action` is `block` / `drop-label` / `remove-worktree` (`block` once a claim has been applied ≥3 times). Read-only; exit `1` when a `gh` query failed. |
-| `loop tick --json` | ✅ | ✅ | One `ai-issue-loop` tick's work list: runs `loop guard`, `loop cleanup` (and `guard --removed`) and `loop reap`, reads verdicts, merge states, required checks and the `ai-ready` queue, and returns `{ halt, idle, adopt, disarm, handoffs, sendBacks, stripMergeReady, cleaned, stalled, decay, verdicts, reviewsToSpawn, fixRounds, slots, pickups, summary, errors }`. Writes no GitHub state — the skill applies every label, comment and spawn. Exit `1`/`2` halts the tick. |
-| `loop comment <pr> --body-file <path>` / `loop verdict <pr> --arm <code\|sec>` | ✅ | ✅ | The loop's hidden-marker protocols. `comment` upserts the one `<!-- ai-issue-loop:decision -->` comment (body from a file or `-` stdin, never argv). `verdict` prints the arm's `PASS` / `PASS-NOTES` / `CHANGES` for the PR's current head, or empty. Both only trust markers posted by `gh`'s own login. Exit `1` when GitHub cannot be read. |
 
 ## Recommended workflows
 
@@ -90,25 +86,13 @@ npx @rtorcato/repo-tooling fix dependabot --yes --json
 npx @rtorcato/repo-tooling fix engines --yes --json
 npx @rtorcato/repo-tooling fix docs-site --yes --json   # scaffold a Docusaurus docs site under apps/docs
 npx @rtorcato/repo-tooling fix bun --yes --json         # Bun runtime/test config
-
-# Opt-in only — writes user-global state, so a bare `fix` / `fix --yes` skips it.
-# Installs the ai-issue-loop skill to ~/.claude/skills. Override with --skills-dir,
-# which is required alongside --yes/--json when that directory doesn't exist.
-npx @rtorcato/repo-tooling fix claude-skills --yes --json
-
-# Opt-in only. Points this checkout's Claude sessions at a gh profile signed in as
-# rules.aiLoop.agentUser (~/.config/gh-<agentUser>, or --gh-config-dir) by merging
-# env.GH_CONFIG_DIR into the gitignored .claude/settings.local.json. Every session
-# in the checkout then runs as the agent, hands-on ones included. Writes nothing
-# and prints the `gh auth login` command if the profile isn't that account.
-npx @rtorcato/repo-tooling fix ai-loop-identity --yes --json
 ```
 
 ## Drift policy (important)
 
 `fix` defaults the confirm prompt to **No** for drift cases (existing file that doesn't extend our preset). The `--yes` flag is required to overwrite drift. Safe-merge fixers (`biome`, `engines`, `husky`, `package-json`) never overwrite — they add/merge — and use friendlier prompt wording. `fix --json` implies `--yes` (prompts would corrupt JSON output).
 
-Fixers marked `explicitOnly` are exempt from `fix` all *and* from `fix --yes` — they only run when named as the target. Today that is `claude-skills` (writes outside the repo), `release-environment` (changes what a merge does), and `ai-loop-identity` (changes which account every session in the checkout acts as).
+Fixers marked `explicitOnly` are exempt from `fix` all *and* from `fix --yes` — they only run when named as the target. Today that is `release-environment` (changes what a merge does).
 
 The same goes for every `optional-missing` finding: a bulk `fix` records it `skipped`, because optional tools are often mutually exclusive (Biome / ESLint / Prettier / Oxlint, semantic-release / Changesets / Release Please) and installing them all is never the intent (#630). Name the one you want — `fix editorconfig --yes`.
 
@@ -121,12 +105,6 @@ A fixer may also **refuse** — the target file holds something the generator ca
 - `src/cli/commands/doctor.ts` — all checks and the public `runDoctor(dir)` / `evaluateNodeVersion(version)` / `nextStepSuggestions(results)`
 - `src/cli/commands/fix.ts` — `Fixer` interface, fixer registry, `fixCommand`
 - `src/cli/commands/fix-targets.ts` — shared check → fix target map (used by both doctor's footer and fix's lookup)
-- `src/cli/commands/loop-guard.ts` — `loop guard`: the `--is-inside-work-tree` / `.git` invariant table and the `node_modules` rebuild gate, drained out of the ai-issue-loop skill's prose (#519)
-- `src/cli/commands/loop-env.ts` — `loop env`: the skill's Pass 0 variables resolved in one call (#615)
-- `src/cli/commands/loop-worktree.ts` — `loop worktree add`: Pass 4 worktree creation, dependency linking and the missing-link assertion (#616)
-- `src/cli/commands/loop-reap.ts` — `loop reap`: the skill's Pass 2 stalled-agent table as verdicts (#618)
-- `src/cli/commands/loop-tick.ts` — `loop tick`: composes the other `loop` helpers into one tick's work list, so the skill keeps only judgement and spawns (#620)
-- `src/cli/commands/loop-marker.ts` — `loop comment` / `loop verdict`: the decision-comment upsert and verdict read-back, with the author and head-commit gates (#619)
 - `src/cli/generators/` — one file per concern (linting, testing, build, git, github-actions, security, misc)
 - `tooling/` — every shipped preset, mirrored 1:1 with `package.json` `exports`
 

package/README.md

@@ -92,7 +92,6 @@ See the [Getting Started guide](https://rtorcato.github.io/repo-tooling/guides/g
 | `copy <config>` | Copy a single config file into the current project. | `npx @rtorcato/repo-tooling copy biome` |
 | `doctor` | Diagnose an existing project for missing or drifted tooling. | `npx @rtorcato/repo-tooling doctor` |
 | `fix [target]` | Apply scaffolders for what `doctor` flagged (`--yes`, `--dry-run`, `--diff`). | `npx @rtorcato/repo-tooling fix` |
-| `loop guard` | Repair a main checkout that has gone `core.bare = true`, gate the `node_modules` rebuild after a worktree removal, and halt when `gh` is not authenticated as the `rules.aiLoop.agentUser` the repo declares. Exits `1` if the repair failed and `2` if the root is not a repairable checkout or the identity is wrong — see `--help`. | `npx @rtorcato/repo-tooling loop guard --root .` |
 
 Prefer to run the audit in CI? `doctor` also ships as a GitHub Action:
 
@@ -182,27 +181,28 @@ ln -sf ../../node_modules/@rtorcato/repo-tooling/tooling/claude/repo-tooling.md
 ### Use with Claude Code (plugin)
 
 This repo is also a self-hosted Claude Code marketplace. Install the plugin to
-get six skills — `repo-tooling` (adopt/audit the presets via the CLI),
-`npm-publish` (never hand-cut a release), `ai-workflow` (**the entry point** to
-the `ai-ready` issue → PR pipeline: bursts the queue in parallel worktrees, then
-schedules the engine below), `ai-issue-loop` (that engine — one stateless tick;
-it runs on a loop rather than being typed), `ai-issue` (file agent-executable
-issues) and `ai-loop-status` (read-only pipeline status) — in any session:
+get its skills — `repo-tooling` (adopt/audit the presets via the CLI),
+`npm-publish` (never hand-cut a release) and `dogfood` (run the tooling against
+throwaway fixtures) — in any session:
 
 ```
 /plugin marketplace add rtorcato/repo-tooling
 /plugin install repo-tooling@repo-tooling
 ```
 
-The four `ai-*` skills also install on their own, user-globally, so every repo
-on the machine shares one copy:
+### The AI issue loop
+
+The label-driven `ai-ready` issue → PR pipeline (the `ai-workflow`,
+`ai-issue-loop`, `ai-issue` and `ai-loop-status` skills, and the `loop`
+commands they call) moved to its own package,
+[`@rtorcato/repo-ai`](https://github.com/rtorcato/repo-ai), so this one can be
+used without it:
 
 ```bash
-npx @rtorcato/repo-tooling fix claude-skills   # → ~/.claude/skills/{ai-issue-loop,ai-workflow,ai-issue,ai-loop-status}/SKILL.md
+npx @rtorcato/repo-ai fix claude-skills   # → ~/.claude/skills/{ai-issue-loop,ai-workflow,ai-issue,ai-loop-status}/SKILL.md
 ```
 
-It writes outside the repo, so it is opt-in: a bare `fix` skips it. See the
-[AI Issue Loop guide](https://rtorcato.github.io/repo-tooling/guides/ai-issue-loop/).
+Its settings stay in `.repo-tooling.json` (`rules.aiLoop`, `rules.requiredSkills`).
 
 ### Use with other AI tools (Cursor / Copilot / Codex)
 
@@ -239,10 +239,7 @@ MIT — see [LICENSE](LICENSE).
 Any agent that supports the [`skills`](https://www.npmjs.com/package/skills) CLI can install this repo's skills straight from GitHub — no clone, no package install:
 
 ```bash
-npx skills add https://github.com/rtorcato/repo-tooling --skill 'ai-issue'
-npx skills add https://github.com/rtorcato/repo-tooling --skill 'ai-issue-loop'
-npx skills add https://github.com/rtorcato/repo-tooling --skill 'ai-loop-status'
-npx skills add https://github.com/rtorcato/repo-tooling --skill 'ai-workflow'
+npx skills add https://github.com/rtorcato/repo-tooling --skill 'dogfood'
 npx skills add https://github.com/rtorcato/repo-tooling --skill 'npm-publish'
 npx skills add https://github.com/rtorcato/repo-tooling --skill 'repo-tooling'
 ```

package/dist/base/checks.js

@@ -2,7 +2,6 @@ import path from 'node:path';
 import fs from 'fs-extra';
 import { BLOCK_START, hasStaleAgentBlock } from '../cli/generators/agent-rules.js';
 import { BADGE_START, hasPublicOnlyBadges } from '../cli/generators/badges.js';
-import { claudeSkillStatus, SHIPPED_SKILLS, skillDiffCommand, } from '../cli/generators/claude-skills.js';
 import { DEPENDABOT_CONFIG_PATHS, dependabotConfigDeltas, dependabotEcosystemFor, dependabotIgnoreRules, } from '../cli/generators/security.js';
 import { detectNestedLanguages } from '../cli/utils/detect-language.js';
 /**
@@ -456,137 +455,6 @@ export async function checkAiSetup(dir) {
         hint: 'Run `npx @rtorcato/repo-tooling fix ai` to scaffold agent rules for every AI tool',
     };
 }
-/**
- * The user-global agent skills this package ships (#404).
- *
- * The only check that reports on state *outside* the repo being audited, which
- * is why it never returns `drift` or `missing`: an out-of-date `~/.claude/skills`
- * is not a defect in this repo, and either of those statuses would fail its CI
- * over a file CI has never seen. `optional-missing` is the honest verdict — an
- * opt-in workflow tool that isn't configured — and it leaves the exit code alone.
- *
- * `skillsDir` is doctor's `--skills-dir`. Without it this reported against
- * `~/.claude/skills` whatever directory the repo actually installs into, so a
- * consumer who passes the flag to `fix` saw a permanent false `optional-missing`
- * for a skill they have (#485).
- */
-export async function checkClaudeSkills(skillsDir) {
-    const check = 'Claude skills';
-    const hint = `Run \`npx @rtorcato/repo-tooling fix claude-skills\` to install the ${SHIPPED_SKILLS.join(', ')} skills (writes outside the repo; opt-in, so \`fix\` alone skips it)`;
-    const statuses = [];
-    for (const name of SHIPPED_SKILLS)
-        statuses.push([name, await claudeSkillStatus(name, skillsDir)]);
-    if (statuses.every(([, s]) => s.file === null)) {
-        return {
-            check,
-            status: 'optional-missing',
-            detail: `no ~/.claude/skills — the ${SHIPPED_SKILLS.join(', ')} skills are not installed`,
-            hint,
-        };
-    }
-    const missing = statuses.filter(([, s]) => !s.installed).map(([name]) => name);
-    const behind = statuses.filter(([, s]) => s.installed && s.needsInstall);
-    if (missing.length > 0 || behind.length > 0) {
-        const parts = [
-            missing.length > 0 ? `not installed: ${missing.join(', ')}` : null,
-            ...behind.map(([name, s]) => `${name} is at ${s.installedVersion ?? 'an unstamped version'}; this package ships ${s.shippedVersion}`),
-        ].filter((p) => p !== null);
-        return { check, status: 'optional-missing', detail: parts.join('; '), hint };
-    }
-    // A local fork is `ok` for the same reason a modified copied asset is (#448):
-    // it is somebody's deliberate work, so it is named once and never nagged as
-    // fixable — pointing at a `fix` that would refuse is worse than saying nothing.
-    // `realFile` is set whenever `contentState` is — both mean something is
-    // installed. The extra test is TypeScript's, not a real condition.
-    const forks = statuses.filter(([, s]) => s.realFile && s.contentState && s.contentState !== 'pristine');
-    if (forks.length > 0) {
-        const detail = forks
-            .map(([name, s]) => {
-            const why = s.contentState === 'modified'
-                ? `has local changes since ${s.installedVersion}`
-                : 'carries no content record, so a fork cannot be told from a stale copy';
-            return `${name} skill at ${s.file} ${why}; this package ships ${s.shippedVersion} and will not overwrite it`;
-        })
-            .join('; ');
-        // Name both paths: "diff it against the shipped copy" left the reader
-        // with nothing to diff, in the one case they most want to look (#484).
-        const diffs = forks
-            .map(([, s]) => s.realFile
-            ? `\`${skillDiffCommand({ realFile: s.realFile, shippedFile: s.shippedFile })}\``
-            : null)
-            .filter((d) => d !== null)
-            .join(', ');
-        return {
-            check,
-            status: 'ok',
-            detail,
-            hint: `Diff against the shipped copy — ${diffs} — then run \`npx @rtorcato/repo-tooling fix claude-skills --force-skills\` to take the shipped version`,
-        };
-    }
-    const versions = new Set(statuses.map(([, s]) => s.installedVersion));
-    return {
-        check,
-        status: 'ok',
-        detail: `${SHIPPED_SKILLS.length} skills installed at ${[...versions].join(', ')}`,
-    };
-}
-/**
- * The skills *this repo* declares it depends on — `requiredSkills` in
- * `.repo-tooling.json` (#533). Where `checkClaudeSkills` above reports on the
- * package's whole skill set as a machine-level nicety, this one is the repo
- * asserting a dependency, so it names the skills the repo actually runs on and
- * reports a stale installed copy against them.
- *
- * Staleness is the failure mode it exists for. Absence fails loudly the moment
- * something reaches for the skill; a copy three releases behind runs to
- * completion without complaint — observed 2026-08-26, an `ai-issue-loop` missing
- * both its decision-comment security gate and its decay rule.
- *
- * Same severity rule as `checkClaudeSkills`, for the same reason: it probes the
- * machine, not the repo, so it never returns `drift` or `missing`. A contributor
- * with no Claude installed must not fail this repo's `doctor`.
- *
- * **Check and hint only.** The fixer writes into `~/`, and repo config that
- * triggers writes outside the repo is the shape of a supply-chain attack even
- * when the content is benign. doctor says stale; the human runs the fixer.
- */
-export async function checkRequiredSkills(names, skillsDir) {
-    const check = 'Required skills';
-    const hint = 'Run `npx @rtorcato/repo-tooling fix claude-skills` yourself to install or refresh them — add `--force-skills` to overwrite a locally modified copy. It writes to `~/.claude`, outside this repo, so nothing runs it for you.';
-    // A name outside SHIPPED_SKILLS has no shipped asset to hash against, and
-    // reading one would throw rather than report. The published schema rejects it
-    // in an editor; this is the runtime half of the same validation.
-    const unknown = names.filter((name) => !SHIPPED_SKILLS.includes(name));
-    if (unknown.length > 0) {
-        return {
-            check,
-            status: 'optional-missing',
-            detail: `.repo-tooling.json lists ${unknown.join(', ')}, which this package does not ship`,
-            hint: `requiredSkills accepts ${SHIPPED_SKILLS.join(', ')}`,
-        };
-    }
-    const statuses = [];
-    for (const name of names)
-        statuses.push([name, await claudeSkillStatus(name, skillsDir)]);
-    const missing = statuses.filter(([, s]) => !s.installed).map(([name]) => name);
-    // `needsInstall` is `behind && pristine`, so these two partitions are disjoint:
-    // a copy matching no shipped version is a fork, not something to update.
-    const stale = statuses.filter(([, s]) => s.installed && s.needsInstall);
-    const modified = statuses.filter(([, s]) => s.contentState && s.contentState !== 'pristine');
-    const parts = [
-        missing.length > 0 ? `not installed: ${missing.join(', ')}` : null,
-        ...stale.map(([name, s]) => `${name} is stale — installed ${s.installedVersion ?? 'unstamped'}, this package ships ${s.shippedVersion}`),
-        ...modified.map(([name, s]) => `${name} at ${s.file} matches no version this package has shipped`),
-    ].filter((part) => part !== null);
-    if (parts.length === 0) {
-        return {
-            check,
-            status: 'ok',
-            detail: `${names.length} required skill(s) installed and current: ${names.join(', ')}`,
-        };
-    }
-    return { check, status: 'optional-missing', detail: parts.join('; '), hint };
-}
 /**
  * The MCP servers this repo's workflow assumes — `mcp.recommended` in
  * `.repo-tooling.json` (#534). Informational in the strongest sense: it reports

package/dist/base/fixers.js

@@ -11,13 +11,10 @@
  * language-shaped (CI steps, recorded tool choices), so each module ships its
  * own — see src/base/ci.ts for the shell they share.
  */
-import os from 'node:os';
 import path from 'node:path';
 import chalk from 'chalk';
 import fs from 'fs-extra';
-import inquirer from 'inquirer';
 import { installAgentRules, installAiSetup } from '../cli/generators/agent-rules.js';
-import { installClaudeSkill, resolveSkillsDir, SHIPPED_SKILLS, skillDiffCommand, } from '../cli/generators/claude-skills.js';
 import { generateBrand } from '../cli/generators/brand.js';
 import { generateCommunityHealth } from '../cli/generators/community-health.js';
 import { generateCommitlintConfig } from '../cli/generators/git.js';
@@ -27,9 +24,7 @@ import { classifyCopiedAssets } from '../cli/utils/copied-assets.js';
 import { copyPreset } from '../cli/utils/copy-preset.js';
 import { detectAuditLanguage } from '../cli/utils/detect-language.js';
 import { resolveLanguageModule } from '../languages/registry.js';
-import { SETTINGS_LOCAL, setupAgentIdentity } from './ai-loop-identity.js';
 import { applyGithubSettings, applyReleaseEnvironment, RELEASE_ENV_CHECK, RELEASE_GATE_CHECK, } from './github-settings.js';
-import { applyLoopLabels } from './labels.js';
 import { closeCompletedMilestones } from './milestones.js';
 /**
  * A fixer giving up on something the user has to resolve — a wrong flag, not a
@@ -59,49 +54,6 @@ async function moduleFor(targetDir) {
         dependabotEcosystem: null,
     });
 }
-/**
- * Where to install user-global skills, asking only when nothing resolves. Under
- * `--yes` / `--json` a prompt is not available — `--json` would have its payload
- * corrupted by one — and guessing at a directory the user never mentioned is not
- * an option either, so the run fails: `--skills-dir` is required in that case
- * (#411). It used to warn and no-op, which exited 0 with an empty `filesWritten`
- * that no `--json` consumer could tell apart from "already up to date".
- */
-async function resolveInstallDir(explicit, assumeYes) {
-    const { dir } = await resolveSkillsDir(explicit);
-    if (dir)
-        return dir;
-    if (assumeYes) {
-        throw new FixerAbort('no-skills-dir', 'no ~/.claude/skills found, and --yes/--json cannot prompt for one', 'pass --skills-dir <path>');
-    }
-    const { answer } = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'answer',
-            message: 'Install agent skills where?',
-            default: path.join(os.homedir(), '.claude', 'skills'),
-        },
-    ]);
-    const trimmed = typeof answer === 'string' ? answer.trim() : '';
-    return trimmed ? path.resolve(trimmed) : null;
-}
-/**
- * Why the install refused, and what to do about it. A bare "skipped" would be
- * its own failure mode: the user still wants the update, and nothing on screen
- * would say how to get it or what they would be giving up (#480).
- */
-function describeSkillFork(result) {
-    const target = result.viaSymlink ? `${result.file} → ${result.realFile}` : result.realFile;
-    const why = result.contentState === 'modified'
-        ? `its content has diverged from the ${result.installedVersion} release it was installed from`
-        : 'it carries no content record, so a local fork and a stale copy are indistinguishable';
-    return [
-        `skipped — ${result.name} was not overwritten with ${result.shippedVersion}: ${why}`,
-        `  ${target}`,
-        `  compare:  ${skillDiffCommand(result)}`,
-        '  overwrite anyway:  fix claude-skills --force-skills',
-    ];
-}
 export const BASE_FIXERS = [
     {
         target: 'copied-assets',
@@ -260,19 +212,6 @@ export const BASE_FIXERS = [
             return { filesWritten: await closeCompletedMilestones(targetDir) };
         },
     },
-    {
-        target: 'labels',
-        description: 'Repair ai-issue-loop label colours and descriptions on GitHub via `gh label edit` (mutates the remote repo, not files). No-ops on a repo that does not use the loop',
-        appliesTo: ['AI loop labels'],
-        outputs: ['GitHub labels (remote, via gh label edit)'],
-        // safe-add for the same reason github-settings is: it exempts this fixer
-        // from the `--diff` shadow-run, which executes run() for a mere preview.
-        riskLevel: 'safe-add',
-        canFixDrift: true,
-        async run({ targetDir }) {
-            return { filesWritten: await applyLoopLabels(targetDir) };
-        },
-    },
     {
         target: 'codeowners',
         description: 'Scaffold .github/CODEOWNERS with commented examples',
@@ -318,8 +257,8 @@ export const BASE_FIXERS = [
         // image paths — hand-edited art is never clobbered.
         riskLevel: 'safe-merge',
         canFixDrift: true,
-        async run({ targetDir, pkg }) {
-            const filesWritten = await generateBrand(pkg, targetDir);
+        async run({ targetDir, pkg, lock }) {
+            const filesWritten = await generateBrand(pkg, targetDir, lock?.rules?.brand?.tagline);
             if (filesWritten.some((f) => f.endsWith('.svg'))) {
                 console.error(chalk.dim('   next: run `brand/render.sh` to render the PNGs (needs librsvg — `brew install librsvg`)'));
             }
@@ -363,68 +302,6 @@ export const BASE_FIXERS = [
             return { filesWritten: [result.target] };
         },
     },
-    {
-        target: 'claude-skills',
-        description: `Install the ${SHIPPED_SKILLS.join(', ')} Claude Code skills into the user-level skills dir (~/.claude/skills, or --skills-dir). Writes outside the repo`,
-        appliesTo: ['Claude skills'],
-        outputs: SHIPPED_SKILLS.map((name) => `~/.claude/skills/${name}/SKILL.md`),
-        // safe-add is load-bearing for the same reason it is on github-settings:
-        // it exempts this fixer from the `--diff` shadow-run, which copies the repo
-        // to tmp and *executes* run() — here that would write to the real home dir
-        // during what the user asked to be a preview.
-        riskLevel: 'safe-add',
-        explicitOnly: true,
-        canFixDrift: true,
-        async run({ skillsDir, forceSkills, assumeYes }) {
-            const dir = await resolveInstallDir(skillsDir, assumeYes);
-            if (!dir)
-                return { filesWritten: [] };
-            const filesWritten = [];
-            for (const name of SHIPPED_SKILLS) {
-                const result = await installClaudeSkill(dir, name, { force: forceSkills });
-                if (result.status === 'declined-downgrade') {
-                    // Say what was compared, not what is newer: the version is a label,
-                    // and on a git checkout it can understate the content behind it
-                    // (#522). Naming the escape hatch matters for exactly that case.
-                    console.error(chalk.yellow(`   skipped — ${result.file} is stamped ${result.installedVersion}, above the ${result.shippedVersion} this package reports; not overwritten`));
-                    console.error(chalk.yellow('   overwrite anyway:  fix claude-skills --force-skills'));
-                    continue;
-                }
-                if (result.status === 'declined-fork') {
-                    // Name `realFile`: through a stow symlink the overwrite would land in a
-                    // *second* repo's working tree, and that is the path to look at (#480).
-                    for (const line of describeSkillFork(result))
-                        console.error(chalk.yellow(`   ${line}`));
-                    continue;
-                }
-                if (result.status === 'up-to-date')
-                    continue;
-                // Report the resolved real path when the skill is a stow symlink: the bytes
-                // landed in a dotfiles checkout, and that is where the user has to commit them.
-                if (result.viaSymlink) {
-                    console.error(chalk.dim(`   wrote through a symlink — commit ${result.realFile}`));
-                }
-                filesWritten.push(result.realFile);
-            }
-            return { filesWritten };
-        },
-    },
-    {
-        target: 'ai-loop-identity',
-        description: "Point this checkout's Claude sessions at a gh profile signed in as rules.aiLoop.agentUser (~/.config/gh-<agentUser>, or --gh-config-dir) via .claude/settings.local.json. Every session in the checkout then runs as the agent",
-        appliesTo: ['AI loop identity'],
-        outputs: [SETTINGS_LOCAL, '.gitignore'],
-        // safe-add keeps it out of the `--diff` shadow-run, which would spawn gh;
-        // explicitOnly because it changes who every session here acts as.
-        riskLevel: 'safe-add',
-        explicitOnly: true,
-        canFixDrift: true,
-        async run({ targetDir, ghConfigDir }) {
-            return {
-                filesWritten: await setupAgentIdentity(targetDir, { ghConfigDir, home: os.homedir() }),
-            };
-        },
-    },
     {
         target: 'cursor-rules',
         description: 'Install the repo-tooling rules for Cursor (.cursor/rules/repo-tooling.mdc)',

package/dist/base/github-settings.js

@@ -588,19 +588,6 @@ async function readEnvironments(gh, nwo) {
         return 'skip';
     }
 }
-/**
- * The ai-issue-loop's unattended-merge probe (#620): true only when the job
- * that publishes runs behind an environment carrying `required_reviewers`, so a
- * human still stands between a merge and the registry. An environment no job
- * references gates nothing, and every unreadable answer fails closed.
- */
-export async function releaseGated(gh, nwo, dir) {
-    const publish = await findPublishJob(dir);
-    if (publish === null || publish === 'skip' || publish.environment === null)
-        return false;
-    const envs = await readEnvironments(gh, nwo);
-    return envs !== 'skip' && envs.get(publish.environment) === true;
-}
 /**
  * The gap between merging the default branch and publishing to npm (#429). On
  * the shipped semantic-release preset those are one event: nothing stands

package/dist/cli/commands/doctor.js

@@ -12,16 +12,14 @@ import { resolveLanguageModule } from '../../languages/registry.js';
 import { SWIFT_GIT_HOOKS, runSwiftChecks } from '../../languages/swift/checks.js';
 import { readSwiftPackage, renderSwiftWorkflow } from '../../languages/swift/ci.js';
 import { detectAuditLanguage } from '../utils/detect-language.js';
-import { checkAgentUser } from '../../base/agent-user.js';
 import { checkGitHubSettings } from '../../base/github-settings.js';
-import { checkLoopLabels } from '../../base/labels.js';
 import { checkMilestones } from '../../base/milestones.js';
 import { checkGitIdentity, checkGitIdentityHistory } from '../../base/git-identity.js';
 import { checkCopiedAssets } from '../utils/copied-assets.js';
 import { LOCKFILE_VERSION, readLockfile } from '../utils/lockfile.js';
 import { compareRulesWithReference } from '../utils/reference-rules.js';
 import { declinedInLock, getFixTargetForCheck } from './fix-targets.js';
-import { checkAiSetup, checkBrand, checkCodeowners, checkClaudeSkills, checkCodeQL, checkCommunityHealth, checkCoverageUpload, checkDependabot, checkEditorConfig, checkFile, checkGitHooks, checkGitHubActions, checkGitLabCI, checkNestedLanguages, checkPrePushHook, checkReadmeBadges, checkRecommendedMcp, checkRequiredSkills, COMMITLINT_FILE_CHECK, } from '../../base/checks.js';
+import { checkAiSetup, checkBrand, checkCodeowners, checkCodeQL, checkCommunityHealth, checkCoverageUpload, checkDependabot, checkEditorConfig, checkFile, checkGitHooks, checkGitHubActions, checkGitLabCI, checkNestedLanguages, checkPrePushHook, checkReadmeBadges, checkRecommendedMcp, COMMITLINT_FILE_CHECK, } from '../../base/checks.js';
 import { allDeps, checkAreTheTypesWrong, checkBiome, checkClaudeWorktreeSettings, checkConfigSchemaVersions, checkDocsSite, checkEnginesNode, checkExportsBuildable, checkGitDependencies, checkKnip, checkLintStaged, checkNodeVersionConsistency, checkNodeVersionPin, checkPackageJson, checkPackageManager, checkPeerVersions, checkPublint, checkSemanticRelease, checkSizeLimit, checkTailwind, checkBuildApprovals, checkPnpmWorkspace, checkTreeshakeSetup, checkTurborepo, checkTypedoc, checkVerifyScript, checkVscodeExtensions, evaluateNodeVersion, FILE_CHECKS, findDocsAppDir, jsBadgeAudience, jsGitHooksProfile, readPackageJson, } from '../../languages/js/checks.js';
 export { evaluateNodeVersion };
 const PACKAGE = '@rtorcato/repo-tooling';
@@ -221,24 +219,11 @@ async function runBaseChecks(dir, lock, opts) {
     results.push(...(await checkGitHubSettings(dir)));
     // Milestone hygiene (#397) — same seam, same self-skip.
     results.push(await checkMilestones(dir));
-    // ai-issue-loop label colours/descriptions (#446) — same seam, same self-skip.
-    results.push(await checkLoopLabels(dir));
-    // aiLoop.agentUser assignability (#530) — same seam, same self-skip.
-    results.push(await checkAgentUser(dir, lock?.rules?.aiLoop?.agentUser));
     results.push(await checkGitLabCI(dir));
     results.push(await checkCodeowners(dir));
     results.push(await checkCommunityHealth(dir));
     results.push(await checkBrand(dir));
     results.push(await checkAiSetup(dir));
-    // User-global, not repo state — see checkClaudeSkills on why it never returns drift.
-    results.push(await checkClaudeSkills(opts.skillsDir));
-    // #533: gated on `aiLoop.agentUser`, which is the "this repo uses the pipeline"
-    // signal, so a repo that doesn't gets no line at all rather than an empty one.
-    // The key itself no longer says that — since #571 every repo is scaffolded with
-    // an empty `aiLoop`, and the skills have always read the login, not the key.
-    if (lock?.rules?.aiLoop?.agentUser && lock.rules.requiredSkills?.length) {
-        results.push(await checkRequiredSkills(lock.rules.requiredSkills, opts.skillsDir));
-    }
     // #534: advisory. Absent `mcp.recommended` means the repo has nothing to say
     // about MCP, which is not a finding.
     if (lock?.rules?.mcp?.recommended?.length) {
@@ -248,7 +233,7 @@ async function runBaseChecks(dir, lock, opts) {
     results.push(await checkCoverageUpload(dir));
     return results;
 }
-export async function runDoctor(dir, skillsDir) {
+export async function runDoctor(dir) {
     const targetDir = path.resolve(dir);
     const lock = await readLockfile(targetDir);
     // Per-module dispatch (#285): the base checks (repo hygiene, CI, security,
@@ -277,7 +262,6 @@ export async function runDoctor(dir, skillsDir) {
                 presetWorkflow: null,
                 language,
                 codeqlLanguages: languageModule?.codeqlLanguages ?? [],
-                skillsDir,
             })),
         ];
         return applyExceptions(demoteDeclined(results, lock), lock);
@@ -300,7 +284,6 @@ export async function runDoctor(dir, skillsDir) {
                 presetWorkflow: renderSwiftWorkflow(await readSwiftPackage(targetDir)),
                 language,
                 codeqlLanguages: languageModule.codeqlLanguages,
-                skillsDir,
             })),
             ...(await runSwiftChecks(targetDir)),
         ];
@@ -324,7 +307,6 @@ export async function runDoctor(dir, skillsDir) {
                 presetWorkflow: renderPythonWorkflow(await readPyproject(targetDir)),
                 language,
                 codeqlLanguages: languageModule.codeqlLanguages,
-                skillsDir,
             })),
             ...(await runPythonChecks(targetDir)),
         ];
@@ -350,7 +332,6 @@ export async function runDoctor(dir, skillsDir) {
                 presetWorkflow: renderPerlWorkflow(await readPerlProject(targetDir)),
                 language,
                 codeqlLanguages: languageModule.codeqlLanguages,
-                skillsDir,
             })),
             ...(await runPerlChecks(targetDir)),
         ];
@@ -418,7 +399,6 @@ export async function runDoctor(dir, skillsDir) {
         presetWorkflow: renderGitHubWorkflow(githubJobs(inferProjectConfig(pkg), { scripts: scriptsOf(pkg) })),
         language,
         codeqlLanguages: languageModule.codeqlLanguages,
-        skillsDir,
     })));
     return applyExceptions(demoteDeclined(results, lock), lock);
 }
@@ -503,7 +483,7 @@ function printRulesComparison(comparison) {
 }
 export async function doctorCommand(options = {}) {
     const dir = options.directory ?? process.cwd();
-    const results = await runDoctor(dir, options.skillsDir);
+    const results = await runDoctor(dir);
     const comparison = options.rulesFrom
         ? await compareRulesWithReference(dir, options.rulesFrom)
         : null;

package/dist/cli/commands/fix-targets.js

@@ -29,7 +29,6 @@ export const FIX_TARGETS = {
     'Workflow permissions': 'github-settings',
     'Code-scanning gate': 'github-settings',
     Milestones: 'milestones',
-    'AI loop labels': 'labels',
     CODEOWNERS: 'codeowners',
     'GitLab CI': 'gitlab-ci',
     Turborepo: 'turborepo',
@@ -47,13 +46,11 @@ export const FIX_TARGETS = {
     TypeDoc: 'typedoc',
     'AI setup': 'ai',
     'Claude worktree settings': 'ai',
-    'Claude skills': 'claude-skills',
     'Copied assets': 'copied-assets',
-    // `Required skills` (#533) and `Recommended MCP` (#534) are deliberately
-    // absent. Both are driven by committed repo config and both would act outside
-    // the repo — installing into `~/.claude`, enabling a code-executing MCP
-    // server. Staying out of this map keeps them out of `fix`'s footer suggestions
-    // and out of every lookup a fixer path makes; their own hints name the command
+    // `Recommended MCP` (#534) is deliberately absent. It is driven by committed
+    // repo config and would act outside the repo — enabling a code-executing MCP
+    // server. Staying out of this map keeps it out of `fix`'s footer suggestions
+    // and out of every lookup a fixer path makes; its own hint names the command
     // a human runs by hand.
 };
 /**

package/dist/cli/commands/fix.js

@@ -377,9 +377,7 @@ export async function fixCommand(target, options = {}) {
     const pkg = await readPackageJson(targetDir);
     const lock = await readLockfile(targetDir);
     const fixers = fixersForLanguage(await detectAuditLanguage(targetDir));
-    // Same --skills-dir the claude-skills fixer writes to, so the diagnosis fix
-    // acts on and the install it performs agree on one directory (#485).
-    const results = await runDoctor(targetDir, options.skillsDir);
+    const results = await runDoctor(targetDir);
     const actions = [];
     const noteLockConflict = (check) => {
         if (!lock)
@@ -458,9 +456,6 @@ export async function fixCommand(target, options = {}) {
         // is the whole outcome of the command. The bulk loop below takes the other
         // branch and records a skip, since one refusal must not abandon the rest.
         const outcome = await applyFixer(fixer, effectiveResult, targetDir, pkg, lock, dryRun, silent, {
-            skillsDir: options.skillsDir,
-            forceSkills: options.forceSkills,
-            ghConfigDir: options.ghConfigDir,
             assumeYes,
         }).catch((err) => {
             if (!(err instanceof FixerAbort))
@@ -541,9 +536,6 @@ export async function fixCommand(target, options = {}) {
         let outcome;
         try {
             outcome = await applyFixer(fixer, result, targetDir, pkg, lock, dryRun, silent, {
-                skillsDir: options.skillsDir,
-                forceSkills: options.forceSkills,
-                ghConfigDir: options.ghConfigDir,
                 assumeYes,
             });
         }

package/dist/cli/commands/setup-presets.js

@@ -209,6 +209,7 @@ export const CONFIG_SCHEMA = {
         turborepo: { type: 'boolean' },
         nx: { type: 'boolean' },
         tailwind: { type: 'boolean' },
+        docsSite: { type: 'boolean' },
         bun: { type: 'boolean' },
     },
 };