flagrm 0.1.1 → 0.2.1

package/dist/core/doctor.js

@@ -5,13 +5,17 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { errorExcerpt, incrementalBuildGap, projectCommands, runCheck, templateCheckGap } from "./baseline.js";
-import { findConfigFile, loadConfig } from "./config.js";
+import { realProbes } from "../adapters/dotnet/setup.js";
+import { errorExcerpt, incrementalBuildGap, runCheck, templateCheckGap } from "./baseline.js";
+import { findConfigFile, loadConfig, TOOL_IDS } from "./config.js";
+import { projectCommands } from "./config-snapshot.js";
 import { gitState, isAncestor } from "./git.js";
-import { AGENT_SKILL_DIRS, installedSkillVersion, SKILLS, stopHookState } from "./install.js";
+import { installedSkillVersion, SKILLS, stopHookState, TOOL_SKILL_DIRS } from "./install.js";
 import { packageVersion } from "./package.js";
 import { resolveProjects } from "./registry.js";
-import { readJson, relativePath } from "./util.js";
+import { setupReport } from "./scope.js";
+import { savedTools } from "./tools.js";
+import { onPath, readJson, relativePath } from "./util.js";
 /** Check the setup in `cwd`: config and commands, git, .gitignore, skills, hook and abandoned baselines. */
 export async function runDoctor(cwd, options = {}) {
     const checks = [];
@@ -30,8 +34,16 @@ export async function runDoctor(cwd, options = {}) {
     const gitignore = path.join(root, ".gitignore");
     const ignored = fs.existsSync(gitignore) && /^\/?\.flagrm\/?\s*$/m.test(fs.readFileSync(gitignore, "utf8"));
     add(ignored ? "ok" : "warn", ignored ? ".flagrm/ is gitignored" : "add .flagrm/ to .gitignore (flagrm init does this)");
+    // Only the tools the config lists, when it lists them.
+    let tools = TOOL_IDS;
+    try {
+        tools = savedTools(root) ?? TOOL_IDS;
+    }
+    catch (err) {
+        add("fail", `config: ${err instanceof Error ? err.message : String(err)}`);
+    }
     const version = packageVersion();
-    for (const dir of AGENT_SKILL_DIRS) {
+    for (const dir of tools.map((t) => TOOL_SKILL_DIRS[t])) {
         const versions = SKILLS.map((s) => installedSkillVersion(path.join(root, dir, s)));
         if (versions.every((v) => v === undefined))
             add("warn", `${dir}: skills not installed (run flagrm init)`);
@@ -42,12 +54,12 @@ export async function runDoctor(cwd, options = {}) {
         else
             add("ok", `${dir}: skills ${version}`);
     }
-    const hook = stopHookState(root);
+    const hook = tools.includes("claude-code") ? stopHookState(root) : undefined;
     if (hook === "current")
         add("ok", "Claude Code Stop hook installed");
     else if (hook === "outdated")
         add("warn", "Claude Code Stop hook runs an outdated command (run flagrm update)");
-    else
+    else if (hook === "missing")
         add("warn", "Claude Code Stop hook missing from .claude/settings.json (run flagrm init)");
     if (git.sha !== null)
         abandonedBaselines(root, add);
@@ -70,6 +82,7 @@ async function configChecks(cwd, configFile, options, add) {
         add("fail", `config: ${err instanceof Error ? err.message : String(err)}`);
         return;
     }
+    setupChecks(projects, root, options.probes ?? realProbes((exe) => onPath(exe, root)), add);
     for (const { adapter, ctx } of projects) {
         const commands = projectCommands(adapter, ctx);
         for (const check of ["build", "test"]) {
@@ -98,7 +111,23 @@ async function configChecks(cwd, configFile, options, add) {
                 add("ok", `${ctx.name}: \`${command}\` passed`);
                 continue;
             }
-            add("fail", `${ctx.name}: \`${command}\` failed (exit ${run.exitCode}, log ${relativePath(cwd, run.log ?? "")})`, errorExcerpt(run.log, 3));
+            add("fail", `${ctx.name}: \`${command}\` failed (exit ${run.exitCode}, log ${relativePath(cwd, run.log ?? "")})`, run.failure ? [`setup problem: ${run.failure.message}`] : errorExcerpt(run.log, 3));
+        }
+    }
+}
+/**
+ * Whether the machine can build and test each .NET project: no SDK matching
+ * global.json fails (nothing builds), a missing `cargo` or Docker warns (a
+ * solution filter can leave out the projects that need them).
+ */
+function setupChecks(projects, root, probes, add) {
+    for (const s of setupReport(projects, root, probes)) {
+        if (s.sdk)
+            add("fail", `${s.project}: ${s.sdk}`);
+        const problems = s.setup?.problems ?? [];
+        if (problems.length) {
+            const out = s.setup?.leaveOut.length ?? 0;
+            add("warn", `${s.project}: ${problems.join("; ")} — \`flagrm scope\` shows the ${out} projects a solution filter would leave out`);
         }
     }
 }
@@ -116,15 +145,6 @@ export function simpleCommandProgram(command) {
         .split(/\s+/)
         .find((word) => !/^\w+=/.test(word));
 }
-function onPath(exe, cwd) {
-    if (exe.includes("/") || exe.includes("\\"))
-        return fs.existsSync(path.resolve(cwd, exe));
-    const exts = process.platform === "win32" ? ["", ...(process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";")] : [""];
-    return (process.env.PATH ?? "")
-        .split(path.delimiter)
-        .filter(Boolean)
-        .some((dir) => exts.some((ext) => fs.existsSync(path.join(dir, exe + ext))));
-}
 /** `.flagrm/<flag>/` entries whose baseline commit is not in this branch's history. */
 function abandonedBaselines(root, add) {
     const dir = path.join(root, ".flagrm");

package/dist/core/environment.js

@@ -0,0 +1,79 @@
+/**
+ * Tell a machine setup problem apart from broken code in a failed build or
+ * test log: a missing .NET SDK, a tool a build step calls that isn't
+ * installed, Docker not running for Testcontainers. Each becomes one line
+ * that says what to fix.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { relativePath } from "./util.js";
+/**
+ * The setup problems a log shows, as one actionable line, or undefined when
+ * it shows none. `root` is the project root: paths are reported relative to it.
+ */
+export function environmentProblem(log, root) {
+    const problems = [missingSdk(log, root), ...missingCommands(log, root), dockerUnavailable(log)].filter(Boolean);
+    return problems.length ? problems.join("; ") : undefined;
+}
+/**
+ * `dotnet` exits 155 with "A compatible .NET SDK was not found" when no
+ * installed SDK satisfies global.json. It prints the requested version and the
+ * global.json path; the installed SDKs (`10.0.101 [/usr/local/share/dotnet/sdk]`)
+ * go to stdout, so in a combined log they may come after the message.
+ */
+function missingSdk(log, root) {
+    if (!/A compatible \.NET SDK was not found/.test(log))
+        return undefined;
+    const requested = /^Requested SDK version:\s*(\S+)/m.exec(log)?.[1];
+    const globalJson = /^global\.json file:\s*(.+?)\s*$/m.exec(log)?.[1];
+    const installed = [...new Set([...log.matchAll(/^(\d+\.\d+\.\d+\S*) \[[^\]]*sdk\]\s*$/gm)].map((m) => m[1]))];
+    const rollForward = globalJson ? readRollForward(globalJson) : undefined;
+    const wanted = [requested ?? "the version", rollForward && `rollForward: ${rollForward}`].filter(Boolean).join(", ");
+    const where = globalJson ? relativePath(root, globalJson) : "global.json";
+    return (`.NET SDK not found: ${where} requests ${wanted}; installed: ${installed.join(", ") || "none"}. ` +
+        `Install that SDK or change ${where}`);
+}
+function readRollForward(file) {
+    try {
+        const value = JSON.parse(fs.readFileSync(file, "utf8"))?.sdk?.rollForward;
+        return typeof value === "string" ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Commands the shell couldn't find (exit 127; `9009` and "is not recognized"
+ * on Windows), with the MSBuild project whose `Exec` ran them when the log
+ * names it (`RustSdk.csproj(12,5): error MSB3073: The command "cargo build" exited with code 127`).
+ */
+function missingCommands(log, root) {
+    const commands = new Map();
+    const add = (command, project) => {
+        const name = path.basename(command);
+        const projects = commands.get(name) ?? new Set();
+        if (project)
+            projects.add(relativePath(root, path.resolve(root, project.trim())));
+        commands.set(name, projects);
+    };
+    for (const m of log.matchAll(/\b(?:ba|z|da)?sh: (?:line \d+: |\d+: )?([^\s:]+): (?:command )?not found/g))
+        add(m[1]);
+    for (const m of log.matchAll(/\bcommand not found: (\S+)/g))
+        add(m[1]);
+    for (const m of log.matchAll(/'([^']+)' is not recognized as an internal or external command/g))
+        add(m[1]);
+    for (const m of log.matchAll(/^\s*(.+?\.\w*proj)\(\d+,\d+\): error MSB3073: The command "([^\s"]+)[^"]*" exited with code (?:127|9009)\b/gm)) {
+        add(m[2].replace(/^["']|["']$/g, ""), m[1]);
+    }
+    return [...commands].map(([command, projects]) => {
+        const neededBy = projects.size ? ` (needed by ${[...projects].sort().join(", ")})` : "";
+        return `\`${command}\` is not installed or not on PATH${neededBy}`;
+    });
+}
+/** Testcontainers throws `DockerUnavailableException`; the docker CLI says it can't reach the daemon. */
+function dockerUnavailable(log) {
+    const docker = /DockerUnavailableException|Docker is either not running or misconfigured|Cannot connect to the Docker daemon/i;
+    if (!docker.test(log))
+        return undefined;
+    return "Docker is not running (Testcontainers tests need it): start Docker or leave those tests out of `test`";
+}

package/dist/core/flag-words.js

@@ -0,0 +1,36 @@
+/**
+ * The words a flag's names are made of, to recognize a name that is about the
+ * flag (`useVfo1Terminology`, `Save_Vfo1Enabled`) among ones that aren't.
+ */
+/** Words that say nothing about which flag a name is about. */
+const GENERIC = new Set("feature features flag flags toggle key keys enabled disabled enable disable is has use get async on off the when with if and".split(" "));
+/** Lowercase words of a name: `Vfo1FoundationEnabled_Saves` → vfo1, foundation, enabled, saves. */
+export function words(name) {
+    return (name.match(/[A-Z]+(?=[A-Z][a-z])|[A-Z]?[a-z]+[0-9]*|[A-Z]+[0-9]*|[0-9]+/g) ?? []).map((w) => w.toLowerCase());
+}
+/** Words of the flag's recorded names */
+export function flagWords(names) {
+    return new Set(names.flatMap((n) => words(n.name)).filter((w) => !GENERIC.has(w)));
+}
+/** Whether `name` contains one of the flag's words. */
+export function mentionsFlag(name, flag) {
+    return words(name).some((w) => flag.has(w));
+}
+/**
+ * Whether `name` names this flag clearly enough to look for it in every file:
+ * it contains all words of the flag's name in order (`IsNewCheckoutEnabledAsync`
+ * for `NewCheckout`), or a flag word with a digit (`vfo1`), which ordinary
+ * names don't have. One plain word (`express`, `checkout`) is not enough.
+ * `flagNames` are the literal and the definitions' last segments.
+ */
+export function namesFlag(name, flagNames, flag) {
+    const own = words(name);
+    if (own.some((w) => flag.has(w) && /\d/.test(w) && /[a-z]/.test(w) && w.length >= 3))
+        return true;
+    return flagNames.some((flagName) => {
+        const seq = words(flagName).filter((w) => !GENERIC.has(w));
+        if (seq.length < 2)
+            return false;
+        return own.some((_, i) => seq.every((w, j) => own[i + j] === w));
+    });
+}

package/dist/core/git.js

@@ -33,6 +33,14 @@ export function changedFilesSince(cwd, sha) {
         return undefined;
     return [...new Set([...paths(diff.stdout), ...untracked(cwd)])].sort();
 }
+/**
+ * Tracked files modified or deleted in the working tree since `sha` (staged
+ * or not); untracked files don't count. Undefined when git can't tell.
+ */
+export function trackedChangesSince(cwd, sha) {
+    const diff = git(cwd, "diff", "-z", "--name-only", "--no-renames", "--relative", sha, ...PATHSPEC);
+    return diff.ok ? paths(diff.stdout).sort() : undefined;
+}
 /** A file's content at `sha`, or undefined when it did not exist there. */
 export function fileAt(cwd, sha, relativePath) {
     const result = git(cwd, "show", `${sha}:./${relativePath.split(path.sep).join("/")}`);

package/dist/core/hook.js

@@ -6,8 +6,8 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { findConfigRoot } from "./config.js";
-import { headSha, treeAt, treeFingerprint } from "./git.js";
+import { CONFIG_FILENAMES, findConfigRoot } from "./config.js";
+import { headSha, trackedChangesSince, treeFingerprint } from "./git.js";
 import { readJson } from "./util.js";
 /** The hook's stdin: only a JSON object counts, and only fields of the expected type are kept. */
 export function parseHookInput(text) {
@@ -33,10 +33,12 @@ export function hookRoot(cwd) {
     return findConfigRoot(cwd) ?? cwd;
 }
 /**
- * Whether to block the stop: a removal is in progress (HEAD is still its
- * baseline commit and the tree has changed) and no passing verify matches the
- * current tree. Once HEAD moves (a commit, a branch switch, a merge), that
- * removal is no longer guarded.
+ * Whether to block the stop: a removal is in progress and no passing verify
+ * matches the current tree. In progress means HEAD is still the baseline
+ * commit and a file git tracks changed, other than the flagrm config (a
+ * removal paused on a question to the user, or a stray test result file,
+ * doesn't count), or the last verify skipped checks. Once HEAD moves (a
+ * commit, a branch switch, a merge), that removal is no longer guarded.
  */
 export function stopDecision(root, input) {
     if (input.stop_hook_active)
@@ -55,16 +57,24 @@ export function stopDecision(root, input) {
             .filter((flagDir) => readJson(path.join(flagDir, "baseline.json"))?.git?.sha === head);
         if (active.length === 0)
             return { block: false };
+        const edited = (trackedChangesSince(root, head) ?? []).some((rel) => !CONFIG_FILENAMES.includes(rel));
+        const started = active.filter((flagDir) => edited || lastVerifySkipped(flagDir));
+        if (started.length === 0)
+            return { block: false };
         const current = treeFingerprint(root);
-        if (!current || current === treeAt(root, head))
+        if (!current)
             return { block: false };
-        const reasons = active.map((flagDir) => unverified(flagDir, current)).filter((r) => r !== undefined);
+        const reasons = started.map((flagDir) => unverified(flagDir, current)).filter((r) => r !== undefined);
         return reasons.length ? { block: true, reason: reasons.join("\n") } : { block: false };
     }
     catch {
         return { block: false };
     }
 }
+function lastVerifySkipped(flagDir) {
+    const skipped = readJson(path.join(flagDir, "verify.json"))?.skipped;
+    return Array.isArray(skipped) && skipped.length > 0;
+}
 /** Why the in-progress removal in `flagDir` is not verified, or undefined when a full verify passed on `current`. */
 function unverified(flagDir, current) {
     const baseline = readJson(path.join(flagDir, "baseline.json"));

package/dist/core/install.js

@@ -1,18 +1,50 @@
 /**
  * What `flagrm init` and `flagrm update` write into a repository: the config
- * template, the agent skills, the AGENTS.md pointer for Codex, the Claude
- * Code Stop hook and the `.flagrm/` gitignore entry. Every step reports what
- * it did; nothing the user wrote is overwritten.
+ * template and the `.flagrm/` gitignore entry, then per AI coding tool its
+ * files: for Claude Code the skills and the Stop hook, for GitHub Copilot the
+ * skills and `/flagrm-*` prompt files, for Codex the skills and the AGENTS.md
+ * pointer. Every step reports what it did; nothing the user wrote is
+ * overwritten, and nothing is deleted.
  */
 import fs from "node:fs";
 import path from "node:path";
-import { DEFAULT_BACKEND_ATTRIBUTES, DEFAULT_BACKEND_METHODS, DEFAULT_FRONTEND_METHODS, findConfigRoot, findDefaultConfigFile, repositoryRoot, } from "./config.js";
+import { DEFAULT_BACKEND_ATTRIBUTES, DEFAULT_BACKEND_METHODS, DEFAULT_FRONTEND_METHODS, findConfigRoot, findDefaultConfigFile, repositoryRoot, TOOL_IDS, } from "./config.js";
 import { detectProjects } from "./detect.js";
 import { packageRoot, packageVersion } from "./package.js";
+import { saveTools } from "./tools.js";
 import { relativePath } from "./util.js";
 export const SKILLS = ["flagrm-remove", "flagrm-verify"];
-/** Where each supported agent discovers repository skills: Claude Code, GitHub Copilot, Codex. */
-export const AGENT_SKILL_DIRS = [".claude/skills", ".github/skills", ".agents/skills"];
+/** Where each supported tool discovers repository skills. */
+export const TOOL_SKILL_DIRS = {
+    "claude-code": ".claude/skills",
+    copilot: ".github/skills",
+    codex: ".agents/skills",
+};
+/** Every tool's skills directory: Claude Code, GitHub Copilot, Codex. */
+export const AGENT_SKILL_DIRS = TOOL_IDS.map((t) => TOOL_SKILL_DIRS[t]);
+/** GitHub Copilot prompt files: `/flagrm-remove` and `/flagrm-verify` in Copilot Chat, each pointing at its skill. */
+export const PROMPT_FILES = {
+    "flagrm-remove": [
+        "---",
+        "description: Remove a feature flag with flagrm's guardrails (keep the ON path, verify until it passes)",
+        "argument-hint: <flag>",
+        "agent: agent",
+        "---",
+        "",
+        "Follow `.github/skills/flagrm-remove/SKILL.md` to remove the feature flag named after this command.",
+        "",
+    ].join("\n"),
+    "flagrm-verify": [
+        "---",
+        "description: Check a feature flag removal with flagrm and propose its commit message",
+        "argument-hint: <flag>",
+        "agent: agent",
+        "---",
+        "",
+        "Follow `.github/skills/flagrm-verify/SKILL.md` for the feature flag named after this command.",
+        "",
+    ].join("\n"),
+};
 /**
  * The Stop hook command. npx runs the project's own flagrm (a dev dependency)
  * and falls back to a global install. `--no-install` matters: the `flagrm` name
@@ -72,27 +104,31 @@ function projectLines(p) {
     }
     return lines;
 }
-export function configTemplate(projects) {
+export function configTemplate(projects, tools) {
     const listed = projects.length ? projects : EXAMPLE_PROJECTS;
-    return [...CONFIG_HEADER, ...listed.flatMap(projectLines), ...CONFIG_FOOTER].join("\n");
+    const [comment1, comment2, projectsKey] = CONFIG_HEADER;
+    const toolLines = tools
+        ? ["# The AI coding tools `flagrm init` and `flagrm update` set up.", `tools: [${tools.join(", ")}]`]
+        : [];
+    return [comment1, comment2, ...toolLines, projectsKey, ...listed.flatMap(projectLines), ...CONFIG_FOOTER].join("\n");
 }
 /** Write `flagrm.config.yaml` for the projects found in `cwd` (an example when none are) unless a config file exists. */
-export function writeConfigTemplate(cwd) {
+export function writeConfigTemplate(cwd, tools) {
     const existing = findDefaultConfigFile(cwd);
     if (existing)
         return { path: relativePath(cwd, existing), status: "skipped" };
     const file = path.join(cwd, "flagrm.config.yaml");
     const projects = detectProjects(cwd);
-    fs.writeFileSync(file, configTemplate(projects), "utf8");
+    fs.writeFileSync(file, configTemplate(projects, tools), "utf8");
     const note = projects.length
         ? `detected ${projects.map((p) => `${p.adapter} (${p.marker})`).join(", ")}`
         : "no Angular or .NET project found: edit the example projects";
     return { path: relativePath(cwd, file), status: "created", note };
 }
-/** Copy each skill into each agent's skills directory and stamp it with the flagrm version. */
-export function installSkills(cwd, mode, version = packageVersion(), source = path.join(packageRoot(), "skills")) {
+/** Copy each skill into each tool's skills directory and stamp it with the flagrm version. */
+export function installSkills(cwd, mode, version = packageVersion(), source = path.join(packageRoot(), "skills"), tools = TOOL_IDS) {
     const results = [];
-    for (const dir of AGENT_SKILL_DIRS) {
+    for (const dir of tools.map((t) => TOOL_SKILL_DIRS[t])) {
         for (const skill of SKILLS) {
             const target = path.join(cwd, dir, skill);
             const exists = fs.existsSync(target);
@@ -142,6 +178,30 @@ export function installedSkillVersion(skillDir) {
         return undefined;
     }
 }
+/** GitHub Copilot's `/flagrm-remove` and `/flagrm-verify` prompt files in `.github/prompts/`. */
+export function installPrompts(cwd, mode) {
+    const results = [];
+    for (const skill of SKILLS) {
+        const file = path.join(cwd, ".github", "prompts", `${skill}.prompt.md`);
+        const step = relativePath(cwd, file);
+        const exists = fs.existsSync(file);
+        if (mode === "init" && exists) {
+            results.push({ path: step, status: "skipped" });
+            continue;
+        }
+        if (mode === "update" && !exists)
+            continue;
+        const before = exists ? fs.readFileSync(file, "utf8") : undefined;
+        if (before === PROMPT_FILES[skill]) {
+            results.push({ path: step, status: "unchanged" });
+            continue;
+        }
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, PROMPT_FILES[skill], "utf8");
+        results.push({ path: step, status: exists ? "updated" : "created" });
+    }
+    return results;
+}
 /** The marked flagrm block in AGENTS.md, which Codex reads. */
 export function installAgentsBlock(cwd, mode) {
     const file = path.join(cwd, "AGENTS.md");
@@ -241,17 +301,63 @@ export function ensureGitignore(cwd) {
 export function installRoot(cwd) {
     return findConfigRoot(cwd) ?? repositoryRoot(cwd) ?? cwd;
 }
-/** `flagrm init`: everything the agent needs in `root` (see {@link installRoot}), added where missing. */
-export function initProject(root) {
+/** The files `init` installs for one tool. */
+function toolSteps(root, tool, mode) {
+    const skills = installSkills(root, mode, undefined, undefined, [tool]);
+    if (tool === "claude-code")
+        return [...skills, installStopHook(root, mode)];
+    if (tool === "copilot")
+        return [...skills, ...installPrompts(root, mode)];
+    return [...skills, installAgentsBlock(root, mode)];
+}
+/**
+ * flagrm's files for tools `tools` leaves out, when they are installed: never
+ * deleted, no longer updated, and named so the user can delete them.
+ */
+function deselectedSteps(root, tools) {
+    const files = {
+        "claude-code": [
+            ...SKILLS.map((s) => `${TOOL_SKILL_DIRS["claude-code"]}/${s}`),
+            stopHookState(root) === "missing" ? "" : ".claude/settings.json",
+        ],
+        copilot: [
+            ...SKILLS.map((s) => `${TOOL_SKILL_DIRS.copilot}/${s}`),
+            ...SKILLS.map((s) => `.github/prompts/${s}.prompt.md`),
+        ],
+        codex: [...SKILLS.map((s) => `${TOOL_SKILL_DIRS.codex}/${s}`), hasAgentsBlock(root) ? "AGENTS.md" : ""],
+    };
+    return TOOL_IDS.filter((t) => !tools.includes(t)).flatMap((tool) => files[tool]
+        .filter((rel) => rel && fs.existsSync(path.join(root, rel)))
+        .map((rel) => ({
+        path: rel,
+        status: "skipped",
+        note: `${tool} isn't in tools: no longer updated${rel.endsWith(".json") || rel === "AGENTS.md" ? " (flagrm's entry)" : ""}; delete it if you don't use it`,
+    })));
+}
+function hasAgentsBlock(root) {
+    try {
+        return fs.readFileSync(path.join(root, "AGENTS.md"), "utf8").includes(AGENTS_START);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * `flagrm init`: everything the agent needs in `root` (see {@link installRoot})
+ * for `tools`, added where missing, and the choice saved as the config's `tools:`.
+ */
+export function initProject(root, tools = TOOL_IDS) {
+    const config = writeConfigTemplate(root, tools);
+    const saved = config.status === "skipped" ? saveTools(root, [...tools]) : undefined;
     return [
-        writeConfigTemplate(root),
-        ...installSkills(root, "init"),
-        installAgentsBlock(root, "init"),
-        installStopHook(root, "init"),
+        config,
+        ...(saved && saved.status !== "unchanged" ? [saved] : []),
+        ...tools.flatMap((t) => toolSteps(root, t, "init")),
         ensureGitignore(root),
+        ...deselectedSteps(root, tools),
     ];
 }
-/** `flagrm update`: refresh what `init` installed in `root` from this flagrm version; adds nothing new. */
-export function updateProject(root) {
-    return [...installSkills(root, "update"), installAgentsBlock(root, "update"), installStopHook(root, "update")];
+/** `flagrm update`: refresh what `init` installed in `root` for `tools` from this flagrm version; adds nothing new. */
+export function updateProject(root, tools = TOOL_IDS) {
+    return [...tools.flatMap((t) => toolSteps(root, t, "update")), ...deselectedSteps(root, tools)];
 }

package/dist/core/inventory.js

@@ -4,6 +4,7 @@
  * type, direct reference counts and the projects involved.
  */
 import path from "node:path";
+import { flagWords, mentionsFlag, namesFlag } from "./flag-words.js";
 import { findMentions } from "./mentions.js";
 import { isTestPath } from "./scan.js";
 import { JSON_SCHEMA_VERSION, } from "./types.js";
@@ -33,6 +34,8 @@ export async function buildInventory(projects) {
                 definitions: [],
                 config: [],
                 references: { total: 0, files: 0, tests: 0, byProject: {} },
+                flow: [],
+                parameterizedTests: [],
             };
             entries.set(c.flag, entry);
             involved.set(entry, new Set());
@@ -52,6 +55,7 @@ export async function buildInventory(projects) {
         }
     }
     countReferences(projects, [...entries.values()]);
+    followFlow(projects, [...entries.values()]);
     const order = projects.map(({ ctx }) => ctx.name);
     const byLocation = (a, b) => order.indexOf(a.project) - order.indexOf(b.project) || a.file.localeCompare(b.file) || a.line - b.line;
     for (const entry of entries.values()) {
@@ -116,3 +120,38 @@ function countReferences(projects, entries) {
     for (const [entry, seen] of files)
         entry.references.files = seen.size;
 }
+/**
+ * Where each flag's value goes, from the adapters that can follow it. A name
+ * is marked `record` when it says it is about the flag; a generic one
+ * (`enabled`, `Plural`) recorded as a wrapper would match unrelated code.
+ */
+function followFlow(projects, entries) {
+    const byFlag = new Map(entries.map((e) => [e.flag, e]));
+    const refs = entries.map((e) => ({ flag: e.flag, aliases: e.definitions.map((d) => d.name) }));
+    for (const { adapter, ctx } of projects) {
+        if (!adapter.flow)
+            continue;
+        const { names, tests } = adapter.flow(ctx, refs);
+        for (const name of names) {
+            const entry = byFlag.get(name.flag);
+            if (!entry)
+                continue;
+            const words = flagWords([{ name: entry.flag }, ...entry.definitions]);
+            const flagNames = [entry.flag, ...entry.definitions.map((d) => d.name.split(".").pop() ?? d.name)];
+            entry.flow.push({ ...name, record: !name.ambiguous && recordable(name, flagNames, words) });
+        }
+        for (const test of tests)
+            byFlag.get(test.flag)?.parameterizedTests.push(test);
+    }
+}
+/**
+ * A local, parameter or field is only looked for in its own file, so one of
+ * the flag's words in its name is enough (`useVfo1Terminology`). A method or
+ * property is looked for everywhere, so its name has to name the flag
+ * (`IsNewCheckoutEnabledAsync`); `express` or `GetCheckout` would match
+ * unrelated code.
+ */
+function recordable(name, flagNames, words) {
+    const scoped = name.kind === "local" || name.kind === "parameter" || name.kind === "field";
+    return scoped ? mentionsFlag(name.name, words) : namesFlag(name.name, flagNames, words);
+}

package/dist/core/markdown.js

@@ -4,7 +4,7 @@
  * notes and the commit message around it.
  */
 import { relativePath } from "./util.js";
-import { shortTestNames } from "./verify/test-results.js";
+import { shortTestName, shortTestNames } from "./verify/test-results.js";
 const ICON = { pass: "✅", fail: "❌", warn: "⚠️", skipped: "➖" };
 /** How many entries a list shows before summarizing the rest. */
 const MAX_ITEMS = 20;
@@ -33,11 +33,22 @@ export function verifyMarkdown(report, root) {
     const changed = report.changedFiles ?? [];
     if (changed.length)
         out.push("", `**Files changed since baseline (${changed.length}):** ${codeList(changed)}`);
-    const removed = report.tests.flatMap((t) => t.removed);
-    if (removed.length) {
-        out.push("", `**Tests that no longer run (${removed.length}):** ${codeList(shortTestNames(removed))}`);
+    const all = (key) => report.tests.flatMap((t) => t[key]);
+    const renamed = report.tests.flatMap((t) => t.renamed);
+    for (const [names, title] of [
+        [all("deleted"), "Tests deleted"],
+        [all("excludedByConfig"), "Tests excluded by a config change"],
+        [all("unexplained"), "Tests that no longer run, unexplained"],
+    ]) {
+        if (names.length)
+            out.push("", `**${title} (${names.length}):** ${codeList(shortTestNames(names))}`);
+    }
+    if (renamed.length) {
+        const pairs = renamed.map((r) => `\`${shortTestName(r.from)}\` → \`${shortTestName(r.to)}\``);
+        out.push("", `**Tests renamed (${renamed.length}):** ${pairs.slice(0, MAX_ITEMS).join(", ")}`);
     }
-    const added = report.tests.flatMap((t) => t.added);
+    const renamedTo = new Set(renamed.map((r) => r.to));
+    const added = report.tests.flatMap((t) => t.added).filter((name) => !renamedTo.has(name));
     if (added.length)
         out.push("", `**New tests (${added.length}):** ${codeList(shortTestNames(added))}`);
     for (const [severity, title] of [