balladeer 1.0.17 → 1.0.18

package/dist/commands/judge.js

@@ -1,6 +1,6 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { CASE_ID, PROMISE_ID, parseBehaviorMap } from "../behavior-map-schema.js";
+import { BEHAVIOR_MAP_DIRECTORY, CASE_ID, PROMISE_ID, parseBehaviorMap, } from "../behavior-map-schema.js";
 import { runCommand } from "../gh.js";
 import { repositoryRoot } from "../git.js";
 import { agentEnvironment, resolveClient, runHeadlessAgent, JUDGE_ACTIVE_VARIABLE, } from "../headless-agent.js";
@@ -9,7 +9,7 @@ import { baseBeforePush, checkoutRoot, commitBeforePush, effectiveBudgetSeconds,
 import { noteHookFired } from "../hook-trust.js";
 import { sessionMemory } from "../judge-said.js";
 import { runOwnedProcess, tail } from "../owned-process.js";
-import { caseIds, connectionReader, promiseFromExcerpt, readPromiseFile, sha256Digest, } from "../promise-meaning.js";
+import { caseIds, connectionReader, meaningExcerpt, promiseFromExcerpt, readPromiseFile, sha256Digest, } from "../promise-meaning.js";
 import { addScratchWorktree, carryFiles, newFiles, removeLiveWorktreesNow, resolveCommit, shareDependencies, } from "../scratch-worktree.js";
 import { normalizeControlPlane, StoreError } from "../store.js";
 import { directness, riskOrder } from "../risk/score.js";
@@ -43,6 +43,8 @@ export const STILL_JUDGING = "still judging; rerun `balladeer judge --wait`";
 export const COMMIT_THEN_PUSH = "Held: this command makes a commit and then pushes it, and the check runs before the command, so it cannot see a commit that has not been made yet. Commit first, then push in a separate command.";
 /** However long `--wait` allows, one judge is stopped after this. */
 const JUDGE_CAP_MS = 15 * 60_000;
+/** With `--wait`, anchoring may still start calls for this long. */
+const ANCHORING_WAIT_MS = 10 * 60_000;
 const LINKED_TEST_TIMEOUT_MS = 3 * 60_000;
 const REPRODUCTION_TIMEOUT_MS = 5 * 60_000;
 export const DEFAULT_JUDGE_CONFIG = {
@@ -375,7 +377,7 @@ export async function judgePromise(input) {
         await shareDependencies(input.root, headTree.path);
         let linkedTestRun = { file: "", outcome: "none" };
         const linkedTestRuns = [];
-        const firstTest = input.map?.linkedTests[0];
+        const firstTest = input.map !== undefined ? input.map.linkedTests[0] : input.anchors?.linkedTests[0];
         if (firstTest !== undefined) {
             const command = linkedTestCommand(headTree.path, firstTest.file);
             if (command === undefined)
@@ -409,6 +411,9 @@ export async function judgePromise(input) {
             prompt: judgePrompt({
                 promise: input.promise,
                 ...(input.map === undefined ? {} : { map: input.map }),
+                ...(input.map !== undefined || input.anchors === undefined
+                    ? {}
+                    : { anchors: input.anchors }),
                 changedFiles: input.changedFiles,
                 base: input.base,
                 head: input.head,
@@ -449,6 +454,7 @@ export async function judgePromise(input) {
             judge,
             briefRevision: JUDGE_BRIEF_REVISION,
             mapUsed: input.map !== undefined,
+            anchorsUsed: input.map === undefined && input.anchors !== undefined,
             linkedTestRun,
             ...fields,
         });
@@ -558,10 +564,13 @@ export const JUDGE_USAGE = `  ${CLI_INVOCATION} judge [--promises <id,id>] [--to
       --block exits 2 on a reproduced break, and when judges are still running
       at the time limit it holds the push rather than letting it through.
       --wait runs without the time limit. Promises come from --promises, else
-      from \`balladeer risk\`: every promise whose own code or tests the
-      change edits, or with "select": "ranked" in .continuity/judge.json the
-      top of its ranking and a small random sample; else every mapped
-      promise; plus that file's alwaysJudge. Verdicts are kept in
+      every agreed promise whose anchored code the change edits, and every
+      promise with a behavior map whose own code or tests it edits (with
+      "select": "ranked" in .continuity/judge.json, the top of the maps'
+      ranking and a small random sample); plus that file's alwaysJudge. A
+      promise with no anchors yet is anchored first, by one small call on
+      your own login (see \`balladeer anchor\`), at most 20 a day on this
+      laptop, and a line says what that cost. Verdicts are kept in
       .continuity/judge-log/, which git ignores. --install-hook adds the push
       hook to .claude/settings.json and .codex/hooks.json, before and after
       each shell command: report mode judges after a push has landed, so the
@@ -572,7 +581,7 @@ export const JUDGE_USAGE = `  ${CLI_INVOCATION} judge [--promises <id,id>] [--to
       whoever is pushing; it records nothing and never holds a push (see
       \`balladeer offers\`). Setup also writes the same pair of entries at
       each host's user scope, running \`judge --hook <host> --user-scope\`,
-      so the check runs in every connected repository with mapped promises
+      so the check runs in every connected repository with agreed promises
       and says nothing anywhere else; a checkout with its own entry keeps
       the check to that entry. --push-check off turns the user-scope check
       off on this laptop, and --push-check on turns it back on.
@@ -793,20 +802,43 @@ export function readRiskOutput(stdout) {
     }
     return undefined;
 }
-/** `balladeer risk --json`, run as a child of this same command, when this build has it. */
-async function riskFromCommand(root, base, env) {
-    const entry = process.argv[1];
-    if (entry === undefined || !/(^|[/\\])(cli\.(m?js|ts)|balladeer)$/.test(entry))
+/**
+ * `balladeer risk`'s report for this change, worked out in this process over
+ * the maps in use and the anchors of the promises they select (in a map's
+ * shape), with the graph the anchoring step already built. Undefined when the
+ * change cannot be read, and the selection falls back as it says.
+ */
+async function riskInProcess(root, base, head, maps, graph) {
+    if (maps.length === 0)
+        return [];
+    try {
+        const { assessChange } = await import("../risk/pipeline.js");
+        const { report } = await assessChange({
+            root,
+            base,
+            head,
+            maps,
+            ...(graph === undefined ? {} : { graph: graph.graph }),
+        });
+        return report.promises.map((entry) => ({
+            promiseId: entry.promiseId,
+            score: entry.score,
+            band: entry.band,
+            features: entry.features,
+            evidence: entry.reasons.reduce((sum, reason) => sum + reason.weight, 0),
+        }));
+    }
+    catch {
         return undefined;
-    const run = await runOwnedProcess({
-        command: process.execPath,
-        args: [...process.execArgv, entry, "risk", "--json", "--base", base],
-        cwd: root,
-        env: { ...env, [JUDGE_ACTIVE_VARIABLE]: "1" },
-        timeoutMs: 60_000,
-        maxOutputBytes: 4 * 1024 * 1024,
-    });
-    return run.exitCode === 0 ? readRiskOutput(run.stdout) : undefined;
+    }
+}
+/**
+ * Every path the change touches, a renamed file under both its names, so a
+ * promise anchored to a file the change moves or deletes counts as edited.
+ */
+async function changedPathsBothSides(root, base, head) {
+    const diff = await runCommand("git", ["-C", root, "diff", "--name-only", "--no-renames", base, head], { timeoutMs: 60_000 });
+    return diff.ok ? diff.stdout.split("\n").filter((line) => line.trim() !== "") : [];
 }
 /**
  * The commit a change is measured from: the fork point with the remote default
@@ -842,20 +874,30 @@ export async function changedFiles(root, base, head) {
     return diff.ok ? diff.stdout.split("\n").filter((line) => line.trim() !== "") : [];
 }
 /**
- * Which promises to judge: named ones, else from the risk report, else every
- * mapped promise; then `alwaysJudge`.
+ * Which promises to judge: named ones; else the promises the change selects
+ * by their anchors and by their maps; then `alwaysJudge`.
+ *
+ * By anchors (`anchored`, chosen before this from the files the change edits):
+ * every promise one of whose anchor files (an entry point's or a symbol's
+ * file) the change edits, with no widening by import distance. The
+ * measurement of 1 October 2026 found that widening multiplied the promises
+ * selected and caught nothing more.
+ *
+ * By maps, from the risk report, in the order `balladeer risk` lists it (how
+ * directly the change reaches each promise, then score, then evidence, then
+ * id; a score alone ties at 1 and falls to the alphabet):
  *
- * From the risk report, in the order `balladeer risk` lists it (how directly
- * the change reaches each promise, then score, then evidence, then id; a score
- * alone ties at 1 and falls to the alphabet):
+ * - "direct" takes every mapped promise whose own code or tests the change
+ *   edits (directness tier 3), and nothing else. Only a `--top` given by hand
+ *   caps it, and it caps anchored and mapped promises together.
+ * - "ranked" takes the top k mapped promises with a score above zero, plus a
+ *   random sample below that line. The sample is what keeps a ranking honest:
+ *   a break found below the line is a miss the ranking made, counted rather
+ *   than never seen. Anchored promises are taken too, before the sample.
  *
- * - "direct" takes every promise whose own code or tests the change edits
- *   (directness tier 3), and nothing else. The first live evaluation found
- *   that this selects about 1.8 promises a change and included the broken one
- *   in 17 of 17 cases. Only a `--top` given by hand caps it.
- * - "ranked" takes the top k with a score above zero, plus a random sample
- *   below that line. The sample is what keeps a ranking honest: a break found
- *   below the line is a miss the ranking made, counted rather than never seen.
+ * Without a risk report, every mapped promise. Anchored and mapped promises
+ * are listed together in the report's order, and one the report does not
+ * list comes after those it does.
  */
 export function selectPromises(input) {
     const out = [];
@@ -866,31 +908,52 @@ export function selectPromises(input) {
         seen.add(promiseId);
         out.push({ promiseId, why });
     };
+    const anchored = new Set(input.anchored ?? []);
     if (input.named !== undefined)
         for (const id of input.named)
             add(id, "named");
     else if (input.risk !== undefined) {
         const ordered = input.risk.filter((entry) => entry.band !== "unmapped").sort(byEntryRisk);
+        const position = new Map(ordered.map((entry, index) => [entry.promiseId, index]));
+        const inOrder = (list) => list
+            .map((entry, index) => ({ entry, index }))
+            .sort((a, b) => (position.get(a.entry.promiseId) ?? Number.MAX_SAFE_INTEGER) -
+            (position.get(b.entry.promiseId) ?? Number.MAX_SAFE_INTEGER) || a.index - b.index)
+            .map(({ entry }) => entry);
+        const byAnchors = [...anchored].map((promiseId) => ({ promiseId, why: "anchored" }));
+        const mapped = ordered.filter((entry) => !anchored.has(entry.promiseId));
         if (input.config.select === "direct") {
-            const direct = ordered.filter((entry) => tierOf(entry) === 3);
+            const direct = inOrder([
+                ...mapped
+                    .filter((entry) => tierOf(entry) === 3)
+                    .map((entry) => ({ promiseId: entry.promiseId, why: "risk" })),
+                ...byAnchors,
+            ]);
             const capped = input.topK === undefined ? direct : direct.slice(0, input.topK);
             for (const entry of capped)
-                add(entry.promiseId, "risk");
+                add(entry.promiseId, entry.why);
         }
         else {
             const k = input.topK ?? input.config.topK;
-            const top = ordered.filter((entry) => entry.score > 0).slice(0, k);
-            for (const entry of top)
-                add(entry.promiseId, "risk");
-            const below = ordered.filter((entry) => !top.includes(entry));
+            const top = mapped.filter((entry) => entry.score > 0).slice(0, k);
+            const chosen = inOrder([
+                ...top.map((entry) => ({ promiseId: entry.promiseId, why: "risk" })),
+                ...byAnchors,
+            ]);
+            for (const entry of chosen)
+                add(entry.promiseId, entry.why);
+            const below = mapped.filter((entry) => !top.includes(entry));
             for (const entry of below)
                 if (input.random() < input.config.sampleBelowLine)
                     add(entry.promiseId, "sample");
         }
     }
-    else
+    else {
         for (const id of input.mapped)
             add(id, "mapped");
+        for (const id of anchored)
+            add(id, "anchored");
+    }
     for (const id of input.config.alwaysJudge)
         add(id, "always");
     return out;
@@ -1113,17 +1176,22 @@ function describeInstall(result) {
 }
 /** What `--push-check off` and `--push-check on` say. */
 export const PUSH_CHECK_OFF_LINE = "The push check is off on this laptop: after a push it now says nothing, in every repository. A repository's own entry from `balladeer judge --install-hook` still runs. Turn it back on with `balladeer judge --push-check on`.";
-export const PUSH_CHECK_ON_LINE = "The push check is back on for this laptop: after a push in a connected repository whose promises have behavior maps, it reports what the push may have broken, and it never holds the push.";
+export const PUSH_CHECK_ON_LINE = "The push check is back on for this laptop: after a push in a connected repository with agreed promises, it reports what the push may have broken, and it never holds the push.";
 /**
  * Whether the push check's user-scope entry has this push to itself, decided
  * before anything is started or fetched: the entry runs on every shell command
  * in every folder on the laptop, and most folders have nothing to judge. It
  * stands aside, saying nothing, when the laptop turned the check off, the
- * folder is in no checkout, the checkout has the push check's own project
+ * folder is in no checkout, or the checkout has the push check's own project
  * entry for this host (that entry owns the check there, so a push is judged
- * once), or no promise here has a behavior map. Only then is the connection
- * looked for, which reads the checkout's remotes, and a checkout this laptop
- * has not connected is left alone too.
+ * once). Only then is the connection looked for, which reads the checkout's
+ * remotes, and a checkout this laptop has not connected is left alone too.
+ *
+ * A connected checkout is not left alone for having no behavior map: since
+ * promise anchors (approved 30 September 2026), its agreed promises are
+ * anchored and checked without one. Whether it has any agreed promise is the
+ * server's to say, after the push, and with none (and no map) the entry still
+ * says nothing.
  */
 export function userScopeTakesThePush(input) {
     if (pushCheckOff(input.environment))
@@ -1133,8 +1201,41 @@ export function userScopeTakesThePush(input) {
         return false;
     if (hasProjectJudgeHook(root, input.host))
         return false;
-    const mapped = readBehaviorMaps(join(root, ".continuity/behavior-maps")).some((entry) => entry.map !== undefined);
-    return mapped && input.connected(root);
+    return input.connected(root);
+}
+/**
+ * The one line said when nothing was selected, and its code: no agreed
+ * promise here; nothing anchored or mapped (with why, when the anchors could
+ * not be read); or nothing the change touches.
+ */
+export function nothingSelected(input) {
+    const { stage } = input;
+    if (stage?.available && stage.promises.length === 0 && input.maps === 0)
+        return {
+            reason: "no_promises",
+            message: "This repository has no agreed promise yet, so nothing was judged.",
+        };
+    if (input.maps === 0 && input.anchors === 0) {
+        if (stage?.available)
+            return {
+                reason: "nothing_anchored",
+                message: "No promise here is anchored or mapped yet, so nothing was judged.",
+            };
+        if (stage === undefined || stage.unsupported)
+            return {
+                reason: "no_maps",
+                message: "No promise here has a behavior map yet, so nothing was judged. Build them with `balladeer map --all`.",
+            };
+        return {
+            reason: "anchors_unavailable",
+            message: `Balladeer could not read this repository's promise anchors (${stage.reason}), and no promise here has a behavior map, so nothing was judged.`,
+        };
+    }
+    const code = input.anchors === 0 ? "mapped" : input.maps === 0 ? "anchored" : "anchored or mapped";
+    return {
+        reason: "no_promise_touched",
+        message: `This ${input.push ? "push" : "change"} touches no promise's ${code} code, so nothing was judged.`,
+    };
 }
 /** `balladeer judge`, from arguments already parsed. */
 /**
@@ -1282,7 +1383,36 @@ export async function runJudge(options) {
             namedMerge = mergeTargets(parsed.command).find((target) => target.selector !== undefined || target.repo !== undefined);
         }
     }
-    const pushedFromUnknown = () => {
+    // Under the user-scope entry, a push from a place it cannot tell is spoken
+    // of only where the session's own checkout has something to check: a
+    // behavior map, or an agreed promise the server lists. Anywhere else it says
+    // nothing, as it always has.
+    const sessionHasPromises = async () => {
+        const sessionRoot = checkoutRoot(cwd);
+        if (sessionRoot === undefined)
+            return false;
+        if (readBehaviorMaps(join(sessionRoot, BEHAVIOR_MAP_DIRECTORY)).some((entry) => entry.map !== undefined))
+            return true;
+        let client = deps.anchors ?? undefined;
+        if (deps.anchors === undefined) {
+            const { connectionAnchorsClient } = await import("./anchor.js");
+            const found = connectionAnchorsClient({
+                environment: options.environment,
+                controlPlane: args.controlPlane,
+                cwd: sessionRoot,
+                ...(args.repository === undefined ? {} : { repository: args.repository }),
+            });
+            if (found.ok)
+                client = found.client;
+        }
+        if (client === undefined)
+            return false;
+        const listed = await client.list();
+        return listed.ok && listed.promises.length > 0;
+    };
+    const pushedFromUnknown = async () => {
+        if (args.userScope && !(await sessionHasPromises()))
+            return 0;
         emit({
             step: "judge",
             status: "nothing_to_judge",
@@ -1470,6 +1600,99 @@ export async function runJudge(options) {
             }
         }
     }
+    // Meanings: the file, else this repository's connection, else the map's own excerpt.
+    const connection = {
+        environment: options.environment,
+        controlPlane: args.controlPlane,
+        cwd: root,
+        ...(args.repository === undefined ? {} : { repository: args.repository }),
+    };
+    let reader = deps.reader ?? undefined;
+    if (deps.reader === undefined && filePromise === undefined) {
+        const found = connectionReader(connection);
+        if (found.ok)
+            reader = found.reader;
+    }
+    // The login is checked once, and only when something needs it: an anchoring call or a judge.
+    const prefer = hook === "claude" || hook === "codex" ? hook : undefined;
+    const requested = args.client ?? config.client;
+    let loginCheck;
+    const resolveLogin = () => (loginCheck ??= (deps.resolveLogin ??
+        ((client, preferred) => resolveClient(client, {
+            env: options.environment,
+            cwd: root,
+            ...(preferred === undefined ? {} : { prefer: preferred }),
+        })))(requested, prefer));
+    // From a hook, the host's own timeout rules and a timed-out hook lets the
+    // push run, so the budget is capped below it; by hand, the person's number.
+    // It starts here, so anchoring and judging share it.
+    const budgetMs = args.wait
+        ? undefined
+        : effectiveBudgetSeconds(config.budgetSeconds, args.hook !== undefined) * 1000;
+    const started = Date.now();
+    // Anchors, brought current before anything is selected: read from Balladeer,
+    // then cut from a current map or written by a call for each agreed promise
+    // without them, within a third of the budget and today's anchorings. In
+    // report mode this all runs after the push has landed; in block mode it runs
+    // before, and a promise left unanchored is said and never holds the push.
+    const named = filePromise !== undefined ? [filePromise.promiseId] : args.promises;
+    const storedMaps = readBehaviorMaps(join(root, BEHAVIOR_MAP_DIRECTORY));
+    let stage;
+    // Loaded only here, once the push is this check's to judge, so the fast
+    // exits above pay nothing for the anchoring machinery.
+    const kit = filePromise === undefined ? await import("./anchor.js") : undefined;
+    if (kit !== undefined) {
+        let client = deps.anchors ?? undefined;
+        let clientMissing;
+        if (deps.anchors === undefined) {
+            const found = kit.connectionAnchorsClient(connection);
+            if (found.ok)
+                client = found.client;
+            else
+                clientMissing = found.reason;
+        }
+        stage = await kit.anchorStage({
+            root,
+            head,
+            environment: options.environment,
+            maps: storedMaps,
+            client,
+            ...(clientMissing === undefined ? {} : { clientMissing }),
+            reader,
+            login: resolveLogin,
+            now,
+            deadline: started + (budgetMs === undefined ? ANCHORING_WAIT_MS : Math.floor(budgetMs / 3)),
+            concurrency: config.concurrency,
+            ...(named === undefined ? {} : { only: new Set(named) }),
+            ...(deps.scratch === undefined ? {} : { scratch: deps.scratch }),
+            ...(deps.anchorAgent === undefined ? {} : { runAgent: deps.anchorAgent }),
+            ...(deps.graph === undefined ? {} : { graph: deps.graph }),
+            ...(deps.anchorBudget === undefined ? {} : { budget: deps.anchorBudget }),
+        });
+    }
+    const parsedMaps = storedMaps.flatMap((entry) => (entry.map === undefined ? [] : [entry.map]));
+    // The user-scope entry still says nothing where there is nothing to check:
+    // the server says this repository has no agreed promise, or the server
+    // cannot be read and no promise here has a map.
+    if (args.userScope &&
+        stage !== undefined &&
+        (stage.available ? stage.promises.length === 0 : parsedMaps.length === 0))
+        return 0;
+    // A map for its promise's current meaning wins over that promise's anchors.
+    // Without the server's word on what is current, every map counts, as before.
+    const mapsInUse = stage?.available ? [...stage.currentMaps.values()] : parsedMaps;
+    const mappedIds = mapsInUse.map((map) => map.promiseId);
+    // What each promise without such a map is judged on, and the anchor files it is selected by.
+    const anchorsInUse = new Map();
+    const selectBy = new Map();
+    if (stage?.available) {
+        for (const [promiseId, anchors] of stage.run?.anchors ?? [])
+            if (!stage.currentMaps.has(promiseId))
+                anchorsInUse.set(promiseId, anchors);
+        for (const [promiseId, anchorFilesOf] of stage.run?.selectBy ?? [])
+            if (!stage.currentMaps.has(promiseId))
+                selectBy.set(promiseId, anchorFilesOf);
+    }
     if (config.offers && hook !== undefined) {
         // Even when no promise is at risk and no map exists: a change nobody
         // mapped is exactly where a rule nobody wrote down is likeliest.
@@ -1491,70 +1714,109 @@ export async function runJudge(options) {
             ...(deps.offerAgent === undefined ? {} : { runAgent: deps.offerAgent }),
         });
     }
-    const mappedIds = readBehaviorMaps(join(root, ".continuity/behavior-maps"))
-        .filter((entry) => entry.map !== undefined)
-        .map((entry) => entry.promiseId);
-    const named = filePromise !== undefined ? [filePromise.promiseId] : args.promises;
+    // By anchors: every promise one of whose anchor files the change edits, a
+    // moved or deleted file counting under its old name too.
+    const anchored = kit !== undefined && named === undefined && selectBy.size > 0
+        ? kit.anchoredByChange(selectBy, await changedPathsBothSides(root, base, head))
+        : [];
+    // Their meanings, read once: the scorer orders them by their words, and
+    // their judges need them anyway.
+    const meanings = new Map();
+    if (reader !== undefined)
+        for (const promiseId of anchored) {
+            const read = await reader.get(promiseId);
+            if (read.ok)
+                meanings.set(promiseId, read.promise);
+        }
+    // A promise all of whose anchors have gone is still selected by them, and is
+    // listed after those the ranking can place.
+    const scored = [
+        ...mapsInUse,
+        ...anchored.flatMap((promiseId) => {
+            const anchors = anchorsInUse.get(promiseId);
+            const meaning = meanings.get(promiseId);
+            return anchors === undefined || kit === undefined
+                ? []
+                : [kit.anchorsAsMap(anchors, meaning === undefined ? undefined : meaningExcerpt(meaning))];
+        }),
+    ];
+    const repository = stage?.available ? stage.repository : undefined;
     const risk = named === undefined
-        ? await (deps.riskReport ?? ((r, b) => riskFromCommand(r, b, options.environment)))(root, base, head)
+        ? await (deps.riskReport ??
+            ((r, b, h, m) => riskInProcess(r, b, h, m, repository)))(root, base, head, scored)
         : undefined;
     const selected = selectPromises({
         ...(named === undefined ? {} : { named }),
         ...(risk === undefined ? {} : { risk }),
         mapped: mappedIds,
+        anchored,
         // A promise handed over in a file is judged alone: the repository's own
         // standing list belongs to its own promises, not to the one in the file.
         config: filePromise === undefined ? config : { ...config, alwaysJudge: [] },
         ...(args.topK === undefined ? {} : { topK: args.topK }),
         random: deps.random ?? Math.random,
     });
+    // What anchoring did, said after the verdicts whenever it ran or was held back.
+    const anchorRun = stage?.available ? stage.run : undefined;
+    if (anchorRun !== undefined && kit !== undefined) {
+        const said = kit.anchoringLines(anchorRun, {
+            push: true,
+            judged: new Set(selected.map((entry) => entry.promiseId)),
+        });
+        if (said.length > 0) {
+            trailing.push(...said);
+            emit({
+                step: "anchors",
+                message: said.join(" "),
+                anchored: anchorRun.outcomes
+                    .filter((outcome) => outcome.status === "anchored" || outcome.status === "seeded")
+                    .map((outcome) => outcome.promiseId),
+                notAnchored: anchorRun.outcomes
+                    .filter((outcome) => !["current", "anchored", "seeded", "stale"].includes(outcome.status))
+                    .map((outcome) => ({
+                    promiseId: outcome.promiseId,
+                    reason: outcome.reason ?? outcome.status,
+                })),
+                tokens: anchorRun.tokens,
+                remainingToday: anchorRun.budget.remaining(),
+            });
+        }
+    }
     if (selected.length === 0) {
         // Said in one line either way, so that silence is never read as safe.
-        const noMaps = mappedIds.length === 0;
-        const message = noMaps
-            ? "No promise here has a behavior map yet, so nothing was judged. Build them with `balladeer map --all`."
-            : `This ${hook === undefined ? "change" : "push"} touches no promise's mapped code, so nothing was judged.`;
+        const nothing = nothingSelected({
+            stage,
+            maps: mapsInUse.length,
+            anchors: selectBy.size,
+            push: hook !== undefined,
+        });
         emit({
             step: "judge",
             status: "nothing_to_judge",
-            reason: noMaps ? "no_maps" : "no_promise_touched",
-            message,
+            reason: nothing.reason,
+            message: nothing.message,
             exitCode: 0,
         });
-        lines.push(message);
+        lines.push(nothing.message);
         return respond(false);
     }
-    const prefer = hook === "claude" || hook === "codex" ? hook : undefined;
-    const requested = args.client ?? config.client;
-    const login = await (deps.resolveLogin ??
-        ((client, preferred) => resolveClient(client, {
-            env: options.environment,
-            cwd: root,
-            ...(preferred === undefined ? {} : { prefer: preferred }),
-        })))(requested, prefer);
+    const login = await resolveLogin();
     if (login === undefined) {
         const message = "not judged: no Claude Code signed in through claude.ai, and no Codex signed in with ChatGPT, is on this machine, so Balladeer did not judge this change.";
         emit({ step: "judge", status: "not_judged", reason: "no_login", message, exitCode: 0 });
         lines.push(message);
         return respond(false);
     }
-    // Meanings: the file, else this repository's connection, else the map's own excerpt.
-    let reader = deps.reader ?? undefined;
-    if (deps.reader === undefined && filePromise === undefined) {
-        const connection = connectionReader({
-            environment: options.environment,
-            controlPlane: args.controlPlane,
-            cwd: root,
-            ...(args.repository === undefined ? {} : { repository: args.repository }),
-        });
-        if (connection.ok)
-            reader = connection.reader;
-    }
     const jobs = [];
     const unreadable = [];
     for (const { promiseId } of selected) {
-        const map = filePromise !== undefined ? fileMap : readBehaviorMap(root, promiseId);
-        let promise = filePromise;
+        const map = filePromise !== undefined
+            ? fileMap
+            : stage?.available
+                ? stage.currentMaps.get(promiseId)
+                : readBehaviorMap(root, promiseId);
+        const anchors = map === undefined ? anchorsInUse.get(promiseId) : undefined;
+        let promise = filePromise ?? meanings.get(promiseId);
         if (promise === undefined && reader !== undefined) {
             const read = await reader.get(promiseId);
             if (read.ok)
@@ -1565,7 +1827,13 @@ export async function runJudge(options) {
         if (promise === undefined)
             unreadable.push(promiseId);
         else
-            jobs.push({ promise, ...(map === undefined ? {} : { map }) });
+            jobs.push({
+                promise,
+                ...(map === undefined ? {} : { map }),
+                ...(anchors === undefined || repository === undefined || kit === undefined
+                    ? {}
+                    : { anchors: kit.judgeAnchors(anchors, repository) }),
+            });
     }
     const stopHandler = () => {
         removeLiveWorktreesNow();
@@ -1574,13 +1842,9 @@ export async function runJudge(options) {
     process.once("SIGINT", stopHandler);
     process.once("SIGTERM", stopHandler);
     const budget = new AbortController();
-    // From a hook, the host's own timeout rules and a timed-out hook lets the
-    // push run, so the budget is capped below it; by hand, the person's number.
-    const budgetMs = args.wait
+    const timer = budgetMs === undefined
         ? undefined
-        : effectiveBudgetSeconds(config.budgetSeconds, args.hook !== undefined) * 1000;
-    const timer = budgetMs === undefined ? undefined : setTimeout(() => budget.abort(), budgetMs);
-    const started = Date.now();
+        : setTimeout(() => budget.abort(), Math.max(1000, budgetMs - (Date.now() - started)));
     const verdicts = [];
     const stillJudging = [];
     const notJudged = [];
@@ -1615,6 +1879,7 @@ export async function runJudge(options) {
                     root,
                     promise: job.promise,
                     ...(job.map === undefined ? {} : { map: job.map }),
+                    ...(job.anchors === undefined ? {} : { anchors: job.anchors }),
                     base,
                     head,
                     changedFiles: files,

package/dist/commands/map.js

@@ -221,6 +221,8 @@ export function agentFailure(agent) {
             return "the agent finished without an answer";
         case "no_json":
             return "the agent's answer held no JSON object";
+        case "output_capped":
+            return `the agent wrote ${agent.outputTokens ?? "more"} output tokens, past its cap, so its answer was not used`;
         default:
             return "the agent did not answer";
     }