@workerstack/repo 0.0.0-stage → 0.1.0

package/cli/check-manifests.ts

@@ -0,0 +1,71 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CALL_SEPARATOR, QUOTED_SPAN } from "./check-manifests.constants.ts";
+import type { PackageJson, Workspace } from "./sync/workspace.ts";
+
+const BUN_PIN = /^bun@\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/;
+
+/**
+ * `repo check`'s manifest lines, one per problem: the root first, then each workspace package by directory.
+ * A root with `workspaces` is not a package, so it needs `private` and `packageManager` but not `sideEffects`.
+ */
+export function checkManifests({ root, manifest, packages }: Workspace): string[] {
+  const lines: string[] = [];
+  const isMonorepo = manifest.workspaces !== undefined;
+  if (fs.existsSync(path.join(root, "package.json"))) {
+    lines.push(
+      ...packageLines("package.json", manifest, !isMonorepo),
+      ...packageManagerLines(manifest),
+      ...chainedScriptLines(manifest),
+    );
+  }
+  for (const pkg of packages) lines.push(...packageLines(`${pkg.dir}/package.json`, pkg.manifest, true));
+  return lines;
+}
+
+function packageLines(file: string, manifest: PackageJson, needsSideEffects: boolean): string[] {
+  const lines: string[] = [];
+  if (manifest.private === undefined) lines.push(`${file}: "private" is missing; set true, or false to publish it`);
+  if (manifest.private === true && manifest.version !== undefined) {
+    lines.push(`${file}: private packages have no "version"; delete it`);
+  }
+  if (needsSideEffects && manifest.sideEffects !== false) {
+    lines.push(
+      manifest.sideEffects === undefined
+        ? `${file}: "sideEffects" is missing; set it to false`
+        : `${file}: "sideEffects" is ${JSON.stringify(manifest.sideEffects)}; set it to false and import CSS from an app entry`,
+    );
+  }
+  return lines;
+}
+
+function packageManagerLines({ packageManager }: PackageJson): string[] {
+  if (packageManager === undefined) {
+    return [`package.json: "packageManager" is missing; set it to "bun@${Bun.version}"`];
+  }
+  if (typeof packageManager === "string" && BUN_PIN.test(packageManager)) return [];
+  return [
+    `package.json: "packageManager" is ${JSON.stringify(packageManager)}; pin an exact version like "bun@${Bun.version}"`,
+  ];
+}
+
+function chainedScriptLines({ scripts }: PackageJson): string[] {
+  const lines: string[] = [];
+  const entries = typeof scripts === "object" && scripts !== null ? Object.entries(scripts) : [];
+  for (const [name, command] of entries) {
+    const calls = typeof command === "string" ? toolCalls(command) : 0;
+    if (calls <= 1) continue;
+    lines.push(
+      `package.json: "${name}" chains ${calls} tool calls with "&&" or ";"; make it one call, such as "repo ci"`,
+    );
+  }
+  return lines;
+}
+
+/** The non-empty segments of `command` split on `&&` and `;` outside quotes; `||` and `|` do not split. */
+function toolCalls(command: string): number {
+  return command
+    .replace(QUOTED_SPAN, "x")
+    .split(CALL_SEPARATOR)
+    .filter((segment) => segment.trim() !== "").length;
+}

package/cli/check-nightly.test.ts

@@ -0,0 +1,103 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { checkNightlyAt, nightlyProblems } from "./check-nightly.ts";
+import type { Pack } from "./config.ts";
+import { BASE_CONFIG } from "./fixtures/base-config.ts";
+import { INSTALL_HINT } from "./mutate.constants.ts";
+import type { PackageJson } from "./sync/workspace.ts";
+
+const temps: string[] = [];
+
+afterEach(() => {
+  for (const dir of temps.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+});
+
+const STRYKER: PackageJson = {
+  devDependencies: { "@stryker-mutator/core": "10.1.1", "@stryker-mutator/vitest-runner": "10.1.1" },
+};
+const INSTALL_LINE = `the release pack runs mutation tests nightly; ${INSTALL_HINT}`;
+const NO_FILE_LINE =
+  "coverage.mutate (src/**/*.ts) matches no tracked file; set coverage.mutate in workerstack.config.ts";
+
+const input = (manifest: PackageJson, tracked: string[], packs: Pack[] = ["release"]) => ({
+  config: { packs, agents: { hosts: [], skills: [] }, ...BASE_CONFIG },
+  workspace: { root: "/repo", manifest, packages: [] },
+  tracked,
+});
+
+describe("nightlyProblems", () => {
+  it("passes a root with both Stryker packages and a tracked file the globs match", () => {
+    expect(nightlyProblems(input(STRYKER, ["src/a.ts"]))).toEqual([]);
+  });
+
+  it("names the install when a Stryker package is missing", () => {
+    expect(nightlyProblems(input({}, ["src/a.ts"]))).toEqual([INSTALL_LINE]);
+    const half = { dependencies: { "@stryker-mutator/core": "10.1.1" } };
+    expect(nightlyProblems(input(half, ["src/a.ts"]))).toEqual([INSTALL_LINE]);
+  });
+
+  it("accepts Stryker as a dependency", () => {
+    const deps = { dependencies: STRYKER.devDependencies ?? {} };
+    expect(nightlyProblems(input(deps, ["src/a.ts"]))).toEqual([]);
+  });
+
+  it("names coverage.mutate when it matches no tracked file, tests and fixtures not counting", () => {
+    expect(nightlyProblems(input(STRYKER, ["src/a.test.ts", "lib/b.ts"]))).toEqual([NO_FILE_LINE]);
+  });
+
+  it("reports both problems, install first", () => {
+    expect(nightlyProblems(input({}, []))).toEqual([INSTALL_LINE, NO_FILE_LINE]);
+  });
+
+  it("checks nothing without the release pack", () => {
+    expect(nightlyProblems(input({}, [], ["docs"]))).toEqual([]);
+  });
+});
+
+/** A git repo holding `files`, committed or not per `commit`. */
+function repo(files: Record<string, string>, commit = true): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "check-nightly-"));
+  temps.push(root);
+  for (const [rel, text] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+    fs.writeFileSync(path.join(root, rel), text);
+  }
+  execFileSync("git", ["init", "-q"], { cwd: root });
+  if (commit) execFileSync("git", ["add", "."], { cwd: root });
+  return root;
+}
+
+const CONFIG = 'export default { packs: ["release"] };\n';
+const MANIFEST = JSON.stringify({ name: "app", ...STRYKER });
+
+describe("checkNightlyAt", () => {
+  it("reads the config, the root manifest and the tracked files", async () => {
+    const root = repo({ ["workerstack.config.ts"]: CONFIG, "package.json": "{}", "lib/a.ts": "" });
+    expect(await checkNightlyAt(root)).toEqual([INSTALL_LINE, NO_FILE_LINE]);
+  });
+
+  it("passes a repo with Stryker and a tracked source", async () => {
+    const root = repo({ "workerstack.config.ts": CONFIG, "package.json": MANIFEST, "src/a.ts": "" });
+    expect(await checkNightlyAt(root)).toEqual([]);
+  });
+
+  it("does not count an untracked file", async () => {
+    const root = repo({ "workerstack.config.ts": CONFIG, "package.json": MANIFEST }, true);
+    fs.mkdirSync(path.join(root, "src"));
+    fs.writeFileSync(path.join(root, "src/a.ts"), "");
+    expect(await checkNightlyAt(root)).toEqual([NO_FILE_LINE]);
+  });
+
+  it("leaves a bad config, an unreadable manifest and a missing git to the other checks", async () => {
+    expect(await checkNightlyAt(repo({ "workerstack.config.ts": "export default 3;\n" }))).toEqual([]);
+    expect(await checkNightlyAt(repo({ "workerstack.config.ts": CONFIG, "package.json": "[" }))).toEqual([]);
+    const bare = fs.mkdtempSync(path.join(os.tmpdir(), "check-nightly-bare-"));
+    temps.push(bare);
+    fs.writeFileSync(path.join(bare, "workerstack.config.ts"), CONFIG);
+    fs.writeFileSync(path.join(bare, "package.json"), MANIFEST);
+    expect(await checkNightlyAt(bare)).toEqual([]);
+  });
+});

package/cli/check-nightly.ts

@@ -0,0 +1,37 @@
+/** `repo check` under the release pack: the nightly mutation run needs Stryker and files to mutate. */
+import { loadConfig, type ResolvedConfig } from "./config.ts";
+import { INSTALL_HINT, STRYKER_CORE, STRYKER_RUNNER } from "./mutate.constants.ts";
+import { selectFiles } from "./mutate-files.ts";
+import { runGit } from "./sync/standards.ts";
+import { readWorkspace, type Workspace } from "./sync/workspace.ts";
+
+/** What the nightly problems are judged from: the config, the workspace and the tracked files. */
+export type NightlyInput = { config: ResolvedConfig; workspace: Workspace; tracked: readonly string[] };
+
+/** One line per problem that would make the nightly mutation job fail every night; none without the release pack. */
+export function nightlyProblems({ config, workspace, tracked }: NightlyInput): string[] {
+  if (!config.packs.includes("release")) return [];
+  const lines: string[] = [];
+  const { dependencies = {}, devDependencies = {} } = workspace.manifest;
+  const installed = (name: string) => name in dependencies || name in devDependencies;
+  if (![STRYKER_CORE, STRYKER_RUNNER].every(installed)) {
+    lines.push(`the release pack runs mutation tests nightly; ${INSTALL_HINT}`);
+  }
+  const globs = config.coverage.mutate;
+  if (selectFiles(tracked, globs).length === 0) {
+    lines.push(
+      `coverage.mutate (${globs.join(", ")}) matches no tracked file; set coverage.mutate in workerstack.config.ts`,
+    );
+  }
+  return lines;
+}
+
+/** `nightlyProblems` for the checkout at `root`; a config, manifest or listing that cannot be read is another check's line. */
+export async function checkNightlyAt(root: string): Promise<string[]> {
+  const loaded = await loadConfig(root);
+  const read = readWorkspace(root);
+  const listed = runGit(root, ["ls-files", "-z", "--cached"]);
+  if (!loaded.ok || !read.ok || listed.status !== 0) return [];
+  const tracked = listed.stdout.split("\0").filter((file) => file !== "");
+  return nightlyProblems({ config: loaded.config, workspace: read.workspace, tracked });
+}

package/cli/check-ratchets-missing.test.ts

@@ -0,0 +1,46 @@
+import fs from "node:fs";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { ratchetProblems } from "./check-ratchets.ts";
+import { removePlanted, repoOnMain, write } from "./fixtures/planted-repo.ts";
+
+afterEach(removePlanted);
+
+const FLOORS = "coverage-floors.json";
+const FAILURES = "known-failures.json";
+const BASELINE = ".repo/lint-baseline.json";
+const HIGH = 61;
+
+const floor = (branches: number) => ({ statements: 80, branches, functions: 90 });
+const job = "cli/scripts/job.ts";
+
+describe("ratchetProblems, files gone, unreadable or oddly shaped here", () => {
+  const main = {
+    [FLOORS]: { [job]: floor(HIGH) },
+    [job]: "export {};\n",
+    [FAILURES]: ["a > b"],
+    [BASELINE]: { "a.ts": { r: 2 } },
+  };
+
+  it("reads a deleted floors, list and baseline file as empty", () => {
+    const dir = repoOnMain(main);
+    for (const rel of [FLOORS, FAILURES, BASELINE]) fs.rmSync(path.join(dir, rel));
+    expect(ratchetProblems(dir)).toEqual([
+      `${FLOORS}: ${job} has no floor but main has one and the file exists; restore it`,
+    ]);
+  });
+
+  it("reads floors that are not JSON as empty, and a baseline that dropped the rule as zero", () => {
+    const dir = repoOnMain(main);
+    write(dir, { [FLOORS]: "{", [BASELINE]: { "a.ts": {} } });
+    expect(ratchetProblems(dir)).toEqual([
+      `${FLOORS}: ${job} has no floor but main has one and the file exists; restore it`,
+    ]);
+  });
+
+  it("fails a metric that lost its floor, and skips main rows that are no table", () => {
+    const dir = repoOnMain({ ...main, [FLOORS]: { [job]: floor(HIGH), "x.ts": 5 } });
+    write(dir, { [FLOORS]: { [job]: { statements: 80, functions: 90 } } });
+    expect(ratchetProblems(dir)).toEqual([`${FLOORS}: ${job} branches has no floor but main has ${HIGH}; restore it`]);
+  });
+});

package/cli/check-ratchets-mutation.test.ts

@@ -0,0 +1,49 @@
+import fs from "node:fs";
+import path from "node:path";
+import { afterEach, expect, it } from "vitest";
+import { ratchetProblems } from "./check-ratchets.ts";
+import { removePlanted, repoOnMain, write } from "./fixtures/planted-repo.ts";
+
+afterEach(removePlanted);
+
+const FILE = "mutation-floors.json";
+const main = { [FILE]: { ".": 89, "packages/a": 70 }, "packages/a/package.json": "{}\n" };
+const paths = { mutationFloors: FILE };
+
+it("fails a lowered floor, naming the package and both numbers", () => {
+  const dir = repoOnMain(main);
+  write(dir, { [FILE]: { ".": 80, "packages/a": 70 } });
+  expect(ratchetProblems(dir, paths)).toEqual([`${FILE} lowers . from 89 to 80 against main; floors only rise`]);
+});
+
+it("passes an unchanged, raised or added floor", () => {
+  const dir = repoOnMain(main);
+  write(dir, { [FILE]: { ".": 90, "packages/a": 70, "packages/b": 1 } });
+  expect(ratchetProblems(dir, paths)).toEqual([]);
+});
+
+it("fails a dropped floor while its package dir exists, and passes one dropped with its package", () => {
+  const dir = repoOnMain(main);
+  write(dir, { [FILE]: { ".": 89 } });
+  expect(ratchetProblems(dir, paths)).toEqual([`${FILE} drops packages/a from 70; floors only rise`]);
+  fs.rmSync(path.join(dir, "packages/a"), { recursive: true });
+  expect(ratchetProblems(dir, paths)).toEqual([]);
+});
+
+it("reads the default path when none is given, and ignores a floors file main lacks", () => {
+  const dir = repoOnMain(main);
+  write(dir, { [FILE]: { ".": 1, "packages/a": 70 } });
+  expect(ratchetProblems(dir)).toEqual([`${FILE} lowers . from 89 to 1 against main; floors only rise`]);
+  const fresh = repoOnMain({ "a.txt": "a\n" });
+  write(fresh, { [FILE]: { ".": 1 } });
+  expect(ratchetProblems(fresh, paths)).toEqual([]);
+});
+
+it("treats a floors file of the wrong shape as having no floors", () => {
+  const dir = repoOnMain(main);
+  write(dir, { [FILE]: "[]\n" });
+  expect(ratchetProblems(dir, paths)).toEqual([
+    `${FILE} drops . from 89; floors only rise`,
+    `${FILE} drops packages/a from 70; floors only rise`,
+  ]);
+});

package/cli/check-ratchets.constants.ts

@@ -0,0 +1,20 @@
+/** The names `repo check`'s ratchets share. */
+
+/** Where the coverage floors live unless the config says otherwise. */
+export const DEFAULT_FLOORS = "coverage-floors.json";
+/** Where the mutation floors live unless the config says otherwise. */
+export const DEFAULT_MUTATION_FLOORS = "mutation-floors.json";
+/** The git remote a clone's default branch is read from. */
+export const ORIGIN = "origin";
+/** The branch names tried when the current branch is the only one left. */
+export const COMMON_BRANCHES = ["main", "master"] as const;
+/** The `git diff --name-status` letter of a rename. */
+export const RENAME = "R";
+/** Separates the columns of `git diff --name-status`. */
+export const TAB = "\t";
+/** Separates the lines of git's output. */
+export const NEWLINE = "\n";
+/** What `defaultBranch` names when no branch is checked out. */
+export const DETACHED = "HEAD";
+/** The columns of a rename in `git diff --name-status`: the status, the old path and the new one. */
+export const RENAME_COLUMNS = 3;

package/cli/check-ratchets.test.ts

@@ -0,0 +1,190 @@
+import fs from "node:fs";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { ratchetProblems } from "./check-ratchets.ts";
+import { git, removePlanted, repoOnMain, tempDir, write } from "./fixtures/planted-repo.ts";
+
+afterEach(removePlanted);
+
+const FLOORS = "coverage-floors.json";
+const FAILURES = "known-failures.json";
+const BASELINE = ".repo/lint-baseline.json";
+const HIGH = 61;
+const LOW = 58;
+
+const floor = (branches: number) => ({ statements: 80, branches, functions: 90 });
+const job = "cli/scripts/job.ts";
+
+describe("ratchetProblems, floors", () => {
+  const main = { [FLOORS]: { [job]: floor(HIGH) }, [job]: "export {};\n" };
+
+  it("fails a lowered floor", () => {
+    const dir = repoOnMain(main);
+    write(dir, { [FLOORS]: { [job]: floor(LOW) } });
+    expect(ratchetProblems(dir)).toEqual([
+      `${FLOORS}: ${job} branches ${LOW} is below main's ${HIGH}; floors only rise`,
+    ]);
+  });
+
+  it("passes an unchanged or raised floor", () => {
+    const dir = repoOnMain(main);
+    write(dir, { [FLOORS]: { [job]: floor(HIGH + 1) } });
+    expect(ratchetProblems(dir)).toEqual([]);
+  });
+
+  it("fails a floor dropped while its source exists, and passes one dropped with its source", () => {
+    const dir = repoOnMain(main);
+    write(dir, { [FLOORS]: {} });
+    expect(ratchetProblems(dir)).toEqual([
+      `${FLOORS}: ${job} has no floor but main has one and the file exists; restore it`,
+    ]);
+    fs.rmSync(path.join(dir, job));
+    expect(ratchetProblems(dir)).toEqual([]);
+  });
+
+  it("passes a new file at any floor", () => {
+    const dir = repoOnMain(main);
+    write(dir, { [FLOORS]: { [job]: floor(HIGH), "cli/new.ts": floor(1) } });
+    expect(ratchetProblems(dir)).toEqual([]);
+  });
+});
+
+describe("ratchetProblems, renamed floors", () => {
+  const main = { [FLOORS]: { [job]: floor(HIGH) }, [job]: "export {};\n" };
+
+  it("fails a renamed file whose new key is below the old key's floor", () => {
+    const dir = repoOnMain(main);
+    git(dir, "mv", job, "cli/scripts/work.ts");
+    write(dir, { [FLOORS]: { "cli/scripts/work.ts": floor(LOW) } });
+    expect(ratchetProblems(dir)).toEqual([
+      `${FLOORS}: cli/scripts/work.ts branches ${LOW} is below main's ${HIGH} (renamed from ${job}); floors only rise`,
+    ]);
+  });
+
+  it("passes a renamed file that carries its floor", () => {
+    const dir = repoOnMain(main);
+    git(dir, "mv", job, "cli/scripts/work.ts");
+    write(dir, { [FLOORS]: { "cli/scripts/work.ts": floor(HIGH) } });
+    expect(ratchetProblems(dir)).toEqual([]);
+  });
+
+  it("reads the floors from the path it is given", () => {
+    const dir = repoOnMain({ "dev/floors.json": { [job]: floor(HIGH) }, [job]: "" });
+    write(dir, { "dev/floors.json": { [job]: floor(LOW) } });
+    expect(ratchetProblems(dir, { floors: "dev/floors.json" })).toHaveLength(1);
+    expect(ratchetProblems(dir)).toEqual([]);
+  });
+});
+
+describe("ratchetProblems, the main ref", () => {
+  const main = { [FLOORS]: { [job]: floor(HIGH) }, [job]: "" };
+
+  it("still fails a lowered floor when only origin/main exists", () => {
+    const origin = repoOnMain(main);
+    git(origin, "checkout", "-q", "main");
+    const dir = tempDir();
+    git(dir, "clone", "-q", origin, dir);
+    git(dir, "checkout", "-q", "-b", "feature");
+    git(dir, "branch", "-q", "-D", "main");
+    write(dir, { [FLOORS]: { [job]: floor(LOW) } });
+    expect(ratchetProblems(dir)).toHaveLength(1);
+  });
+});
+
+describe("ratchetProblems, no main ref", () => {
+  it("compares nothing in a repo with no main", () => {
+    const dir = tempDir();
+    git(dir, "init", "-q", "-b", "work");
+    write(dir, { [FLOORS]: { [job]: floor(LOW) }, [FAILURES]: ["a"] });
+    git(dir, "add", "-A");
+    git(dir, "commit", "-q", "-m", "work");
+    expect(ratchetProblems(dir)).toEqual([]);
+  });
+
+  it("compares nothing before the first commit", () => {
+    const dir = tempDir();
+    git(dir, "init", "-q", "-b", "main");
+    write(dir, { [FLOORS]: { [job]: floor(LOW) } });
+    expect(ratchetProblems(dir)).toEqual([]);
+  });
+
+  it("compares nothing for a file main does not have", () => {
+    const dir = repoOnMain({ "README.md": "x\n" });
+    write(dir, { [FLOORS]: { [job]: floor(LOW) }, [FAILURES]: ["a"], [BASELINE]: { "a.ts": { r: 1 } } });
+    expect(ratchetProblems(dir)).toEqual([]);
+  });
+});
+
+describe("ratchetProblems, known failures", () => {
+  const main = { [FAILURES]: ["a.test.ts > one", "a.test.ts > two"] };
+
+  it("fails an entry main's list lacks", () => {
+    const dir = repoOnMain(main);
+    write(dir, { [FAILURES]: ["a.test.ts > one", "a.test.ts > two", "a.test.ts > three"] });
+    expect(ratchetProblems(dir)).toEqual([
+      `${FAILURES}: "a.test.ts > three" is not on main's list; fix the case instead of listing it`,
+    ]);
+  });
+
+  it("fails a swapped entry though the list is no longer", () => {
+    const dir = repoOnMain(main);
+    write(dir, { [FAILURES]: ["a.test.ts > one", "a.test.ts > other"] });
+    expect(ratchetProblems(dir)).toEqual([
+      `${FAILURES}: "a.test.ts > other" is not on main's list; fix the case instead of listing it`,
+    ]);
+  });
+
+  it("passes a shrunk list", () => {
+    const dir = repoOnMain(main);
+    write(dir, { [FAILURES]: ["a.test.ts > one"] });
+    expect(ratchetProblems(dir)).toEqual([]);
+  });
+
+  it("reads the list from the path it is given", () => {
+    const dir = repoOnMain({ "dev/kf.json": ["x"] });
+    write(dir, { "dev/kf.json": ["x", "y"] });
+    expect(ratchetProblems(dir, { knownFailures: "dev/kf.json" })).toHaveLength(1);
+  });
+});
+
+describe("ratchetProblems, the lint baseline", () => {
+  const MAGIC = "repo(magic-number)";
+  const main = { [BASELINE]: { "a.ts": { [MAGIC]: 2 }, "b.ts": { [MAGIC]: 1 } } };
+
+  it("fails a rule whose total rises over main's", () => {
+    const dir = repoOnMain(main);
+    write(dir, { [BASELINE]: { "a.ts": { [MAGIC]: 3 }, "b.ts": { [MAGIC]: 1 } } });
+    expect(ratchetProblems(dir)).toEqual([
+      `${BASELINE}: ${MAGIC} totals 4, main has 3; fix the new hit instead of baselining it`,
+    ]);
+  });
+
+  it("fails a rule that rises in a new file even when another file fell", () => {
+    const dir = repoOnMain(main);
+    write(dir, { [BASELINE]: { "a.ts": { [MAGIC]: 1 }, "b.ts": { [MAGIC]: 1 }, "c.ts": { [MAGIC]: 2 } } });
+    expect(ratchetProblems(dir)).toHaveLength(1);
+  });
+
+  it("passes a rename that keeps the per-rule totals", () => {
+    const dir = repoOnMain(main);
+    write(dir, { [BASELINE]: { "x.ts": { [MAGIC]: 2 }, "b.ts": { [MAGIC]: 1 } } });
+    expect(ratchetProblems(dir)).toEqual([]);
+  });
+});
+
+describe("ratchetProblems, the lint baseline, lowered and seeded", () => {
+  const MAGIC = "repo(magic-number)";
+  const main = { [BASELINE]: { "a.ts": { [MAGIC]: 2 }, "b.ts": { [MAGIC]: 1 } } };
+
+  it("passes a lowered total", () => {
+    const dir = repoOnMain(main);
+    write(dir, { [BASELINE]: { "a.ts": { [MAGIC]: 1 } } });
+    expect(ratchetProblems(dir)).toEqual([]);
+  });
+
+  it("lets a rule main's baseline lacks be seeded", () => {
+    const dir = repoOnMain(main);
+    write(dir, { [BASELINE]: { "a.ts": { [MAGIC]: 2, "repo(new-rule)": 40 }, "b.ts": { [MAGIC]: 1 } } });
+    expect(ratchetProblems(dir)).toEqual([]);
+  });
+});