flagrm 0.2.1 → 0.4.0

package/dist/adapters/angular/holders.js

@@ -0,0 +1,194 @@
+/**
+ * The names a flag's value is held in: fields, getters, parameterless
+ * methods and locals whose value is an evaluation of the flag (or its
+ * negation), and those whose value is such a name of the same class or
+ * function. A getter or method returning a ternary on an evaluation is
+ * recorded but not followed: it holds the ternary's value, not the flag's.
+ * Parsed, never type-checked.
+ */
+import ts from "typescript";
+export function skipParens(expr) {
+    let e = expr;
+    while (ts.isParenthesizedExpression(e))
+        e = e.expression;
+    return e;
+}
+/** `expr` without parentheses and leading `!`s. */
+export function skipNot(expr) {
+    let e = expr;
+    for (;;) {
+        if (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        else if (ts.isPrefixUnaryExpression(e) && e.operator === ts.SyntaxKind.ExclamationToken)
+            e = e.operand;
+        else
+            return e;
+    }
+}
+/**
+ * An evaluation: a call of a configured eval method, by the last name of its
+ * callee (`a.b.isFeatureFlagEnabled`), whose first argument names the flag;
+ * parentheses and `!` around it are allowed.
+ */
+export function evaluationMatcher(evalMethods, flagOfArgument) {
+    return (file, expr) => {
+        const e = skipNot(expr);
+        if (!ts.isCallExpression(e) || e.arguments.length === 0)
+            return undefined;
+        const callee = skipParens(e.expression);
+        const name = ts.isPropertyAccessExpression(callee)
+            ? callee.name.text
+            : ts.isIdentifier(callee)
+                ? callee.text
+                : undefined;
+        if (!name || !evalMethods.includes(name))
+            return undefined;
+        return flagOfArgument(file, e.arguments[0]);
+    };
+}
+/**
+ * Every place a holder can be declared: a property with an initializer, a
+ * `this.x = …` statement, a getter or parameterless method whose body is a
+ * single `return`, a `const`/`let` in a function.
+ */
+export function collectSites(files) {
+    const sites = [];
+    for (const file of files) {
+        const { sf } = file;
+        const lineOf = (node) => sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+        const visit = (node, cls, fn) => {
+            if (cls && ts.isPropertyDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+                sites.push({
+                    file,
+                    name: node.name.text,
+                    kind: "field",
+                    line: lineOf(node.name),
+                    expr: node.initializer,
+                    ternary: false,
+                    cls,
+                });
+            }
+            else if (cls &&
+                ts.isExpressionStatement(node) &&
+                ts.isBinaryExpression(node.expression) &&
+                node.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                ts.isPropertyAccessExpression(node.expression.left) &&
+                node.expression.left.expression.kind === ts.SyntaxKind.ThisKeyword &&
+                ts.isIdentifier(node.expression.left.name)) {
+                const { left, right } = node.expression;
+                sites.push({ file, name: left.name.text, kind: "field", line: lineOf(node), expr: right, ternary: false, cls });
+            }
+            else if (cls &&
+                (ts.isGetAccessorDeclaration(node) || (ts.isMethodDeclaration(node) && node.parameters.length === 0)) &&
+                ts.isIdentifier(node.name) &&
+                node.body?.statements.length === 1) {
+                const only = node.body.statements[0];
+                if (ts.isReturnStatement(only) && only.expression) {
+                    const kind = ts.isGetAccessorDeclaration(node) ? "property" : "method";
+                    const value = skipParens(only.expression);
+                    const base = { file, name: node.name.text, kind, line: lineOf(node.name), cls };
+                    if (ts.isConditionalExpression(value))
+                        sites.push({ ...base, expr: value.condition, ternary: true });
+                    else
+                        sites.push({ ...base, expr: only.expression, ternary: false });
+                }
+            }
+            else if (fn &&
+                ts.isVariableDeclaration(node) &&
+                ts.isIdentifier(node.name) &&
+                node.initializer &&
+                ts.isVariableDeclarationList(node.parent) &&
+                node.parent.flags & (ts.NodeFlags.Const | ts.NodeFlags.Let)) {
+                sites.push({
+                    file,
+                    name: node.name.text,
+                    kind: "local",
+                    line: lineOf(node.name),
+                    expr: node.initializer,
+                    ternary: false,
+                    cls,
+                    fn,
+                });
+            }
+            const nextCls = ts.isClassLike(node) ? node : cls;
+            const nextFn = ts.isFunctionLike(node) ? node : fn;
+            ts.forEachChild(node, (child) => visit(child, nextCls, nextFn));
+        };
+        visit(sf, undefined, undefined);
+    }
+    return sites;
+}
+/**
+ * The holders among `sites`, repeated until nothing new: a site whose value
+ * is an evaluation, or a read of a holder of its class (`this.x`, `!this.x`,
+ * `this.x()`) or, for a local, of a local of its function (`x`, `!x`, `x()`).
+ * `seeds` (a child component's inputs) are holders from the start.
+ */
+export function deriveHolders(sites, evaluates, seeds = []) {
+    const holders = [];
+    const members = new Map();
+    const locals = new Map();
+    const index = (scopes, scope, name, flag) => {
+        const names = scopes.get(scope) ?? new Map();
+        scopes.set(scope, names);
+        const flags = names.get(name) ?? new Set();
+        names.set(name, flags);
+        flags.add(flag);
+    };
+    const add = (h) => {
+        const same = (o) => o.flag === h.flag && o.name === h.name && o.kind === h.kind && o.cls === h.cls && o.fn === h.fn;
+        if (holders.some(same))
+            return false;
+        holders.push(h);
+        if (h.ternary || h.ambiguous)
+            return true;
+        if (h.kind === "local") {
+            if (h.fn)
+                index(locals, h.fn, h.name, h.flag);
+        }
+        else if (h.cls) {
+            index(members, h.cls, h.name, h.flag);
+        }
+        return true;
+    };
+    const flagsOf = (site) => {
+        const flag = evaluates(site.file, site.expr);
+        if (flag)
+            return [flag];
+        if (site.ternary)
+            return [];
+        let read = skipNot(site.expr);
+        if (ts.isCallExpression(read) && read.arguments.length === 0)
+            read = skipParens(read.expression);
+        if (ts.isPropertyAccessExpression(read) && read.expression.kind === ts.SyntaxKind.ThisKeyword) {
+            return [...((site.cls && members.get(site.cls)?.get(read.name.text)) ?? [])];
+        }
+        if (ts.isIdentifier(read))
+            return [...((site.fn && locals.get(site.fn)?.get(read.text)) ?? [])];
+        return [];
+    };
+    for (const seed of seeds)
+        add(seed);
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const site of sites) {
+            for (const flag of flagsOf(site)) {
+                const holder = {
+                    flag,
+                    name: site.name,
+                    kind: site.kind,
+                    file: site.file.file,
+                    line: site.line,
+                    cls: site.cls,
+                };
+                if (site.kind === "local")
+                    holder.fn = site.fn;
+                if (site.ternary)
+                    holder.ternary = true;
+                if (add(holder))
+                    changed = true;
+            }
+        }
+    }
+    return holders;
+}

package/dist/adapters/angular/index.js

@@ -1,7 +1,11 @@
 import fs from "node:fs";
+import path from "node:path";
 import { discoverInText } from "../../core/discover.js";
 import { FRONTEND_GLOBS } from "../../core/scan.js";
+import { detectTestRunner, runnerTestCommands } from "../../core/test-runner.js";
+import { componentScopeFiles } from "./component-files.js";
 import { discoverTypeScript } from "./discover.js";
+import { angularFlow } from "./flow.js";
 import { angularUnusedDiagnostics } from "./unused.js";
 /**
  * Discover candidate flag names: string literals passed to configured eval
@@ -25,10 +29,25 @@ export function discoverAngularFlags(ctx) {
     }
     return out;
 }
+/** The runner per project directory: projectCommands asks for the default commands many times per command. */
+const runners = new Map();
+function testRunner(root) {
+    let runner = runners.get(root);
+    if (!runner)
+        runners.set(root, (runner = detectTestRunner(root)));
+    return runner;
+}
 export const angularAdapter = {
     id: "angular",
     defaultGlobs: FRONTEND_GLOBS,
     discover: async (ctx) => discoverAngularFlags(ctx),
-    defaultCommands: () => ({ build: "npx ng build", test: "npx ng test --watch=false" }),
+    flow: (ctx, flags) => angularFlow(ctx, flags, ctx.project.methods),
+    scopeFiles: (_ctx, file) => componentScopeFiles(file),
+    // Like the .NET adapter: when the runner can write results without setup, the default test command does, under .flagrm/.
+    defaultCommands: (ctx) => {
+        const dir = path.join(ctx.config.root, ".flagrm", "test-results", ctx.name);
+        const tests = runnerTestCommands(testRunner(ctx.root), ctx.root, dir);
+        return { build: "npx ng build", ...(tests ?? { test: "npx ng test --watch=false" }) };
+    },
     unusedDiagnostics: (_ctx, input) => angularUnusedDiagnostics(input),
 };

package/dist/adapters/angular/inputs.js

@@ -0,0 +1,181 @@
+/**
+ * One hop of a flag's value into a child component: a parent's template
+ * binds a holder (`[express]="expressShipping()"`) on an element whose tag is
+ * another component's selector, and the child's input of that binding name
+ * holds the flag too. Templates are scanned lexically; components are parsed,
+ * never type-checked. The child's own bindings are not followed.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+const ELEMENT_SELECTOR = /^[a-z][\w-]*$/i;
+/** A start tag and its attributes; quoted values may contain `>`. */
+const START_TAG = /<([a-zA-Z][\w-]*)((?:\s+[^\s"'=<>/]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*)\s*\/?>/g;
+/** `[prop]="expr"` or `[prop]='expr'`; `[attr.x]`, `[class.x]`, `[style.x]` don't match. */
+const PROPERTY_BINDING = /\[([\w$]+)\]\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+/** `h`, `!h`, `h()` or `!h()`. */
+const HOLDER_READ = /^!?\s*([A-Za-z_$][\w$]*)(?:\s*\(\s*\))?$/;
+const SIGNAL_INPUT = /^(?:input|model)(?:\.required)?$/;
+/**
+ * The inputs of child components that parents' templates bind one of
+ * `holders` to. An input is `ambiguous` (suggested, never recorded) when its
+ * tag maps to several components, or when another binding passes it
+ * something else: a reusable component keeps that input after the removal.
+ */
+export function childInputs(files, holders) {
+    const all = components(files);
+    const bySelector = new Map();
+    for (const c of all)
+        for (const s of c.selectors)
+            bySelector.set(s, [...(bySelector.get(s) ?? []), c]);
+    const inputs = new Map();
+    for (const parent of all) {
+        const bound = new Map();
+        for (const h of holders) {
+            if (h.cls !== parent.cls || h.kind === "local" || h.ternary || h.ambiguous)
+                continue;
+            bound.set(h.name, (bound.get(h.name) ?? new Set()).add(h.flag));
+        }
+        const template = templateOf(parent)?.replace(/<!--[\s\S]*?-->/g, "");
+        if (!template)
+            continue;
+        for (const tag of template.matchAll(START_TAG)) {
+            const children = bySelector.get(tag[1].toLowerCase());
+            if (!children)
+                continue;
+            for (const binding of tag[2].matchAll(PROPERTY_BINDING)) {
+                const read = HOLDER_READ.exec((binding[2] ?? binding[3]).trim());
+                const flags = read ? bound.get(read[1]) : undefined;
+                for (const child of children) {
+                    const input = findInput(child, binding[1]);
+                    if (!input)
+                        continue;
+                    const key = `${child.file.file}\0${child.cls.pos}\0${input.name}`;
+                    const entry = inputs.get(key) ?? { child, input, shared: false, reads: [] };
+                    inputs.set(key, entry);
+                    entry.shared ||= children.length > 1;
+                    entry.reads.push(flags);
+                }
+            }
+        }
+    }
+    const out = [];
+    for (const { child, input, shared, reads } of inputs.values()) {
+        const flags = new Set(reads.flatMap((r) => [...(r ?? [])]));
+        for (const flag of flags) {
+            const ambiguous = shared || reads.some((r) => !r?.has(flag));
+            out.push({
+                flag,
+                name: input.name,
+                kind: "field",
+                file: child.file.file,
+                line: input.line,
+                cls: child.cls,
+                ...(ambiguous ? { ambiguous: true } : {}),
+            });
+        }
+    }
+    return out;
+}
+/** The `@Component` classes of `files`, with their selectors and template. */
+function components(files) {
+    const out = [];
+    for (const file of files) {
+        if (!file.text.includes("@Component"))
+            continue;
+        for (const statement of file.sf.statements) {
+            if (!ts.isClassDeclaration(statement))
+                continue;
+            for (const decorator of ts.getDecorators(statement) ?? []) {
+                const call = decorator.expression;
+                if (!ts.isCallExpression(call) || call.expression.getText(file.sf) !== "Component")
+                    continue;
+                const options = call.arguments[0];
+                if (!options || !ts.isObjectLiteralExpression(options))
+                    continue;
+                const info = { file, cls: statement, selectors: [] };
+                for (const prop of options.properties) {
+                    if (!ts.isPropertyAssignment(prop) || !ts.isStringLiteralLike(prop.initializer))
+                        continue;
+                    const key = prop.name.getText(file.sf);
+                    const value = prop.initializer.text;
+                    if (key === "selector") {
+                        info.selectors = value
+                            .split(",")
+                            .map((s) => s.trim())
+                            .filter((s) => ELEMENT_SELECTOR.test(s))
+                            .map((s) => s.toLowerCase());
+                    }
+                    else if (key === "template") {
+                        info.template = value;
+                    }
+                    else if (key === "templateUrl") {
+                        info.templateUrl = path.resolve(path.dirname(file.file), value);
+                    }
+                }
+                out.push(info);
+            }
+        }
+    }
+    return out;
+}
+function templateOf(c) {
+    if (c.template !== undefined)
+        return c.template;
+    if (!c.templateUrl)
+        return undefined;
+    try {
+        return fs.readFileSync(c.templateUrl, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The child's member whose binding name (its `alias`, else its own name) is `binding`. */
+function findInput(child, binding) {
+    const { sf } = child.file;
+    for (const member of child.cls.members) {
+        if (!(ts.isPropertyDeclaration(member) || ts.isSetAccessorDeclaration(member)) || !ts.isIdentifier(member.name)) {
+            continue;
+        }
+        const name = member.name.text;
+        const line = sf.getLineAndCharacterOfPosition(member.name.getStart(sf)).line + 1;
+        const decorator = (ts.getDecorators(member) ?? [])
+            .map((d) => d.expression)
+            .find((e) => ts.isCallExpression(e) && e.expression.getText(sf) === "Input");
+        if (decorator) {
+            if ((aliasOf(decorator.arguments, true) ?? name) === binding)
+                return { name, line };
+            continue;
+        }
+        const init = ts.isPropertyDeclaration(member) ? member.initializer : undefined;
+        if (init &&
+            ts.isCallExpression(init) &&
+            SIGNAL_INPUT.test(init.expression.getText(sf)) &&
+            (aliasOf(init.arguments, false) ?? name) === binding) {
+            return { name, line };
+        }
+    }
+    return undefined;
+}
+/**
+ * An input's alias: `{ alias: 'x' }` among the arguments, or (for `@Input`
+ * only, where a signal input's first argument is its initial value) `'x'`.
+ */
+function aliasOf(args, stringAlias) {
+    for (const arg of args) {
+        if (stringAlias && ts.isStringLiteralLike(arg))
+            return arg.text;
+        if (!ts.isObjectLiteralExpression(arg))
+            continue;
+        for (const p of arg.properties) {
+            if (ts.isPropertyAssignment(p) &&
+                ts.isIdentifier(p.name) &&
+                p.name.text === "alias" &&
+                ts.isStringLiteralLike(p.initializer)) {
+                return p.initializer.text;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/adapters/dotnet/index.js

@@ -1,6 +1,8 @@
 import fs from "node:fs";
+import path from "node:path";
 import { discoverInText } from "../../core/discover.js";
 import { BACKEND_GLOBS } from "../../core/scan.js";
+import { relativePath } from "../../core/util.js";
 import { dotnetFlow } from "./flow.js";
 import { dotnetUnusedDiagnostics } from "./unused.js";
 /** Discover candidate flag names (appsettings config keys, [FeatureGate] args, eval-call literals, *Flags constants/enums). */
@@ -26,6 +28,14 @@ export const dotnetAdapter = {
     flow: (ctx, flags) => dotnetFlow(ctx, flags, ctx.project.methods),
     // --no-incremental: an up-to-date project skips compiling and prints none of its
     // warnings, so the baseline's dead-code comparison would have nothing to subtract.
-    defaultCommands: () => ({ build: "dotnet build --no-incremental", test: "dotnet test" }),
+    // TRX under .flagrm/, so verify compares tests by name (known failures) out of the box.
+    defaultCommands: (ctx) => {
+        const dir = path.join(ctx.config.root, ".flagrm", "test-results", ctx.name);
+        return {
+            build: "dotnet build --no-incremental",
+            test: `dotnet test --logger trx --results-directory "${relativePath(ctx.root, dir) || "."}"`,
+            testResults: path.join(dir, "*.trx"),
+        };
+    },
     unusedDiagnostics: (_ctx, input) => dotnetUnusedDiagnostics(input),
 };

package/dist/cli.js

@@ -4,18 +4,23 @@ import path from "node:path";
 import { Command } from "commander";
 import pc from "picocolors";
 import { realProbes } from "./adapters/dotnet/setup.js";
-import { addNames, assertNoEditsSinceBaseline, baselinePath, baselineSummary, discoverFlag, flagDir, mergeNames, runChecks, validateAgentNames, writeBaseline, } from "./core/baseline.js";
+import { acceptBaseline, addNames, assertNoEditsSinceBaseline, baselinePath, baselineSummary, discoverFlag, mergeNames, parseAccept, validateAgentNames, writeBaseline, } from "./core/baseline.js";
+import { changeFilter } from "./core/change-filter.js";
 import { loadConfig, parseTools, TOOL_IDS } from "./core/config.js";
+import { projectCommands } from "./core/config-snapshot.js";
 import { runDoctor } from "./core/doctor.js";
-import { gitState } from "./core/git.js";
+import { blobIds, gitState } from "./core/git.js";
 import { hookRoot, parseHookInput, stopDecision } from "./core/hook.js";
 import { initProject, installRoot, updateProject } from "./core/install.js";
 import { buildInventory } from "./core/inventory.js";
 import { verifyMarkdown } from "./core/markdown.js";
+import { assertOwnNames } from "./core/name-owner.js";
 import { packageVersion } from "./core/package.js";
 import { resolveProjects } from "./core/registry.js";
 import { printBaseline, printDoctor, printInventory, printScope, printSteps, printVerifyReport, } from "./core/report.js";
+import { baselineRuns } from "./core/run-cache.js";
 import { setupReport, writeScope } from "./core/scope.js";
+import { withScopeFiles } from "./core/scope-files.js";
 import { askTools, detectTools, savedTools, TOOL_LABELS } from "./core/tools.js";
 import { CHECK_IDS } from "./core/types.js";
 import { onPath, relativePath } from "./core/util.js";
@@ -61,41 +66,70 @@ function loadWorkspace(opts) {
 // --- baseline ------------------------------------------------------------------
 addCommonOptions(program
     .command("baseline <flag>")
-    .description("record the state before removing a flag: the git commit, each project's build and test results, and the " +
+    .description("record the state before removing a flag: the git commit, each project's build, test and lint results, and the " +
     "flag's names for the leftovers check; writes .flagrm/<flag>/baseline.json for verify. With --name on an " +
     "existing baseline, only adds names"))
-    .option("--no-checks", "record only the git state, without running build and test commands")
+    .option("--no-checks", "record only the git state, without running build, test and lint commands")
+    .option("--no-reuse", "run build, tests and lint even when a passing verify on the same tree and commands saved their results")
     .option("--name <name>", "add a name the flag is read through (repeatable)", collect, [])
     .option("--kind <kind>", "how --name entries are matched: alias (qualified constant) or wrapper (identifier, calls included); default alias, wrapper with --file")
-    .option("--file <path>", "check the --name entries only in this file (a local, parameter or field; implies --kind wrapper)")
+    .option("--file <path>", "check the --name entries only in these files and the files sharing their scope, such as a component's template " +
+    "(repeatable; a local, parameter or field; implies --kind wrapper)", collect, [])
     .option("--force", "start over: replace the baseline, only while the code is unedited since it")
+    .option("--accept <what>", "acknowledge without starting over, also mid-removal: config (verify stops warning about changes to the flagrm " +
+    "config so far), failures (the baseline's failing tests); comma-separated")
     .action(async (flag, opts) => {
     const { root, projects } = loadWorkspace(opts);
+    if (opts.accept !== undefined) {
+        if (opts.force || opts.name.length || opts.file.length || opts.kind || !opts.checks || !opts.reuse) {
+            fail(new Error("--accept only records an acknowledgement; run it without --force, --name, --file, --kind, --no-checks and --no-reuse."));
+        }
+        let accepted;
+        try {
+            accepted = acceptBaseline(root, flag, projects, parseAccept(opts.accept));
+        }
+        catch (err) {
+            fail(err);
+        }
+        if (opts.json)
+            console.log(JSON.stringify(baselineSummary(accepted.baseline, accepted.file), null, 2));
+        else
+            printBaseline(accepted.baseline, accepted.file);
+        return;
+    }
     // Only wrappers are matched per file: a name scoped with --file is a local, parameter or field.
-    const kind = opts.kind ?? (opts.file ? "wrapper" : "alias");
+    const kind = opts.kind ?? (opts.file.length ? "wrapper" : "alias");
     if (kind !== "alias" && kind !== "wrapper") {
         fail(new Error(`--kind must be alias or wrapper, not "${kind}".`));
     }
-    if (opts.file && opts.name.length === 0)
+    if (!opts.checks && !opts.reuse)
+        fail(new Error("--no-reuse has nothing to reuse with --no-checks."));
+    if (opts.file.length && opts.name.length === 0)
         fail(new Error("--file scopes --name entries; pass --name too."));
-    if (opts.file && kind !== "wrapper")
+    if (opts.file.length && kind !== "wrapper")
         fail(new Error("--file scopes wrapper names; drop --kind alias."));
-    const scope = opts.file && relativePath(root, path.resolve(opts.file));
-    if (scope?.startsWith(".."))
-        fail(new Error(`--file ${opts.file} is outside ${root}.`));
-    const added = opts.name.map((name) => ({
+    const scopes = [
+        ...new Set(opts.file.flatMap((file) => {
+            const rel = relativePath(root, path.resolve(file));
+            if (rel.startsWith(".."))
+                fail(new Error(`--file ${file} is outside ${root}.`));
+            return withScopeFiles(projects, root, rel);
+        })),
+    ];
+    const added = opts.name.flatMap((name) => (scopes.length ? scopes : [undefined]).map((file) => ({
         name,
         kind: kind,
         source: "agent",
-        ...(scope ? { file: scope } : {}),
-    }));
+        ...(file ? { file } : {}),
+    })));
     let result;
     try {
         validateAgentNames(projects, added);
+        await assertOwnNames(root, projects, flag, added);
         const exists = fs.existsSync(baselinePath(root, flag));
         if (exists && opts.force) {
-            const testResults = projects.flatMap(({ ctx }) => (ctx.project.testResults ? [ctx.project.testResults] : []));
-            assertNoEditsSinceBaseline(root, flag, testResults);
+            const testResults = projects.flatMap(({ adapter, ctx }) => projectCommands(adapter, ctx).testResults ?? []);
+            assertNoEditsSinceBaseline(root, flag, testResults, changeFilter(projects[0]?.ctx.config));
         }
         if (exists && !opts.force) {
             if (added.length === 0) {
@@ -105,7 +139,9 @@ addCommonOptions(program
         }
         else {
             const git = gitState(root);
-            const checks = opts.checks ? await runChecks(projects, flagDir(root, flag)) : undefined;
+            if (git.dirtyFiles?.length)
+                git.dirtyHashes = blobIds(root, git.dirtyFiles);
+            const checks = opts.checks ? await baselineRuns(root, flag, projects, opts.reuse) : undefined;
             const { names, ...flow } = await discoverFlag(projects, flag);
             result = writeBaseline(root, flag, projects, git, checks, mergeNames(names, added), flow);
         }
@@ -123,18 +159,23 @@ addCommonOptions(program
 // --- verify ------------------------------------------------------------------
 addCommonOptions(program
     .command("verify <flag>")
-    .description("gate a flag removal against its baseline (`flagrm baseline <flag>`): build, tests and new unused code; " +
+    .description("gate a flag removal against its baseline (`flagrm baseline <flag>`): leftovers, new unused code, build, tests, lint and coverage; " +
     "writes .flagrm/<flag>/verify.json; exit 0 pass, 1 fail, 2 usage error"))
     .option("--skip <checks>", `comma-separated checks to skip (${CHECK_IDS.join(", ")})`)
     .option("--strict", "treat warnings as failures")
     .option("--md", "print a markdown overview (for the user or a PR) instead of text")
+    .option("--no-reuse", "run build, tests and lint even when a passing verify on the same tree and commands saved their results")
     .action(async (flag, opts) => {
     if (opts.md && opts.json)
         fail(new Error("--md and --json can't be combined."));
     const { root, projects } = loadWorkspace(opts);
     let result;
     try {
-        result = await verifyFlag(root, projects, flag, { skip: parseSkip(opts.skip), strict: opts.strict });
+        result = await verifyFlag(root, projects, flag, {
+            skip: parseSkip(opts.skip),
+            strict: opts.strict,
+            reuse: opts.reuse,
+        });
     }
     catch (err) {
         fail(err);
@@ -252,10 +293,10 @@ function printInstallRoot(root) {
 // --- doctor ------------------------------------------------------------------
 program
     .command("doctor")
-    .description("check that this repository is ready for flag removal: config, build/test commands, git, .gitignore, " +
+    .description("check that this repository is ready for flag removal: config, build/test/lint commands, git, .gitignore, " +
     "installed skills and Stop hook, abandoned baselines; exit 0 ok, 1 problems")
     .option("--config <path>", "path to a config file (default: the nearest flagrm.config.yaml up to the git repository root)")
-    .option("--run", "also run each build and test command")
+    .option("--run", "also run each build, test and lint command")
     .option("--json", "machine-readable JSON output")
     .action(async (opts) => {
     const report = await runDoctor(process.cwd(), { config: opts.config, run: opts.run });