@goodbones/cli 0.1.0-beta.17 → 0.1.0-beta.18

package/build/esm/run.js

@@ -1,19 +1,18 @@
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
-import { attest, authorOf, baseSideAt, campaignFailuresOf, campaignReportsOf, campaignsOf, campaignsSelecting, clear, concede, evaluateCampaigns, explainCampaignLines, explainObjective, historyOf, hitsInWindow, ledgeredFilter, measureFile, note, nudgeOf, readDiff, renderCampaignReports, renderCampaignRows, renderHistory, renderNudge, renderSectorView, reportSpecsOf, sectorMovesOf, sectorViewOf, snapshotCampaignsOf, valueOfParts, widenedExtensions, } from "@goodbones/campaigns";
 import { baselineOf, breaches, CONFORMANCE_MEASURES, countedFiles, coverageOf, cyclesIn, decodeBaseline, decodeManifest, EMPTY_BASELINE, evaluateGraph, evaluateMemberSite, evaluateResolvedEdge, evaluateSelectedBindings, evaluateStructure, evaluateSurface, expandAliases, exportRulesSelecting, findManifestFile, fingerprintOf, formatManifestYaml, formatMessage, fractionsOf, globsOf, globToRegExp, hasGraphRules, heightOf, listSourceFiles, makeBaselineFilter, MANIFEST_FILENAMES, MANIFEST_SCHEMA_ID, memberRulesSelecting, readManifestFile, requiredSiblingsOf, residueOf, rulesSelecting, serializeBaseline, slackOf, SNAPSHOT_VERSION, staleEntriesOf, surfaceRulesSelecting, vacancyOf, } from "@goodbones/core";
 import * as Effect from "effect/Effect";
 import * as Result from "effect/Result";
 import { loadPolicyFromFile, manifestPathOf } from "./config-loader.js";
 import { buildGraph } from "./graph.js";
 import { infer } from "./infer.js";
+import { count, fail, report } from "./output.js";
 import { sourceFactsOf } from "./source-facts.js";
-const fail = (message) => ({ _tag: "CliFailure", message });
 export const collectFindings = (policy, roots, options = {}) => {
     // A campaign may widen the walk past the packs' extensions; a file only a
     // campaign asked for is seen by the campaigns and by no other family.
-    const walked = listSourceFiles(policy.repoRoot, roots, policy.languages, widenedExtensions(policy));
+    const walked = listSourceFiles(policy.repoRoot, roots, policy.languages, policy.campaigns.widenedExtensions(policy));
     const known = new Set(policy.languages.flatMap((one) => one.extensions));
     const files = walked.filter((file) => known.has(path.extname(file)));
     const violations = [];
@@ -49,7 +48,7 @@ export const collectFindings = (policy, roots, options = {}) => {
             violations.push(violation);
     }
     // The campaigns, over every walked file, through the same caches.
-    const campaigns = evaluateCampaigns(policy, roots, walked, { textOf, factsOf });
+    const campaigns = policy.campaigns.evaluate(policy, roots, walked, { textOf, factsOf });
     for (const file of files) {
         for (const violation of evaluateStructure(policy.structure, policy.fileSystem, file)) {
             violations.push(violation);
@@ -119,10 +118,6 @@ const readBaseline = (policy) => {
         return EMPTY_BASELINE;
     }
 };
-const report = (lines) => Effect.sync(() => {
-    for (const line of lines)
-        process.stdout.write(`${line}\n`);
-});
 const describe = (violation) => `  ${violation.file}\n      ${formatMessage(violation)}`;
 const COVERAGE_FAMILIES = [
     "imports",
@@ -170,7 +165,6 @@ const reportOf = (policy, roots, manifestPath, findings) => {
     const baseline = readBaseline(policy);
     const stale = staleEntriesOf(baseline, findings.violations);
     const { isBaselined } = makeBaselineFilter(baseline);
-    const isLedgered = ledgeredFilter(policy, findings.campaigns);
     const violations = [
         ...findings.violations.map((violation) => ({
             ...violation,
@@ -180,17 +174,17 @@ const reportOf = (policy, roots, manifestPath, findings) => {
         })),
         // The hits that count: those whose objective is in window for the
         // sector they fall in.
-        ...findings.campaigns.flatMap((evaluation) => hitsInWindow(evaluation).map((hit) => ({
+        ...policy.campaigns.hitsOf(policy, findings.campaigns).map((hit) => ({
             ...hit.violation,
             fingerprint: fingerprintOf(hit.violation),
             baselined: false,
-            ledgered: isLedgered(hit),
+            ledgered: hit.ledgered,
             objective: hit.objective,
             sector: hit.sector,
             entry: hit.entry,
-        }))),
+        })),
     ];
-    const campaigns = campaignReportsOf(policy, findings.campaigns);
+    const campaigns = policy.campaigns.reportsOf(policy, findings.campaigns);
     // The floors. A policy states how much of the tree it reaches, per
     // family; falling under is a policy that quietly stopped covering files.
     // Both are held over the files the limits count: what `limits.outside`
@@ -239,7 +233,7 @@ const reportOf = (policy, roots, manifestPath, findings) => {
             shortfalls.length === 0 &&
             overruns.length === 0 &&
             excesses.length === 0 &&
-            campaignFailuresOf(campaigns).length === 0,
+            policy.campaigns.failuresOf(campaigns).length === 0,
         manifest: {
             path: path.relative(policy.repoRoot, manifestPath).replaceAll(path.sep, "/"),
             sha256: sha256Of(manifestPath),
@@ -279,10 +273,10 @@ const excessesOf = (conformance) => CONFORMANCE_MEASURES.flatMap((measure) => {
         ? []
         : [{ measure, count, ceiling }];
 });
-const failureOf = (report, shortfalls) => {
+const failureOf = (policy, report, shortfalls) => {
     if (report.stale.length > 0)
         return fail("stale baseline entries");
-    const [campaignFailure] = campaignFailuresOf(report.campaigns);
+    const [campaignFailure] = policy.campaigns.failuresOf(report.campaigns);
     if (campaignFailure !== undefined)
         return fail(campaignFailure);
     if (shortfalls.length > 0)
@@ -309,7 +303,7 @@ const describeExcess = (one) => {
     const [singular, plural] = MEASURE_NOUNS[one.measure];
     return `  ${one.measure}: ${count(one.count, singular, plural)}, ceiling ${String(one.ceiling)}`;
 };
-const renderCampaigns = (report) => renderCampaignReports(report.campaigns, report.violations.flatMap((one) => one.kind === "campaign" &&
+const renderCampaigns = (policy, report) => policy.campaigns.renderReports(report.campaigns, report.violations.flatMap((one) => one.kind === "campaign" &&
     one.objective !== undefined &&
     one.sector !== undefined &&
     one.entry !== undefined
@@ -323,7 +317,7 @@ const renderCampaigns = (report) => renderCampaignReports(report.campaigns, repo
         },
     ]
     : []));
-const renderText = (report) => {
+const renderText = (policy, report) => {
     const reportable = report.violations.filter((one) => one.kind !== "campaign" && !one.baselined);
     const carried = report.violations.filter((one) => one.kind !== "campaign").length - reportable.length;
     const shortfalls = shortfallsOf(report.coverage);
@@ -373,20 +367,19 @@ const renderText = (report) => {
                 "",
                 "  architecture conformance    # which files, nodes and allowances",
             ]),
-        ...renderCampaigns(report),
+        ...renderCampaigns(policy, report),
     ];
 };
 export const check = (policy, roots, options) => Effect.gen(function* () {
     const report_ = checkReport(policy, roots, options.manifestPath);
     // JSON is one object on stdout and nothing else there; the failure, when
     // there is one, is a sentence on stderr and the exit code, as in text.
-    yield* report(options.format === "json" ? [JSON.stringify(report_, null, 2)] : renderText(report_));
-    const failure = failureOf(report_, shortfallsOf(report_.coverage));
+    yield* report(options.format === "json" ? [JSON.stringify(report_, null, 2)] : renderText(policy, report_));
+    const failure = failureOf(policy, report_, shortfallsOf(report_.coverage));
     if (failure !== null)
         return yield* Effect.fail(failure);
 });
 const percent = (fraction) => `${String(Math.floor(fraction * 100))}%`;
-const count = (n, noun, plural = `${noun}s`) => `${String(n)} ${n === 1 ? noun : plural}`;
 // The conformance snapshot: `check`'s report grown with what no family
 // reaches, what the allowlists permit and nothing uses, the cycle count and
 // the size of the debt — the whole distance between the tree and the
@@ -407,7 +400,7 @@ export const snapshotOf = (policy, roots, manifestPath) => {
         const byHeight = heightOfViolation(left) - heightOfViolation(right);
         return byHeight !== 0 ? byHeight : left.fingerprint.localeCompare(right.fingerprint);
     });
-    const campaigns = snapshotCampaignsOf(policy, findings.campaigns);
+    const campaigns = policy.campaigns.snapshotOf(policy, findings.campaigns);
     return {
         version: SNAPSHOT_VERSION,
         manifest: report_.manifest,
@@ -441,7 +434,7 @@ const unreachedMark = (covered, total, ceiling) => {
     return `  ${String(left)} unreached ≤ ${String(ceiling)} ✓${left < ceiling ? `, lower it to ${String(left)}` : ""}`;
 };
 const outsideNote = (outside) => outside === 0 ? "" : `, ${count(outside, "file")} outside the limits`;
-const renderSnapshot = (snapshot) => {
+const renderSnapshot = (policy, snapshot) => {
     const reportable = snapshot.violations.filter((one) => !one.baselined && !one.ledgered);
     const carried = snapshot.violations.length - reportable.length;
     const row = (family) => {
@@ -512,7 +505,7 @@ const renderSnapshot = (snapshot) => {
                     : "") +
                 (snapshot.campaigns.some((one) => one.complete && one.ledgered)
                     ? `, ${count(snapshot.campaigns.filter((one) => one.complete && one.ledgered).length, "complete", "complete")}`
-                    : ""), renderCampaignRows(snapshot.campaigns))),
+                    : ""), policy.campaigns.renderRows(snapshot.campaigns))),
         "",
         `cycles: ${String(snapshot.cycles)}`,
         `baseline: ${count(snapshot.baseline.size, "entry", "entries")}`,
@@ -525,7 +518,9 @@ const renderSnapshot = (snapshot) => {
 // `ok` in the document says what `check` would have done.
 export const conformance = (policy, roots, options) => Effect.gen(function* () {
     const snapshot = snapshotOf(policy, roots, options.manifestPath);
-    yield* report(options.format === "json" ? [JSON.stringify(snapshot, null, 2)] : renderSnapshot(snapshot));
+    yield* report(options.format === "json"
+        ? [JSON.stringify(snapshot, null, 2)]
+        : renderSnapshot(policy, snapshot));
 });
 // How much of the tree the policy reaches. A probe proves a rule can fire;
 // this is whether the files are there to fire on. Reported per family, with the
@@ -610,56 +605,9 @@ export const explain = (policy, file, roots = ["packages"]) => Effect.gen(functi
             .map((rule) => `${named(rule)} (reach)`),
     ];
     const section = (title, lines) => lines.length === 0 ? [] : ["", title, ...lines];
-    // Each campaign selecting the file: the sector the file is in, its
-    // phase and definedness, the objectives in window that fire on it and
-    // the nearest remaining holdouts — which needs the campaign evaluated
-    // over its files, since a sector's phase is derived from all of them —
-    // then each objective's truth table: one line per leaf term and what
-    // it answered here, so a detector that "should fire" and does not shows
-    // which term is not saying what its author thinks.
-    const selectedCampaigns = campaignsSelecting(campaignsOf(policy).campaignRules, relative);
-    const evaluations = selectedCampaigns.length === 0 ? [] : collectFindings(policy, roots).campaigns;
-    const campaignLines = selectedCampaigns.flatMap((rule) => {
-        const at = path.join(policy.repoRoot, relative);
-        const text = existsSync(at) ? readFileSync(at, "utf8") : "";
-        const input = {
-            file: relative,
-            text,
-            facts: policy.extractor.factsOf(relative, text),
-            resolver: policy.resolver,
-            fileSystem: policy.fileSystem,
-            syntax: policy.syntax.parse(relative, text),
-            functions: campaignsOf(policy).functions,
-            reports: campaignsOf(policy).reports,
-        };
-        const evaluation = evaluations.find((one) => one.rule.id === rule.id);
-        return [
-            ...(evaluation === undefined ? [] : explainCampaignLines(policy, evaluation, relative)),
-            ...rule.objectives.flatMap((objective) => {
-                const measure = objective.measure;
-                if (measure !== null) {
-                    // A scalar: what this file adds to its sector's number.
-                    if (measure.kind === "command")
-                        return [];
-                    const parts = measureFile(measure, input);
-                    const here = measure.kind === "ratio"
-                        ? `${String(parts.of)} of ${String(parts.per)} here`
-                        : `${String(valueOfParts(measure, parts))} here`;
-                    return [
-                        `      ${objective.name} — ${firstSentence(objective.intent ?? objective.message)} (measure, ${objective.direction}; ${here})`,
-                    ];
-                }
-                const table = explainObjective(objective, input);
-                if (table.length === 0)
-                    return [];
-                const fired = table.length > 0 && table.every((line) => line.answer);
-                return [
-                    `      ${objective.name} — ${firstSentence(objective.intent ?? objective.message)} (${objective.holdout}; ${fired ? "fires here" : "no hit"})`,
-                    ...table.map((line) => `          ${line.answer ? "✓" : "✗"} ${line.term}${line.count === undefined ? "" : ` (${String(line.count)})`}`),
-                ];
-            }),
-        ];
-    });
+    // The campaigns selecting the file, evaluated over their files only
+    // when one does: a sector's phase is derived from all of them.
+    const campaignLines = policy.campaigns.explainLines(policy, relative, () => collectFindings(policy, roots).campaigns);
     yield* report([
         relative,
         "",
@@ -865,485 +813,21 @@ export const migrate = (repoRoot, configFilename) => Effect.gen(function* () {
         `Then delete ${path.basename(from)}: a repository with two manifests is refused.`,
     ]);
 });
-// The campaign commands. `campaigns` alone is the status table; `status
-// --changed` is the nudge; `attest` and `note` write a sector's record;
-// `history` replays the ledgers' git history. The ledgers themselves are
-// written by `objectives clear` (the ledger reconciled with the code
-// wherever that is not a regression) and `objectives concede` (the one way
-// a holdout is added by hand, with a reason).
-const flagOf = (argv, flag) => {
-    const at = argv.indexOf(flag);
-    const value = at === -1 ? undefined : argv[at + 1];
-    return value === undefined || value.startsWith("--") ? undefined : value;
-};
-const CAMPAIGN_SUBCOMMANDS = ["status", "attest", "note", "history", "clear", "concede"];
-const OBJECTIVE_SUBCOMMANDS = ["clear", "concede"];
-const VALUE_FLAGS = [
-    "--reason",
-    "--by",
-    "--holdouts",
-    "--entries",
-    "--sector",
-    "--campaign",
-    "--evidence",
-    "--base",
-    "--since",
-    "--hotfix",
-];
-// The verbs the family shipped with, refused by name: each has a new name
-// or no place.
-const RETIRED = {
-    init: "`campaigns init` is gone: `objectives clear <campaign>` writes a first ledger, recording each sector's initial.",
-    prune: "`campaigns prune` is now `objectives clear`.",
-    allow: "`campaigns allow` is now `objectives concede`.",
-};
-// The positionals after the subcommand, with the value flags and their
-// values stepped over: whatever is left names the roots to walk, as it
-// does for every other command.
-const positionalsOf = (argv) => {
-    const positional = [];
-    for (let at = 0; at < argv.length; at += 1) {
-        const one = argv[at] ?? "";
-        if (VALUE_FLAGS.includes(one)) {
-            at += 1;
-            continue;
-        }
-        if (!one.startsWith("--"))
-            positional.push(one);
-    }
-    return positional;
-};
-// `campaigns [status | attest <sector> <phase> | note <sector> "<text>" |
-// history [<campaign>]] [roots…]`: the subcommand and its arguments come
-// first.
-export const campaignArgsOf = (argv, ids) => {
-    const positional = positionalsOf(argv);
-    const [first, ...rest] = positional;
-    if (first === undefined)
-        return { subcommand: undefined, args: [], roots: [] };
-    if (first in RETIRED)
-        return { subcommand: first, args: [], roots: rest };
-    if (!CAMPAIGN_SUBCOMMANDS.includes(first)) {
-        return { subcommand: undefined, args: [], roots: positional };
-    }
-    switch (first) {
-        case "attest":
-            return { subcommand: first, args: rest.slice(0, 2), roots: rest.slice(2) };
-        case "note":
-            return { subcommand: first, args: rest.slice(0, 2), roots: rest.slice(2) };
-        case "history": {
-            const [second] = rest;
-            return second !== undefined && ids.includes(second)
-                ? { subcommand: first, args: [second], roots: rest.slice(1) }
-                : { subcommand: first, args: [], roots: rest };
-        }
-        case "clear":
-        case "concede": {
-            const [second] = rest;
-            return second !== undefined && ids.includes(second.split("/")[0] ?? "")
-                ? { subcommand: first, args: [second], roots: rest.slice(1) }
-                : { subcommand: first, args: [], roots: rest };
-        }
-        default:
-            return { subcommand: first, args: [], roots: rest };
-    }
-};
-// `objectives [clear [<campaign>[/<objective>]] | concede <campaign>[/<objective>]
-// --reason <text>] [roots…]`.
-export const objectiveArgsOf = (argv, ids) => {
-    const positional = positionalsOf(argv);
-    const [first, second, ...rest] = positional;
-    if (first === undefined || !OBJECTIVE_SUBCOMMANDS.includes(first)) {
-        return { subcommand: first, target: null, roots: positional.slice(1) };
-    }
-    const [campaign = "", objective] = (second ?? "").split("/");
-    const named = second !== undefined && ids.includes(campaign);
-    return {
-        subcommand: first,
-        target: named ? { campaign, objective: objective ?? null } : null,
-        roots: named ? rest : second === undefined ? [] : [second, ...rest],
-    };
-};
-// The one campaign, when there is one, else the one `--campaign` names.
-const campaignFor = (policy, argv) => {
-    const named = flagOf(argv, "--campaign");
-    if (named !== undefined) {
-        const found = campaignsOf(policy).campaignRules.find((rule) => rule.id === named);
-        return found === undefined
-            ? Result.fail(`no campaign is named "${named}"`)
-            : Result.succeed(found);
-    }
-    const [only] = campaignsOf(policy).campaignRules;
-    if (campaignsOf(policy).campaignRules.length === 1 && only !== undefined)
-        return Result.succeed(only);
-    return Result.fail(`this policy declares ${String(campaignsOf(policy).campaignRules.length)} campaigns; say which with --campaign <id>.`);
-};
-const objectiveFor = (rule, objective) => {
-    if (objective !== null) {
-        return rule.objectives.some((one) => one.id === objective)
-            ? Result.succeed(objective)
-            : Result.fail(`no objective of ${rule.id} is named "${objective}"`);
-    }
-    const [only] = rule.objectives;
-    if (rule.objectives.length === 1 && only !== undefined)
-        return Result.succeed(only.id);
-    return Result.fail(`campaign ${rule.id} declares ${String(rule.objectives.length)} objectives; say which as ${rule.id}/<objective>.`);
-};
-export const objectives = (policy, defaultRoots, argv) => Effect.gen(function* () {
-    const parsed = objectiveArgsOf(argv, campaignsOf(policy).campaignRules.map((rule) => rule.id));
-    const roots = parsed.roots.length > 0 ? parsed.roots : defaultRoots;
-    if (campaignsOf(policy).campaignRules.length === 0) {
-        return yield* report(["this policy declares no campaigns."]);
-    }
-    const evaluations = () => collectFindings(policy, roots).campaigns;
-    switch (parsed.subcommand) {
-        case "clear": {
-            const targets = parsed.target === null
-                ? campaignsOf(policy).campaignRules
-                : campaignsOf(policy).campaignRules.filter((rule) => rule.id === parsed.target?.campaign);
-            const by = authorOf(flagOf(argv, "--by")) ?? "unknown";
-            const all = evaluations();
-            const lines = [];
-            for (const rule of targets) {
-                const evaluation = all.find((one) => one.rule.id === rule.id);
-                if (evaluation === undefined)
-                    continue;
-                const only = parsed.target?.objective ?? null;
-                if (only !== null && !rule.objectives.some((one) => one.id === only)) {
-                    return yield* Effect.fail(fail(`no objective of ${rule.id} is named "${only}"`));
-                }
-                const outcomes = yield* Effect.try({
-                    try: () => clear(policy, evaluation, only, by),
-                    catch: (cause) => fail(String(cause)),
-                });
-                // Where each sector went, read off the ledgers as they stood: a
-                // clear of one objective places no sector, so it says nothing.
-                const moves = only === null ? sectorMovesOf(policy, evaluation) : [];
-                for (const outcome of outcomes) {
-                    const parts = [
-                        ...(outcome.entered.length > 0
-                            ? [
-                                `${count(outcome.entered.length, "sector")} entered (${outcome.entered.join(", ")})`,
-                            ]
-                            : []),
-                        ...(outcome.cleared > 0 ? [`${count(outcome.cleared, "holdout")} cleared`] : []),
-                        ...(outcome.rewritten > 0
-                            ? [`${count(outcome.rewritten, "holdout")} rewritten`]
-                            : []),
-                        ...(outcome.closed > 0 ? [`${count(outcome.closed, "holdout")} closed`] : []),
-                        ...(outcome.rebaselined.length > 0
-                            ? [
-                                `${count(outcome.rebaselined.length, "sector")} re-baselined (${outcome.rebaselined.join(", ")})`,
-                            ]
-                            : []),
-                    ];
-                    if (outcome.measure !== undefined) {
-                        const moved = [
-                            ...(outcome.entered.length > 0
-                                ? [
-                                    `${count(outcome.entered.length, "sector")} entered (${outcome.entered.join(", ")})`,
-                                ]
-                                : []),
-                            ...(outcome.measure.improved.length > 0
-                                ? [
-                                    `${count(outcome.measure.improved.length, "sector")} improved (${outcome.measure.improved
-                                        .map((one) => `${one.sector} ${String(one.from)} → ${String(one.to)}`)
-                                        .join(", ")})`,
-                                ]
-                                : []),
-                            ...(outcome.measure.grown.length > 0
-                                ? [
-                                    `${count(outcome.measure.grown.length, "sector")} grown (${outcome.measure.grown
-                                        .map((one) => `${one.sector} ${String(one.from)} → ${String(one.to)}, ${one.phase === null ? "measured, not held" : `as ${one.phase} expects`}`)
-                                        .join(", ")})`,
-                                ]
-                                : []),
-                            ...(outcome.closed > 0 ? [`${count(outcome.closed, "sector")} closed`] : []),
-                            ...(outcome.rebaselined.length > 0
-                                ? [
-                                    `${count(outcome.rebaselined.length, "sector")} re-baselined (${outcome.rebaselined.join(", ")})`,
-                                ]
-                                : []),
-                        ];
-                        lines.push(`${outcome.campaign}/${outcome.objective}: ${moved.length === 0 ? "nothing to clear" : moved.join(", ")}; held to ${String(outcome.measure.recorded)}.`);
-                        continue;
-                    }
-                    lines.push(`${outcome.campaign}/${outcome.objective}: ${parts.length === 0 ? "nothing to clear" : parts.join(", ")}; ${count(outcome.left, "holdout")} left.`);
-                }
-                for (const move of moves) {
-                    lines.push(`${move.campaign}: ${move.sector} ${move.back ? "went back" : "moved"} ${move.from ?? "done"} → ${move.to ?? "done"}` +
-                        (move.passed.length === 0
-                            ? "."
-                            : `, passing ${move.passed.join(", ")} in the same clear: nothing there was ever counted for it.`));
-                }
-            }
-            return yield* report(lines);
-        }
-        case "concede": {
-            if (parsed.target === null) {
-                return yield* Effect.fail(fail("objectives concede needs a campaign: `objectives concede <campaign>[/<objective>] --reason <text>`"));
-            }
-            const rule = campaignsOf(policy).campaignRules.find((one) => one.id === parsed.target?.campaign);
-            if (rule === undefined)
-                return yield* Effect.fail(fail(`no campaign is named "${parsed.target.campaign}"`));
-            const objective = objectiveFor(rule, parsed.target.objective);
-            if (Result.isFailure(objective))
-                return yield* Effect.fail(fail(objective.failure));
-            const reason = flagOf(argv, "--reason");
-            if (reason === undefined) {
-                return yield* Effect.fail(fail("objectives concede needs --reason <text>: growth is recorded with why, or not at all."));
-            }
-            const by = authorOf(flagOf(argv, "--by"));
-            if (by === null) {
-                return yield* Effect.fail(fail("objectives concede needs an author: pass --by <email>, or set git's user.email."));
-            }
-            const evaluation = evaluations().find((one) => one.rule.id === rule.id);
-            if (evaluation === undefined)
-                return yield* Effect.fail(fail(`campaign ${rule.id} was not evaluated`));
-            // `--holdouts` concedes a subset and refuses the rest: a pull
-            // request that legitimately adds one hit while another is an
-            // accident.
-            const chosen = (flagOf(argv, "--holdouts") ?? flagOf(argv, "--entries"))
-                ?.split(",")
-                .map((one) => one.trim()) ?? null;
-            const outcome = concede(policy, evaluation, objective.success, chosen, flagOf(argv, "--sector") ?? null, {
-                at: policy.now,
-                by,
-                reason,
-            });
-            if (Result.isFailure(outcome))
-                return yield* Effect.fail(fail(outcome.failure));
-            // A concession that sends a sector back a phase says so, and names
-            // the attestations it revoked on the way.
-            const sentBack = outcome.success.sentBack.flatMap((one) => [
-                "",
-                `this concession moves ${one.sector} back ${one.from ?? "done"} → ${one.to ?? "done"}.`,
-                ...(one.revoked.length === 0
-                    ? []
-                    : [
-                        `It revokes ${one.sector}'s attestation of ${one.revoked.join(", ")}: what was attested no longer holds. Once it does again, attest it anew:`,
-                        ...one.revoked.map((phase) => `  architecture campaigns attest ${one.sector} ${phase} --reason "…" --campaign ${rule.id}`),
-                    ]),
-            ]);
-            const scalar = rule.objectives.find((one) => one.id === objective.success)?.measure !== null;
-            if (scalar) {
-                if (outcome.success.conceded.length === 0) {
-                    return yield* report([
-                        `${rule.id}/${objective.success}: nothing to concede; no sector measures past its record.`,
-                    ]);
-                }
-                return yield* report([
-                    `${rule.id}/${objective.success}: a rise conceded in ${count(outcome.success.conceded.length, "sector")}, recorded by ${by}.`,
-                    ...outcome.success.conceded.map((one) => `  ${one.sector} · ${one.entry}`),
-                    ...(outcome.success.left.length === 0
-                        ? []
-                        : [
-                            "",
-                            `${count(outcome.success.left.length, "sector")} left past the record; check still fails on them.`,
-                        ]),
-                    ...sentBack,
-                ]);
-            }
-            if (outcome.success.conceded.length === 0) {
-                return yield* report([
-                    `${rule.id}/${objective.success}: nothing to concede; every hit is in the ledger.`,
-                ]);
-            }
-            return yield* report([
-                `${rule.id}/${objective.success}: ${count(outcome.success.conceded.length, "holdout")} conceded, recorded by ${by}.`,
-                ...outcome.success.conceded.map((one) => `  ${one.sector} · ${one.entry}`),
-                ...(outcome.success.left.length === 0
-                    ? []
-                    : [
-                        "",
-                        `${count(outcome.success.left.length, "hit")} left unrecorded; check still fails on them.`,
-                    ]),
-                ...sentBack,
-            ]);
-        }
-        default:
-            return yield* Effect.fail(fail(`unknown objectives subcommand "${parsed.subcommand ?? ""}". Try: objectives clear [<campaign>[/<objective>]] | objectives concede <campaign>[/<objective>] --reason <text> [--by <email>] [--sector <name>] [--holdouts a,b]`));
-    }
-});
-export const campaigns = (policy, defaultRoots, argv, configFilename) => Effect.gen(function* () {
-    const parsed = campaignArgsOf(argv, campaignsOf(policy).campaignRules.map((rule) => rule.id));
-    const roots = parsed.roots.length > 0 ? parsed.roots : defaultRoots;
-    if (campaignsOf(policy).campaignRules.length === 0) {
-        return yield* report(["this policy declares no campaigns."]);
-    }
-    const json = argv.includes("--json");
-    const retired = parsed.subcommand === undefined ? undefined : RETIRED[parsed.subcommand];
-    if (retired !== undefined)
-        return yield* Effect.fail(fail(retired));
-    // A positional that is no path is refused, not walked: most often it is
-    // a sector's name, and `--sector` is what asks about one.
-    for (const root of parsed.roots) {
-        if (existsSync(path.resolve(policy.repoRoot, root)))
-            continue;
-        const named = collectFindings(policy, defaultRoots).campaigns.some((one) => one.sectors.has(root));
-        return yield* Effect.fail(fail(`campaigns: ${root} is not a path in the repository, so there is nothing to walk there.` +
-            (named ? ` It names a sector: \`campaigns status --sector ${root}\`.` : "")));
-    }
-    const sector = flagOf(argv, "--sector");
-    if (parsed.subcommand === "status" && sector !== undefined) {
-        const only = argv.includes("--campaign") ? campaignFor(policy, argv) : null;
-        if (only !== null && Result.isFailure(only))
-            return yield* Effect.fail(fail(only.failure));
-        const views = collectFindings(policy, roots)
-            .campaigns.filter((one) => only === null || one.rule.id === only.success.id)
-            .flatMap((one) => {
-            const view = sectorViewOf(policy, one, sector);
-            return view === null ? [] : [view];
-        });
-        if (views.length === 0) {
-            return yield* Effect.fail(fail(`campaigns: no campaign under ${roots.join(", ")} has a sector named ${sector}.`));
-        }
-        return yield* report(json
-            ? [JSON.stringify({ version: 1, sectors: views }, null, 2)]
-            : views.flatMap((view, i) => [...(i === 0 ? [] : [""]), ...renderSectorView(view)]));
-    }
-    // `status` without `--changed` is the overview, in text or JSON: the
-    // nudge alone is scoped to a diff.
-    const subcommand = parsed.subcommand === "status" && !argv.includes("--changed") ? undefined : parsed.subcommand;
-    switch (subcommand) {
-        case undefined: {
-            const snapshot = snapshotOf(policy, roots, manifestPathOf(policy.repoRoot, configFilename));
-            if (json) {
-                // Each campaign as the conformance snapshot carries it: its
-                // burn-down, its ladder, and a row per sector.
-                return yield* report([
-                    JSON.stringify({ version: 1, campaigns: snapshot.campaigns }, null, 2),
-                ]);
-            }
-            return yield* report([
-                `${count(snapshot.campaigns.length, "campaign")} under ${roots.join(", ")}`,
-                "",
-                ...renderCampaignRows(snapshot.campaigns),
-                "",
-                "  architecture campaigns status --changed [--base <ref>] [--json]   # what a diff touches, and what to do",
-                "  architecture campaigns status --sector <sector> [--json]          # where one sector stands, and what holds it",
-                "  architecture objectives clear [<campaign>[/<objective>]]        # reconcile the ledgers with the code",
-                '  architecture objectives concede <campaign>[/<objective>] --reason "<why>"   # record why a count may rise',
-                '  architecture campaigns attest <sector> <phase> --reason "<why>" [--evidence <url>]',
-                '  architecture campaigns note <sector> "<text>"',
-                "  architecture campaigns history [<campaign>] [--since <ref>]",
-            ]);
-        }
-        case "status": {
-            const base = flagOf(argv, "--base") ?? null;
-            const diff = yield* Effect.try({
-                try: () => readDiff(policy.repoRoot, base),
-                catch: (cause) => fail(`could not read the diff: ${String(cause)}`),
-            });
-            const current = collectFindings(policy, roots).campaigns;
-            const baseSide = base === null
-                ? null
-                : yield* Effect.tryPromise({
-                    try: () => baseSideAt(policy, base, roots, (repoRoot) => loadPolicyFromFile(repoRoot, configFilename)),
-                    catch: (cause) => fail(`could not evaluate the base tree at ${base}: ${String(cause)}`),
-                });
-            // The ledger mode's "before" for work done ahead of the plan is the
-            // HEAD tree, evaluated once per commit and cached: no ledger counts
-            // the holdouts of a phase a sector has not entered.
-            const headTree = base !== null || !current.some((one) => one.rule.phases.length > 0)
-                ? null
-                : yield* Effect.tryPromise({
-                    try: () => baseSideAt(policy, "HEAD", roots, (repoRoot) => loadPolicyFromFile(repoRoot, configFilename)),
-                    catch: (cause) => fail(`could not evaluate the tree at HEAD: ${String(cause)}`),
-                });
-            const hotfix = flagOf(argv, "--hotfix") ?? null;
-            const nudge = nudgeOf(policy, current, diff, baseSide, hotfix, hotfix === null ? null : authorOf(flagOf(argv, "--by")), headTree);
-            yield* report(json ? [JSON.stringify(nudge, null, 2)] : renderNudge(nudge, policy.now));
-            if (!nudge.ok) {
-                const ahead = nudge.sectors.some((one) => one.verdict === "ahead");
-                const back = nudge.sectors.some((one) => one.verdict !== "ok" && one.verdict !== "ahead" && one.verdict !== "hotfix");
-                return yield* Effect.fail(fail([
-                    ...(back ? ["the diff sends a sector back under its onTouch"] : []),
-                    ...(ahead ? ["the diff works ahead of a sector's phase under its onAhead"] : []),
-                ].join("; ")));
-            }
-            return;
-        }
-        case "attest": {
-            const [sector, phase] = parsed.args;
-            if (sector === undefined || phase === undefined) {
-                return yield* Effect.fail(fail('campaigns attest needs a sector and a phase: `campaigns attest <sector> <phase> --reason "<why>"`'));
-            }
-            const reason = flagOf(argv, "--reason");
-            if (reason === undefined)
-                return yield* Effect.fail(fail("campaigns attest needs --reason <text>."));
-            const by = authorOf(flagOf(argv, "--by"));
-            if (by === null)
-                return yield* Effect.fail(fail("campaigns attest needs an author: pass --by <email>, or set git's user.email."));
-            const rule = campaignFor(policy, argv);
-            if (Result.isFailure(rule))
-                return yield* Effect.fail(fail(rule.failure));
-            const evaluation = collectFindings(policy, roots).campaigns.find((one) => one.rule.id === rule.success.id);
-            if (evaluation === undefined)
-                return yield* Effect.fail(fail(`campaign ${rule.success.id} was not evaluated`));
-            const written = attest(policy, evaluation, sector, phase, {
-                reason,
-                evidence: flagOf(argv, "--evidence"),
-                by,
-            });
-            if (Result.isFailure(written))
-                return yield* Effect.fail(fail(written.failure));
-            return yield* report([
-                `${rule.success.id}: sector ${sector} attested at ${phase} by ${by}, in ${written.success}.`,
-                "Run `objectives clear` to move it on.",
-            ]);
-        }
-        case "note": {
-            const [sector, text] = parsed.args;
-            if (sector === undefined || text === undefined) {
-                return yield* Effect.fail(fail('campaigns note needs a sector and a text: `campaigns note <sector> "<text>"`'));
-            }
-            const by = authorOf(flagOf(argv, "--by"));
-            if (by === null)
-                return yield* Effect.fail(fail("campaigns note needs an author: pass --by <email>, or set git's user.email."));
-            const rule = campaignFor(policy, argv);
-            if (Result.isFailure(rule))
-                return yield* Effect.fail(fail(rule.failure));
-            const evaluation = collectFindings(policy, roots).campaigns.find((one) => one.rule.id === rule.success.id);
-            if (evaluation === undefined)
-                return yield* Effect.fail(fail(`campaign ${rule.success.id} was not evaluated`));
-            const written = note(policy, evaluation, sector, text, by);
-            if (Result.isFailure(written))
-                return yield* Effect.fail(fail(written.failure));
-            return yield* report([
-                `${rule.success.id}: note left on ${sector}, in ${written.success}.`,
-            ]);
-        }
-        case "history": {
-            const [named] = parsed.args;
-            const targets = named === undefined
-                ? campaignsOf(policy).campaignRules
-                : campaignsOf(policy).campaignRules.filter((rule) => rule.id === named);
-            const manifestPath = path
-                .relative(policy.repoRoot, manifestPathOf(policy.repoRoot, configFilename))
-                .replaceAll(path.sep, "/");
-            const lines = [];
-            for (const rule of targets) {
-                const rows = historyOf(policy, rule, flagOf(argv, "--since") ?? null, [manifestPath]);
-                if (json) {
-                    lines.push(JSON.stringify({ campaign: rule.id, rows }, null, 2));
-                    continue;
-                }
-                if (lines.length > 0)
-                    lines.push("");
-                for (const line of renderHistory(rule, rows))
-                    lines.push(line);
-            }
-            return yield* report(lines);
-        }
-        case "clear":
-        case "concede":
-            // The ledger verbs answer under `objectives`; accepted here too.
-            return yield* objectives(policy, defaultRoots, argv);
-        default:
-            return yield* Effect.fail(fail(`unknown campaigns subcommand "${parsed.subcommand}". Try: campaigns | campaigns status --changed | campaigns attest <sector> <phase> --reason <text> | campaigns note <sector> "<text>" | campaigns history [<campaign>]`));
-    }
+// The campaign commands, answered by the family the host was composed with:
+// `campaigns` alone is the status table, `status --changed` the nudge,
+// `attest` and `note` write a sector's record, `history` replays the ledgers;
+// `objectives clear` and `objectives concede` write the ledgers. Without
+// `@goodbones/campaigns` installed, each says what to install.
+const verbContext = (policy, defaultRoots, argv, configFilename) => ({
+    policy,
+    defaultRoots,
+    argv,
+    evaluate: (roots) => collectFindings(policy, roots).campaigns,
+    reload: (repoRoot) => loadPolicyFromFile(repoRoot, configFilename),
+    manifestPath: manifestPathOf(policy.repoRoot, configFilename),
 });
+export const objectives = (policy, defaultRoots, argv) => policy.campaigns.objectives(verbContext(policy, defaultRoots, argv));
+export const campaigns = (policy, defaultRoots, argv, configFilename) => policy.campaigns.campaigns(verbContext(policy, defaultRoots, argv, configFilename));
 // The commands that judge a campaign, and so ask its report source.
 const READS_REPORTS = new Set([
     "check",
@@ -1393,7 +877,7 @@ configFilename) => Effect.gen(function* () {
     // for the campaign to report; a report that does not parse is refused.
     if (READS_REPORTS.has(command)) {
         yield* Effect.tryPromise({
-            try: () => Promise.all(reportSpecsOf(campaignsOf(policy).campaignRules).map((spec) => campaignsOf(policy).reports.read?.(spec))),
+            try: () => policy.campaigns.readReports(policy),
             catch: (cause) => fail(String(cause)),
         });
     }