@goodbones/campaigns 0.1.1-beta.1 → 0.1.1-beta.3

package/build/esm/host/campaigns.js

@@ -1,16 +1,17 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
-import { compileExportRules, compileImportRules, compileMemberRules, compileStructure, compileSurfaceRules, evaluateMemberSite, evaluateResolvedEdge, evaluateSelectedBindings, evaluateStructure, evaluateSurface, exportRulesSelecting, globToRegExp, listSourceFiles, listWorkspaceProjects, memberRulesSelecting, rulesSelecting, surfaceRulesSelecting, } from "@goodbones/core";
+import { breaches, compileExportRules, compileImportRules, compileMemberRules, compileStructure, compileSurfaceRules, evaluateMemberSite, evaluateResolvedEdge, evaluateSelectedBindings, evaluateStructure, evaluateSurface, exportRulesSelecting, globToRegExp, listSourceFiles, listWorkspaceProjects, memberRulesSelecting, rulesSelecting, surfaceRulesSelecting, } from "@goodbones/core";
 import * as Result from "effect/Result";
 import { evaluateCampaign, hitsInWindow, towardNextOf, } from "../core/campaign-state.js";
-import { detectorOf, needsSyntax, } from "../core/campaigns.js";
-import { attestedRecord, clearedSector, concededSector, EMPTY_LEDGER, EMPTY_SECTOR_RECORD, isComplete, isStalled, lastClearedOf, ledgerArithmeticHolds, ledgerPathOf, notedRecord, planDiffOf, planOf, planPathOf, progressOf, reachedRecord, rebaselinedSector, reconcileSector, sectorArithmeticHolds, sectorClockOf, sectorRecordPathOf, serializeLedger, serializePlanRecord, serializeSectorRecord, } from "../core/ledger.js";
+import { detectorOf, distanceToTarget, measureDetectorsOf, needsSyntax, } from "../core/campaigns.js";
+import { attestedRecord, clearedMeasure, clearedSector, concededMeasure, concededSector, EMPTY_LEDGER, EMPTY_MEASURE_LEDGER, EMPTY_SECTOR_RECORD, isComplete, isStalled, lastClearedOf, lastImprovedOf, ledgerArithmeticHolds, ledgerPathOf, measureLedgerArithmeticHolds, measureProgressOf, measureStandingOf, notedRecord, planDiffOf, planOf, planPathOf, progressOf, reachedRecord, rebaselinedSector, reconcileSector, recordedOf, sectorArithmeticHolds, sectorClockOf, sectorRecordPathOf, serializeLedger, serializeMeasureLedger, serializePlanRecord, serializeSectorRecord, } from "../core/ledger.js";
 import { compareResidue, isDefinedPhase, isOpenPhase, onTouchOf, worsened, } from "../core/phases.js";
 import { LEGACY_SECTOR, parseSectorMarker } from "../core/sectors.js";
 import { campaignsOf, ledgerKeyOf } from "../load/extension.js";
 import { lowerEndState } from "../manifest/lower.js";
 import { commitOf, commitsTouching, distanceToHunks, gitEnv, materializeTree, readDiff, textAt, } from "./diff.js";
+import { commandValues } from "./measure-command.js";
 // The files a campaign sees: those in its scope with an extension a pack
 // walks, or one the campaign's scope widens the walk to.
 const filesFor = (policy, rule, files) => {
@@ -123,11 +124,12 @@ export const evaluateCampaigns = (policy, roots, files, readers = readersOf(poli
     const projects = campaignsOf(policy).campaignRules.some((rule) => rule.perimeter?.kind === "nx")
         ? listWorkspaceProjects(policy.repoRoot, roots)
         : [];
+    const commandValueOf = commandValues(policy.repoRoot);
     return campaignsOf(policy).campaignRules.map((rule) => {
         const detectors = [
             ...rule.objectives.flatMap((one) => {
                 const detect = detectorOf(one);
-                return detect === null ? [] : [detect];
+                return [...(detect === null ? [] : [detect]), ...measureDetectorsOf(one)];
             }),
             ...(rule.perimeter?.kind === "match" ? [rule.perimeter.detect] : []),
         ];
@@ -152,6 +154,7 @@ export const evaluateCampaigns = (policy, roots, files, readers = readersOf(poli
             globToRegExp,
             projects,
             recordOf: (sector) => campaignsOf(policy).sectorRecords.get(ledgerKeyOf(rule.id, sector)),
+            commandValueOf,
         };
         if (!rule.objectives.some((one) => one.endState !== null))
             return evaluateCampaign(rule, input);
@@ -177,6 +180,9 @@ export const evaluateCampaigns = (policy, roots, files, readers = readersOf(poli
     });
 };
 const ledgerOf = (policy, rule, objective) => campaignsOf(policy).ledgers.get(ledgerKeyOf(rule.id, objective.id));
+const measureLedgerOf = (policy, rule, objective) => campaignsOf(policy).measureLedgers.get(ledgerKeyOf(rule.id, objective.id));
+// How a scalar reads in a line: its value, and against what.
+const describeValue = (value) => Number.isNaN(value) ? "no number" : String(value);
 const recordOf = (policy, rule, sector) => campaignsOf(policy).sectorRecords.get(ledgerKeyOf(rule.id, sector));
 const phaseIdOf = (rule, phase) => rule.phases[phase]?.id ?? null;
 const entriesOf = (hits, objective, sector) => hits
@@ -189,7 +195,113 @@ export const campaignReportsOf = (policy, evaluations) => evaluations.map((evalu
     const { rule } = evaluation;
     const counted = hitsInWindow(evaluation);
     let missingLedger = false;
+    const unmeasured = [];
+    const scalarNew = [];
+    const scalarStale = [];
+    // A scalar objective, reconciled per sector against its ledger. A value
+    // worse than the record past the tolerance is growth `concede` records;
+    // better past it, progress `clear` records — each a line of the same
+    // `new` and `stale` lists a holdout lands in, so `check` fails on them
+    // for the same reasons and says the same next step.
+    const scalarReport = (objective) => {
+        const ledger = measureLedgerOf(policy, rule, objective);
+        const sectors = [];
+        let value = 0;
+        let recorded = 0;
+        let measuredAll = true;
+        let recordedAll = true;
+        for (const name of sectorNames(evaluation)) {
+            const state = evaluation.sectors.get(name);
+            if (state === undefined)
+                continue;
+            const measured = state.values[objective.id] ?? Number.NaN;
+            const own = ledger?.sectors[name];
+            if (!state.inWindow.some((one) => one.id === objective.id)) {
+                // Past the window: a record still open is closed by `clear`.
+                if (own?.closed === null) {
+                    scalarStale.push({
+                        objective: objective.id,
+                        sector: name,
+                        entry: `left the window at ${describeValue(measured)}`,
+                    });
+                }
+                continue;
+            }
+            if (Number.isNaN(measured)) {
+                measuredAll = false;
+                unmeasured.push({ objective: objective.id, sector: name });
+            }
+            else
+                value += measured;
+            if (ledger === undefined || own === undefined || own.closed !== null) {
+                missingLedger = true;
+                recordedAll = false;
+                sectors.push({
+                    sector: name,
+                    count: 0,
+                    new: [],
+                    stale: [],
+                    drifted: 0,
+                    unrecorded: true,
+                    arithmetic: true,
+                    measure: {
+                        value: Number.isNaN(measured) ? null : measured,
+                        recorded: null,
+                        standing: Number.isNaN(measured) ? "unmeasured" : "unrecorded",
+                    },
+                });
+                continue;
+            }
+            recorded += own.recorded;
+            const standing = Number.isNaN(measured)
+                ? "unmeasured"
+                : measureStandingOf(ledger, name, measured, objective.tolerance);
+            const line = `measured ${describeValue(measured)}, recorded ${String(own.recorded)}`;
+            if (standing === "breached") {
+                scalarNew.push({ objective: objective.id, sector: name, entry: line });
+            }
+            if (standing === "surpassed") {
+                scalarStale.push({ objective: objective.id, sector: name, entry: line });
+            }
+            sectors.push({
+                sector: name,
+                count: 0,
+                new: standing === "breached" ? [line] : [],
+                stale: standing === "surpassed" ? [line] : [],
+                drifted: 0,
+                unrecorded: false,
+                arithmetic: measureLedgerArithmeticHolds(ledger),
+                measure: {
+                    value: Number.isNaN(measured) ? null : measured,
+                    recorded: own.recorded,
+                    standing,
+                },
+            });
+        }
+        // Sectors the ledger records that the code no longer births: closed
+        // on the next `clear`, stale until then.
+        for (const [name, own] of Object.entries(ledger?.sectors ?? {})) {
+            if (evaluation.sectors.has(name) || own.closed !== null)
+                continue;
+            scalarStale.push({ objective: objective.id, sector: name, entry: "no longer a sector" });
+        }
+        return {
+            id: objective.id,
+            count: 0,
+            ledgered: ledger !== undefined,
+            sectors,
+            measure: {
+                direction: objective.direction,
+                value: measuredAll ? value : null,
+                recorded: recordedAll ? recorded : null,
+                target: objective.target,
+                tolerance: objective.tolerance,
+            },
+        };
+    };
     const objectives = rule.objectives.map((objective) => {
+        if (objective.measure !== null)
+            return scalarReport(objective);
         const ledger = ledgerOf(policy, rule, objective);
         const sectors = [];
         for (const name of sectorNames(evaluation)) {
@@ -271,6 +383,19 @@ export const campaignReportsOf = (policy, evaluations) => evaluations.map((evalu
         const ledger = ledgerOf(policy, rule, objective);
         return ledger === undefined ? [] : [ledger];
     });
+    const measureLedgers = rule.objectives.flatMap((objective) => {
+        const ledger = measureLedgerOf(policy, rule, objective);
+        return ledger === undefined ? [] : [{ objective, ledger }];
+    });
+    // A targeted scalar is met in every sector in window when its distance
+    // is 0 there; a standing one never holds a campaign open.
+    const scalarsMet = rule.objectives
+        .filter((objective) => objective.measure !== null && objective.target !== null)
+        .every((objective) => [...evaluation.sectors.values()].every((state) => !state.inWindow.some((one) => one.id === objective.id) ||
+        (state.counts[objective.id] ?? 0) === 0));
+    const scalarsOpen = measureLedgers.filter(({ objective }) => objective.target !== null &&
+        [...evaluation.sectors.values()].some((state) => state.inWindow.some((one) => one.id === objective.id) &&
+            (state.counts[objective.id] ?? 0) > 0));
     const sectorClock = [...evaluation.sectors.keys()]
         .map((name) => recordOf(policy, rule, name))
         .filter((one) => one !== undefined)
@@ -280,14 +405,23 @@ export const campaignReportsOf = (policy, evaluations) => evaluations.map((evalu
     return {
         id: rule.id,
         count,
-        new: flat((one) => one.new),
-        stale: flat((one) => one.stale),
+        new: [
+            ...flat((one) => (one.measure === undefined ? one.new : [])),
+            ...scalarNew,
+        ],
+        stale: [
+            ...flat((one) => (one.measure === undefined ? one.stale : [])),
+            ...scalarStale,
+        ],
         drifted: objectives.reduce((sum, one) => sum + one.sectors.reduce((inner, two) => inner + two.drifted, 0), 0),
         missingLedger,
-        arithmetic: ledgers.every(ledgerArithmeticHolds),
-        complete: count === 0 && ledgers.every(isComplete),
-        stalled: ledgers.length > 0 &&
-            ledgers.some((ledger) => isStalled(rule, ledger, policy.now, sectorClock)),
+        unmeasured,
+        arithmetic: ledgers.every(ledgerArithmeticHolds) &&
+            measureLedgers.every(({ ledger }) => measureLedgerArithmeticHolds(ledger)),
+        complete: count === 0 && ledgers.every(isComplete) && scalarsMet && unmeasured.length === 0,
+        stalled: (ledgers.length > 0 &&
+            ledgers.some((ledger) => isStalled(rule, ledger, policy.now, sectorClock))) ||
+            scalarsOpen.some(({ ledger }) => isMeasureStalled(rule, ledger, policy.now, sectorClock)),
         onComplete: rule.onComplete,
         objectives,
         sectors: [...evaluation.sectors.values()].map((state) => ({
@@ -301,6 +435,17 @@ export const campaignReportsOf = (policy, evaluations) => evaluations.map((evalu
         plan: planDiffOf(rule, campaignsOf(policy).plans.get(rule.id)),
     };
 });
+// A scalar short of its target is stalled when its record has not improved,
+// and no sector has been attested or noted, within the campaign's
+// `staleAfter`.
+const isMeasureStalled = (rule, ledger, now, sectorClock) => {
+    if (rule.staleAfter === null)
+        return false;
+    const last = [lastImprovedOf(ledger), sectorClock]
+        .filter((one) => one !== null)
+        .reduce((a, b) => (a > b ? a : b), ledger.created);
+    return now - Date.parse(last) > rule.staleAfter;
+};
 // Which hits in window are carried by a ledger, exactly or by anchor.
 export const ledgeredFilter = (policy, evaluations) => {
     const carried = new Set();
@@ -330,6 +475,9 @@ export const campaignFailuresOf = (campaigns) => [
     ...campaigns
         .filter((one) => one.plan.unreceipted.length > 0)
         .map((one) => `campaign ${one.id}: a defined phase changed without a concession`),
+    ...campaigns
+        .filter((one) => one.unmeasured.length > 0)
+        .map((one) => `campaign ${one.id}: a scalar objective measured no number`),
     ...campaigns.filter((one) => one.stale.length > 0).map(() => "stale ledger entries"),
     ...campaigns.filter((one) => !one.arithmetic).map(() => "ledger arithmetic does not hold"),
     ...campaigns.filter((one) => one.missingLedger).map((one) => `campaign ${one.id} has no ledger`),
@@ -358,10 +506,16 @@ export const renderCampaignReports = (reports, hits) => reports.flatMap((campaig
     }
     if (campaign.missingLedger) {
         const unrecorded = campaign.objectives.flatMap((objective) => objective.sectors
-            .filter((one) => one.unrecorded && (one.count > 0 || objective.ledgered))
-            .map((one) => `  ${objective.id} · ${one.sector}  (${count(one.count, "hit")})`));
+            .filter((one) => one.unrecorded &&
+            (one.count > 0 || objective.ledgered || one.measure !== undefined))
+            .map((one) => `  ${objective.id} · ${one.sector}  (${one.measure === undefined
+            ? count(one.count, "hit")
+            : `measures ${one.measure.value === null ? "no number" : String(one.measure.value)}`})`));
         say("", `campaign ${campaign.id}: ${count(unrecorded.length, "sector")} in an objective's window that no ledger has seen. Record them before they count as growth:`, ...unrecorded, "", `  architecture objectives clear ${campaign.id}`);
     }
+    if (campaign.unmeasured.length > 0) {
+        say("", `campaign ${campaign.id}: ${count(campaign.unmeasured.length, "sector")} where a scalar objective measured no number — a function that answered something other than a number of zero or more, or a command that did not run or printed none:`, ...campaign.unmeasured.map((one) => `  ${one.objective} · ${one.sector}`));
+    }
     if (campaign.new.length > 0 && !campaign.missingLedger) {
         say("", `campaign ${campaign.id}: ${count(campaign.new.length, "new hit")} the ledger does not carry. Fix them, or record why the count may rise:`, ...campaign.new.flatMap((one) => {
             const hit = hits.find((two) => two.objective === one.objective &&
@@ -377,7 +531,7 @@ export const renderCampaignReports = (reports, hits) => reports.flatMap((campaig
         say("", `campaign ${campaign.id}: ${count(campaign.stale.length, "ledger entry", "ledger entries")} no longer fire, or fire past their window. The code was fixed, or the sector moved on; clear them:`, ...campaign.stale.map((one) => at(one.objective, one.sector, one.entry)), "", `  architecture objectives clear ${campaign.id}`);
     }
     if (!campaign.arithmetic) {
-        say("", `campaign ${campaign.id}: a ledger does not add up (holdouts ≠ initial + conceded − cleared − closed). A holdout was added by hand; remove it, or record it with \`objectives concede\`.`);
+        say("", `campaign ${campaign.id}: a ledger does not add up (holdouts ≠ initial + conceded − cleared − closed; for a scalar, recorded ≠ initial + risen − improved). The ledger was edited by hand; restore it, or record the change with \`objectives concede\`.`);
     }
     const complete = campaign.complete && !campaign.missingLedger;
     if (complete && campaign.onComplete === "remove") {
@@ -405,10 +559,39 @@ export const snapshotCampaignsOf = (policy, evaluations) => campaignReportsOf(po
         throw new Error("report without evaluation");
     const { rule } = evaluation;
     const ledgers = rule.objectives.map((objective) => ledgerOf(policy, rule, objective));
+    const scalar = new Set(rule.objectives.filter((one) => one.measure !== null).map((one) => one.id));
     const objectives = rule.objectives.map((objective, j) => {
         const ledger = ledgers[j];
         const own = report.objectives[j];
         const phase = rule.phases.find((one) => one.objectives.includes(objective.id))?.id ?? null;
+        if (objective.measure !== null) {
+            // A scalar: the holdout counts are all 0, and the number is under
+            // `measure`. Met when every sector in window is at its target.
+            const measured = measureLedgerOf(policy, rule, objective);
+            const met = objective.target !== null &&
+                (own?.sectors ?? []).every((one) => (evaluation.sectors.get(one.sector)?.counts[objective.id] ?? 1) === 0);
+            return {
+                id: objective.id,
+                phase,
+                initial: 0,
+                allowed: 0,
+                count: 0,
+                cleared: 0,
+                closed: 0,
+                progress: measured === undefined ? 0 : measureProgressOf(measured, objective.target),
+                lastCleared: measured === undefined ? null : lastImprovedOf(measured),
+                concessions: measured?.concessions.length ?? 0,
+                complete: met,
+                ledgered: measured !== undefined,
+                measure: {
+                    direction: objective.direction,
+                    value: own?.measure?.value ?? 0,
+                    recorded: own?.measure?.recorded ?? (measured === undefined ? 0 : recordedOf(measured)),
+                    target: objective.target,
+                    tolerance: objective.tolerance,
+                },
+            };
+        }
         if (ledger === undefined) {
             return {
                 id: objective.id,
@@ -481,13 +664,19 @@ export const snapshotCampaignsOf = (policy, evaluations) => campaignReportsOf(po
         }),
         legacy: {
             files: evaluation.index.legacy.length,
-            holdouts: legacy === undefined ? 0 : Object.values(legacy.residue).reduce((a, b) => a + b, 0),
+            holdouts: legacy === undefined
+                ? 0
+                : Object.entries(legacy.residue)
+                    .filter(([id]) => !scalar.has(id))
+                    .reduce((a, [, n]) => a + n, 0),
         },
         plan: report.plan,
         stalled: report.stalled,
         complete: report.complete,
         onComplete: rule.onComplete,
-        ledgered: ledgers.every((one) => one !== undefined),
+        ledgered: rule.objectives.every((objective, j) => objective.measure === null
+            ? ledgers[j] !== undefined
+            : measureLedgerOf(policy, rule, objective) !== undefined),
     };
 });
 const percent = (fraction) => `${String(Math.round(fraction * 100))}%`;
@@ -515,10 +704,16 @@ export const renderCampaignRows = (campaigns) => {
                         .join(" → ")}` +
                         (one.legacy.files > 0 ? `  · legacy ${count(one.legacy.files, "file")}` : ""),
                 ]),
-            ...one.objectives.map((objective) => `    ${objective.id.padEnd(width)}  ${percent(objective.progress).padStart(4)}  ${String(objective.count).padStart(5)} left` +
-                `  ${String(objective.cleared)} cleared  ${String(objective.allowed)} conceded` +
-                (objective.closed > 0 ? `  ${String(objective.closed)} closed` : "") +
-                (objective.ledgered ? "" : "  no ledger")),
+            ...one.objectives.map((objective) => objective.measure !== undefined
+                ? `    ${objective.id.padEnd(width)}  ${percent(objective.progress).padStart(4)}  measures ${String(objective.measure.value)}, held to ${String(objective.measure.recorded)}` +
+                    (objective.measure.target === null
+                        ? ""
+                        : `, target ${String(objective.measure.target)}`) +
+                    (objective.ledgered ? "" : "  no ledger")
+                : `    ${objective.id.padEnd(width)}  ${percent(objective.progress).padStart(4)}  ${String(objective.count).padStart(5)} left` +
+                    `  ${String(objective.cleared)} cleared  ${String(objective.allowed)} conceded` +
+                    (objective.closed > 0 ? `  ${String(objective.closed)} closed` : "") +
+                    (objective.ledgered ? "" : "  no ledger")),
         ];
     });
 };
@@ -550,6 +745,80 @@ export const authorOf = (given) => {
     const fromEnvironment = process.env.GIT_AUTHOR_EMAIL;
     return fromEnvironment === undefined || fromEnvironment === "" ? null : fromEnvironment;
 };
+// `clear` for a scalar objective: a sector entering the window is recorded
+// at its value; one inside it whose value improved past the tolerance is
+// held to that value from now; one past it, or no longer born, is closed;
+// and a receipted phase change re-baselines the sectors in window to what
+// they measure, with a concession. A rise is left where it is.
+const clearMeasure = (policy, evaluation, objective, receipted, by) => {
+    const { rule } = evaluation;
+    const existing = measureLedgerOf(policy, rule, objective);
+    const before = existing ?? EMPTY_MEASURE_LEDGER(rule.id, objective.id, objective.direction, policy.now);
+    let ledger = before;
+    const entered = [];
+    const rebaselined = [];
+    const improved = [];
+    let closed = 0;
+    for (const [name, state] of evaluation.sectors) {
+        const value = state.values[objective.id] ?? Number.NaN;
+        const own = ledger.sectors[name];
+        if (!state.inWindow.some((one) => one.id === objective.id)) {
+            const next = clearedMeasure(ledger, name, value, objective.tolerance, policy.now, "outside");
+            if (next !== ledger)
+                closed += 1;
+            ledger = next;
+            continue;
+        }
+        if (own === undefined || own.closed !== null) {
+            const next = clearedMeasure(ledger, name, value, objective.tolerance, policy.now, "inside", by);
+            if (next !== ledger)
+                entered.push(name);
+            ledger = next;
+            continue;
+        }
+        if (receipted !== null) {
+            const next = concededMeasure(ledger, name, value, {
+                at: policy.now,
+                by,
+                reason: `phase ${receipted.id} changed: ${receipted.concessions.at(-1)?.reason ?? ""}`,
+            });
+            if (next !== ledger)
+                rebaselined.push(name);
+            ledger = next;
+            continue;
+        }
+        const next = clearedMeasure(ledger, name, value, objective.tolerance, policy.now, "inside");
+        if (next !== ledger) {
+            improved.push({
+                sector: name,
+                from: own.recorded,
+                to: next.sectors[name]?.recorded ?? own.recorded,
+            });
+        }
+        ledger = next;
+    }
+    // Sectors the code no longer births are past every window.
+    for (const [name, own] of Object.entries(ledger.sectors)) {
+        if (evaluation.sectors.has(name) || own.closed !== null)
+            continue;
+        ledger = clearedMeasure(ledger, name, own.recorded, objective.tolerance, policy.now, "outside");
+        closed += 1;
+    }
+    if (ledger !== before || existing === undefined) {
+        writeJson(policy.repoRoot, ledgerPathOf(campaignsOf(policy).ledgerDir, rule.id, objective.id), serializeMeasureLedger(ledger));
+    }
+    return {
+        campaign: rule.id,
+        objective: objective.id,
+        cleared: 0,
+        rewritten: 0,
+        closed,
+        entered,
+        rebaselined,
+        left: 0,
+        measure: { improved, recorded: recordedOf(ledger) },
+    };
+};
 // `clear`: the ledger reconciled with the code wherever that is not a
 // regression. Stale holdouts leave and drifted ones are rewritten; a sector
 // newly in an objective's window is recorded with its initial; a sector
@@ -565,15 +834,19 @@ export const clear = (policy, evaluation, only, by) => {
     for (const objective of rule.objectives) {
         if (only !== null && objective.id !== only)
             continue;
-        const before = ledgerOf(policy, rule, objective) ?? EMPTY_LEDGER(rule.id, objective.id, policy.now);
-        let ledger = before;
-        const entered = [];
-        const rebaselined = [];
         const phase = rule.phases.find((one) => one.objectives.includes(objective.id));
         // The phase naming the objective, when it changed with a receipt.
         const receipted = phase !== undefined && plan.changed.includes(phase.id) && !plan.unreceipted.includes(phase.id)
             ? phase
             : null;
+        if (objective.measure !== null) {
+            outcomes.push(clearMeasure(policy, evaluation, objective, receipted, by));
+            continue;
+        }
+        const before = ledgerOf(policy, rule, objective) ?? EMPTY_LEDGER(rule.id, objective.id, policy.now);
+        let ledger = before;
+        const entered = [];
+        const rebaselined = [];
         let rewritten = 0;
         for (const [name, state] of evaluation.sectors) {
             const inWindow = state.inWindow.some((one) => one.id === objective.id);
@@ -645,6 +918,12 @@ export const concede = (policy, evaluation, objectiveId, chosen, sector, record)
     const objective = rule.objectives.find((one) => one.id === objectiveId);
     if (objective === undefined)
         return Result.fail(`no objective of ${rule.id} is named "${objectiveId}"`);
+    if (objective.measure !== null) {
+        if (chosen !== null) {
+            return Result.fail(`${rule.id}/${objectiveId} is a scalar objective: it has no holdouts to choose among. Narrow with --sector.`);
+        }
+        return concedeMeasure(policy, evaluation, objective, sector, record);
+    }
     let ledger = ledgerOf(policy, rule, objective);
     if (ledger === undefined) {
         return Result.fail(`objective ${rule.id}/${objectiveId} has no ledger yet; run \`objectives clear ${rule.id}\` first.`);
@@ -684,6 +963,41 @@ export const concede = (policy, evaluation, objectiveId, chosen, sector, record)
         left: unrecorded.filter((one) => !wanted.includes(one)),
     });
 };
+// `concede` for a scalar objective: each sector in window whose value is
+// worse than its record past the tolerance is held to its value from now,
+// with a concession naming the reason and the author. A sector the ledger
+// has not recorded is `clear`'s to enter first.
+const concedeMeasure = (policy, evaluation, objective, sector, record) => {
+    const { rule } = evaluation;
+    let ledger = measureLedgerOf(policy, rule, objective);
+    if (ledger === undefined) {
+        return Result.fail(`objective ${rule.id}/${objective.id} has no ledger yet; run \`objectives clear ${rule.id}\` first.`);
+    }
+    const conceded = [];
+    const left = [];
+    for (const [name, state] of evaluation.sectors) {
+        if (!state.inWindow.some((one) => one.id === objective.id))
+            continue;
+        const value = state.values[objective.id] ?? Number.NaN;
+        const standing = Number.isNaN(value)
+            ? "unmeasured"
+            : measureStandingOf(ledger, name, value, objective.tolerance);
+        if (standing !== "breached")
+            continue;
+        const from = ledger.sectors[name]?.recorded ?? value;
+        const entry = `${String(from)} → ${String(value)}`;
+        if (sector !== null && name !== sector) {
+            left.push({ sector: name, entry });
+            continue;
+        }
+        ledger = concededMeasure(ledger, name, value, record);
+        conceded.push({ sector: name, entry });
+    }
+    if (conceded.length > 0) {
+        writeJson(policy.repoRoot, ledgerPathOf(campaignsOf(policy).ledgerDir, rule.id, objective.id), serializeMeasureLedger(ledger));
+    }
+    return Result.succeed({ objective: objective.id, conceded, left });
+};
 // `attest`: a step no detector sees is recorded done for a sector — with a
 // reason and evidence — and only while the sector stands at that phase, so
 // it cannot be recorded ahead and passed through on arrival.
@@ -738,6 +1052,11 @@ export const baseSideOf = (evaluations) => evaluations.map((evaluation) => ({
         objective: hit.objective,
         entry: hit.entry,
     })),
+    // `NaN` does not survive the JSON cache; `null` is "no number".
+    values: Object.fromEntries([...evaluation.sectors.values()].map((state) => [
+        state.name,
+        Object.fromEntries(Object.entries(state.values).map(([id, value]) => [id, Number.isNaN(value) ? null : value])),
+    ])),
 }));
 // The nudge for one diff. The "before" side is the ledger, or the base tree
 // evaluated whole in the exact mode; the "after" side is the tree now.
@@ -785,8 +1104,38 @@ export const nudgeOf = (policy, evaluations, diff, base, hotfix, by) => {
             const open = phase !== undefined && isOpenPhase(phase);
             const onTouch = onTouchOf(rule, state.phase);
             // Before: the ledger's count per objective in window, or the base tree's.
+            // A scalar's is its distance to target from the value before: the
+            // base tree's, or the ledger's record.
             const before = {};
+            const measures = [];
             for (const objective of state.inWindow) {
+                if (objective.measure !== null) {
+                    const recorded = measureLedgerOf(policy, rule, objective)?.sectors[name];
+                    const baseValue = baseEvaluation?.values === undefined
+                        ? undefined
+                        : baseEvaluation.values[name]?.[objective.id];
+                    const was = baseValue !== undefined
+                        ? baseValue
+                        : recorded === undefined || recorded.closed !== null
+                            ? null
+                            : recorded.recorded;
+                    const value = state.values[objective.id] ?? Number.NaN;
+                    const now_ = Number.isNaN(value) ? null : value;
+                    before[objective.id] =
+                        was === null ? (state.counts[objective.id] ?? 0) : distanceToTarget(objective, was);
+                    measures.push({
+                        objective: objective.id,
+                        direction: objective.direction,
+                        before: was,
+                        after: now_,
+                        target: objective.target,
+                        tolerance: objective.tolerance,
+                        back: was !== null &&
+                            (now_ === null ||
+                                breaches({ direction: objective.direction, limit: was, tolerance: objective.tolerance }, now_)),
+                    });
+                    continue;
+                }
                 if (baseEvaluation !== null) {
                     before[objective.id] = baseEvaluation.sectors[name]?.[objective.id] ?? 0;
                 }
@@ -869,9 +1218,19 @@ export const nudgeOf = (policy, evaluations, diff, base, hotfix, by) => {
                 if (state_.stale.length > 0)
                     editsHoldout = true;
             }
-            const back = worsened(before, after);
-            const totalBefore = Object.values(before).reduce((a, b) => a + b, 0);
-            const totalAfter = Object.values(after).reduce((a, b) => a + b, 0);
+            // A scalar goes back by its tolerance, not by any rise of its
+            // distance; the holdout dimensions go back by any rise at all. Only
+            // the holdouts are paid down: a scalar has none to touch.
+            const scalar = new Set(measures.map((one) => one.objective));
+            const back = [
+                ...worsened(before, after).filter((id) => !scalar.has(id)),
+                ...measures.filter((one) => one.back).map((one) => one.objective),
+            ].sort();
+            const holdoutTotal = (vector) => Object.entries(vector)
+                .filter(([id]) => !scalar.has(id))
+                .reduce((sum, [, n]) => sum + n, 0);
+            const totalBefore = holdoutTotal(before);
+            const totalAfter = holdoutTotal(after);
             let ask;
             let verdict = "ok";
             if (open)
@@ -893,6 +1252,16 @@ export const nudgeOf = (policy, evaluations, diff, base, hotfix, by) => {
             if (verdict !== "ok" && hotfix !== null && by !== null) {
                 // The escape: the growth is conceded, with a reason naming the hotfix.
                 for (const objective of state.inWindow) {
+                    if (objective.measure !== null) {
+                        if (measures.some((one) => one.objective === objective.id && one.back)) {
+                            concedeMeasure(policy, evaluation, objective, name, {
+                                at: policy.now,
+                                by,
+                                reason: `hotfix: ${hotfix}`,
+                            });
+                        }
+                        continue;
+                    }
                     const ledger = ledgerOf(policy, rule, objective);
                     if (ledger === undefined)
                         continue;
@@ -935,6 +1304,7 @@ export const nudgeOf = (policy, evaluations, diff, base, hotfix, by) => {
                 holdouts: { total: own.length, cap: HOLDOUT_CAP, shown },
                 added: added.sort(),
                 removed: removed.sort(),
+                measures,
                 belongsInSector: name === LEGACY_SECTOR ? belongs.sort() : [],
             });
         }
@@ -1000,6 +1370,7 @@ export const renderNudge = (nudge, now) => {
             ? "its objectives"
             : `phase ${one.phase.id ?? "done"} (${String(one.phase.index + 1)} of ${String(one.phase.of)}${one.phase.open ? ", open" : ""})`;
         const quiet = one.holdouts.total === 0 &&
+            one.measures.every((measure) => measure.before === measure.after) &&
             one.direction === "neutral" &&
             !one.phase.open &&
             one.verdict === "ok" &&
@@ -1030,6 +1401,17 @@ export const renderNudge = (nudge, now) => {
             else if (one.direction !== "neutral") {
                 say(`    this diff: ${residueOf(one.residue.before)} → ${residueOf(one.residue.after)}  ${one.direction}`);
             }
+            for (const measure of one.measures) {
+                if (measure.before === measure.after && !measure.back)
+                    continue;
+                const bounds = [
+                    ...(measure.target === null ? [] : [`target ${String(measure.target)}`]),
+                    ...(measure.tolerance === 0 ? [] : [`tolerance ${String(measure.tolerance)}`]),
+                ];
+                say(`    ${measure.objective}: ${measure.before === null ? "unrecorded" : String(measure.before)} → ${measure.after === null ? "no number" : String(measure.after)}` +
+                    (bounds.length === 0 ? "" : ` (${bounds.join(", ")})`) +
+                    (measure.back ? "  back" : ""));
+            }
         }
         for (const file of one.belongsInSector)
             say(`    ${file} landed in the legacy inside the scope: this belongs in a sector`);
@@ -1054,9 +1436,14 @@ export const historyOf = (policy, rule, since, manifestPaths) => {
                 continue;
             try {
                 const raw = JSON.parse(text);
+                // A scalar's column is what its open sectors were held to.
                 counts[objective.id] =
-                    raw.entries?.length ??
-                        Object.values(raw.sectors ?? {}).reduce((sum, one) => sum + (one.holdouts?.length ?? 0), 0);
+                    raw.kind === "measure"
+                        ? Math.round(Object.values(raw.sectors ?? {})
+                            .filter((one) => one.closed === null || one.closed === undefined)
+                            .reduce((sum, one) => sum + (one.recorded ?? 0), 0) * 1e6) / 1e6
+                        : (raw.entries?.length ??
+                            Object.values(raw.sectors ?? {}).reduce((sum, one) => sum + (one.holdouts?.length ?? 0), 0));
             }
             catch {
                 // an unreadable ledger at that commit contributes nothing
@@ -1106,6 +1493,12 @@ export const explainCampaignLines = (policy, evaluation, file) => {
     return [
         `    ${rule.name}: sector ${sector}${at}${record?.reached === undefined || record.reached === null ? "" : `, reached ${record.reached}`}`,
         `      in window: ${state.inWindow.length === 0 ? "(nothing)" : state.inWindow.map((one) => `${one.id}${firing.has(one.id) ? " ✗" : ""}`).join(", ")}`,
+        ...state.inWindow
+            .filter((one) => one.measure !== null)
+            .map((one) => {
+            const recorded = measureLedgerOf(policy, rule, one)?.sectors[sector];
+            return `      ${one.id}: the sector measures ${describeValue(state.values[one.id] ?? Number.NaN)}${recorded === undefined || recorded.closed !== null ? ", unrecorded" : `, held to ${String(recorded.recorded)}`}${one.target === null ? "" : `, target ${String(one.target)}`}`;
+        }),
         ...(own.length === 0
             ? []
             : [