balladeer 1.0.16 → 1.0.18

package/dist/anchoring.js

@@ -0,0 +1,766 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ANCHOR_BRIEF_SOURCE, ANCHOR_LIMITS, BEHAVIOR_MAP_SOURCE, PROMISE_ANCHORS_SCHEMA_VERSION, anchorFiles, checkPromiseAnchors, isAnchorPath, isAnchorResourceName, isAnchorSymbol, } from "./anchors-schema.js";
+import { ENTRY_POINT_KINDS } from "./behavior-map-schema.js";
+import { runHeadlessAgent, } from "./headless-agent.js";
+import { isIndexSource } from "./risk/graph-cache.js";
+import { isTestPath } from "./risk/paths.js";
+import { buildIdf, identifierTokens, words } from "./risk/text.js";
+/**
+ * Promise anchors on the laptop: where an agreed promise's behavior lives,
+ * written by one small call on the person's own Claude Code or Codex, or cut
+ * from a behavior map, and shared through the server with every teammate.
+ *
+ * The call is `anchor-brief/v3`, frozen on 1 October 2026 after the
+ * measurement in `docs/agentic-testing/evidence/20261001/anchors-measurement.md`.
+ * The index, the shortlist and the brief below are
+ * `scripts/agentic-eval/anchors-fresh.ts` at v3, word for word. They were tuned
+ * on the seventeen in-window cases, so any change to them is a new revision
+ * with a label of its own, measured before it ships; never edit v3 in place.
+ */
+export const ANCHOR_BRIEF_REVISION = ANCHOR_BRIEF_SOURCE;
+const FILES = 150;
+const NAMES_PER_FILE = 12;
+const PER_FOLDER = 6;
+const RARE_WORDS = 10;
+const PER_RARE_WORD = 3;
+/**
+ * Each anchoring call's caps. The measured calls wrote at most 1,157 output
+ * tokens and took at most 9.3 seconds; one runaway call in 291 wrote 128,690.
+ * A call that reaches either cap leaves its promise unanchored.
+ */
+export const ANCHOR_CALL_CAPS = { outputTokens: 8000, wallMs: 60_000 };
+/** A call is not started with less time than this left: the measured calls took up to 9.3 seconds. */
+const MIN_CALL_TIME_MS = 15_000;
+/** Every non-test source file the graph knows, with the top-level names it exports. */
+export function anchorIndex(repository) {
+    const sources = repository.graph.files.filter(isIndexSource);
+    repository.prepareNames(sources);
+    const entries = [];
+    for (const file of sources) {
+        const names = repository.exportedNames(file);
+        if (names === undefined)
+            continue;
+        const pathWords = file
+            .replace(/\.[^.]+$/, "")
+            .split(/[/._-]+/)
+            .flatMap((part) => identifierTokens(part));
+        const nameWords = names.flatMap((entry) => identifierTokens(entry.name));
+        entries.push({ file, names, words: words([...pathWords, ...nameWords].join(" ")) });
+    }
+    return { sha: repository.sha, entries, idf: buildIdf(entries.map((entry) => entry.words)) };
+}
+/**
+ * The promise as the measured brief showed it: title, outcome, the cases'
+ * label, setup and outcome, and the non-goals. Nothing else of the meaning is
+ * read, so what the model sees is what was measured.
+ */
+export function briefMeaning(meaning) {
+    const example = (entry) => ({
+        ...(entry.label ? { label: entry.label } : {}),
+        setup: entry.setup,
+        expectedOutcome: entry.expectedOutcome,
+    });
+    return {
+        title: meaning.title,
+        observableOutcome: meaning.observableOutcome,
+        passingExamples: meaning.passingExamples.map(example),
+        failingExamples: meaning.failingExamples.map(example),
+        nonGoals: [...meaning.nonGoals],
+    };
+}
+function promiseText(meaning) {
+    const examples = [...(meaning.passingExamples ?? []), ...(meaning.failingExamples ?? [])]
+        .map((example) => [example.label, example.setup, example.expectedOutcome].filter(Boolean).join(" "))
+        .join(" ");
+    return [meaning.title, meaning.observableOutcome, examples, ...(meaning.nonGoals ?? [])].join(" ");
+}
+/** The files whose path and names share the most weighted words with the promise. */
+export function shortlist(index, meaning) {
+    const promiseWords = words(promiseText(meaning));
+    const scored = index.entries.map((entry) => {
+        let score = 0;
+        for (const word of promiseWords)
+            if (entry.words.has(word))
+                score += index.idf.weight(word);
+        return { entry, score };
+    });
+    const ordered = scored
+        .filter((item) => item.score > 0)
+        .sort((a, b) => b.score - a.score || a.entry.file.localeCompare(b.entry.file));
+    // At most a few files per folder, so a promise whose words also name generic UI (table,
+    // dialog, row) still reaches the feature folders where it lives.
+    const perFolder = new Map();
+    const out = [];
+    // The promise's rarest words that name anything at all each get a few places first. A
+    // summed score favours files that match many common words (table, row, dialog) over the one
+    // file named by a rare word the promise uses for a specific place (SSO, PIN, verified domain).
+    const rare = [...promiseWords]
+        .map((word) => ({ word, weight: index.idf.weight(word) }))
+        .filter(({ word }) => index.entries.some((entry) => entry.words.has(word)))
+        .sort((a, b) => b.weight - a.weight)
+        .slice(0, RARE_WORDS);
+    const byScore = new Map(ordered.map((item) => [item.entry.file, item.score]));
+    for (const { word } of rare) {
+        const matches = index.entries
+            .filter((entry) => entry.words.has(word) && !out.includes(entry))
+            .sort((a, b) => (byScore.get(b.file) ?? 0) - (byScore.get(a.file) ?? 0))
+            .slice(0, PER_RARE_WORD);
+        out.push(...matches);
+    }
+    for (const entry of out) {
+        const folder = entry.file.slice(0, entry.file.lastIndexOf("/"));
+        perFolder.set(folder, (perFolder.get(folder) ?? 0) + 1);
+    }
+    for (const item of ordered) {
+        if (out.includes(item.entry))
+            continue;
+        if (out.length >= FILES)
+            break;
+        const folder = item.entry.file.slice(0, item.entry.file.lastIndexOf("/"));
+        const count = perFolder.get(folder) ?? 0;
+        if (count >= PER_FOLDER)
+            continue;
+        perFolder.set(folder, count + 1);
+        out.push(item.entry);
+    }
+    return out;
+}
+/** `anchor-brief/v3`, word for word. */
+export function anchorBrief(meaning, candidates) {
+    const listing = candidates
+        .map((entry) => `${entry.file}: ${entry.names
+        .slice(0, NAMES_PER_FILE)
+        .map((name) => name.name)
+        .join(", ")}`)
+        .join("\n");
+    return [
+        "You are anchoring a product promise to the code that realizes it.",
+        "",
+        "The promise, in its owner's words:",
+        JSON.stringify({
+            title: meaning.title,
+            observableOutcome: meaning.observableOutcome,
+            passingExamples: meaning.passingExamples ?? [],
+            failingExamples: meaning.failingExamples ?? [],
+            nonGoals: meaning.nonGoals ?? [],
+        }, null, 1),
+        "",
+        "Source files of the repository, each with the names it exports (a pre-selected list, not the whole repository):",
+        listing,
+        "",
+        "Pick, from this list only:",
+        "- entryPoints: where the promised behavior starts (a page, route handler, API endpoint, command, job or exported function a caller uses), at most 6;",
+        "- symbols: the functions, components or classes whose code decides whether the promise holds, at most 12.",
+        "Prefer the code that decides the outcome over generic helpers. Use exact file paths and names from the list. If nothing in the list realizes the promise, answer empty lists.",
+        "Cover every layer the behavior passes through, as far as the list shows them: the page or route where a person meets it, the components that render it, the hooks or state that drive it, and the server or API code it calls. When the promise names several places (several pages or features), anchor each of them. That is usually four to ten files.",
+        'Answer with JSON only: {"entryPoints":[{"file":"...","symbol":"...","kind":"route|command|ui|job|event|function"}],"symbols":[{"file":"...","name":"..."}]}',
+    ].join("\n");
+}
+/**
+ * The first complete JSON value in a model's answer, fenced or bare, as the
+ * measurement read it. Undefined when there is none.
+ */
+export function firstJsonValue(answer) {
+    const fenced = /```(?:json)?\s*([\s\S]*?)```/.exec(answer);
+    for (const body of fenced ? [fenced[1], answer] : [answer]) {
+        const start = body.search(/[[{]/);
+        if (start === -1)
+            continue;
+        const opener = body[start];
+        const closer = opener === "{" ? "}" : "]";
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        for (let index = start; index < body.length; index += 1) {
+            const character = body[index];
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (character === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (character === '"')
+                inString = !inString;
+            if (inString)
+                continue;
+            if (character === opener)
+                depth += 1;
+            if (character === closer) {
+                depth -= 1;
+                if (depth === 0) {
+                    try {
+                        return JSON.parse(body.slice(start, index + 1));
+                    }
+                    catch {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    return undefined;
+}
+const ENTRY_KINDS = new Set(ENTRY_POINT_KINDS);
+const SYMBOL_KIND = {
+    function: "function",
+    class: "class",
+    method: "method",
+    const: "const",
+    type: "type",
+    interface: "type",
+    enum: "type",
+};
+/**
+ * What the model picked, kept only when its file is on the shortlist and its
+ * name is declared or exported in that file, and only when both pass the data
+ * boundary. Anything else is dropped. The measurement kept any name in a
+ * listed file; a name the file does not declare would read as gone on the next
+ * push, so it is dropped here instead (2 of the 1,268 measured picks).
+ */
+export function readPicks(raw, candidates, declared) {
+    const answer = (raw ?? {});
+    const byFile = new Map(candidates.map((entry) => [entry.file, entry]));
+    const dropped = [];
+    const keep = (file, name) => {
+        if (typeof file !== "string" || typeof name !== "string" || name === "")
+            return undefined;
+        const known = byFile.get(file);
+        if (known === undefined)
+            return undefined;
+        if (!isAnchorPath(known.file) || !isAnchorSymbol(name))
+            return undefined;
+        return declared(known.file)?.has(name) ? known : undefined;
+    };
+    const entryPoints = [];
+    for (const entry of Array.isArray(answer.entryPoints) ? answer.entryPoints : []) {
+        const row = (entry ?? {});
+        const known = keep(row.file, row.symbol);
+        if (known === undefined || entryPoints.length >= ANCHOR_LIMITS.entryPoints) {
+            dropped.push(`entry ${String(row.file)}#${String(row.symbol)}`);
+            continue;
+        }
+        const symbol = row.symbol;
+        if (entryPoints.some((kept) => kept.file === known.file && kept.symbol === symbol))
+            continue;
+        entryPoints.push({
+            file: known.file,
+            symbol,
+            kind: (typeof row.kind === "string" && ENTRY_KINDS.has(row.kind)
+                ? row.kind
+                : "function"),
+        });
+    }
+    const symbols = [];
+    for (const entry of Array.isArray(answer.symbols) ? answer.symbols : []) {
+        const row = (entry ?? {});
+        const known = keep(row.file, row.name);
+        if (known === undefined || symbols.length >= ANCHOR_LIMITS.symbols) {
+            dropped.push(`symbol ${String(row.file)}#${String(row.name)}`);
+            continue;
+        }
+        const name = row.name;
+        if (symbols.some((kept) => kept.file === known.file && kept.name === name))
+            continue;
+        const declaredKind = known.names.find((exported) => exported.name === name)?.kind;
+        symbols.push({
+            file: known.file,
+            name,
+            kind: SYMBOL_KIND[declaredKind ?? "function"] ?? "function",
+        });
+    }
+    return { entryPoints, symbols, dropped };
+}
+/** Linked tests, from the graph: test files that import an anchor file directly. */
+export function linkedTestsFor(graph, files) {
+    const tests = new Set();
+    for (const file of files)
+        for (const importer of graph.importedBy[file] ?? [])
+            if (isTestPath(importer))
+                tests.add(importer);
+    return [...tests]
+        .filter((file) => isAnchorPath(file))
+        .slice(0, ANCHOR_LIMITS.linkedTests)
+        .map((file) => ({ file }));
+}
+/**
+ * Files one import step from the anchor files, either way: what they import
+ * and what imports them, tests left out (linked tests are listed apart). This
+ * is the judge's neighborhood: where to look next if the behavior reaches
+ * further than the anchors.
+ */
+export function neighborhood(graph, files, limit = 30) {
+    const anchors = new Set(files);
+    const found = new Set();
+    for (const file of files) {
+        for (const next of graph.imports[file] ?? [])
+            if (!anchors.has(next))
+                found.add(next);
+        for (const next of graph.importedBy[file] ?? [])
+            if (!anchors.has(next))
+                found.add(next);
+    }
+    return [...found]
+        .filter((file) => !isTestPath(file))
+        .sort()
+        .slice(0, limit);
+}
+/**
+ * Anchors cut from a behavior map, with no model: its entry points, its core
+ * symbols, its resources and its linked tests, each kept only when it passes
+ * the data boundary, up to the contract's limits. A map's notes are not
+ * carried. Undefined when nothing anchorable is left.
+ */
+export function seedFromMap(map, at) {
+    const entryPoints = map.entryPoints
+        .filter((entry) => isAnchorPath(entry.file) && isAnchorSymbol(entry.symbol))
+        .slice(0, ANCHOR_LIMITS.entryPoints)
+        .map((entry) => ({ file: entry.file, symbol: entry.symbol, kind: entry.kind }));
+    const symbols = map.symbols
+        .filter((symbol) => symbol.role === "core")
+        .filter((symbol) => isAnchorPath(symbol.file) && isAnchorSymbol(symbol.name))
+        .slice(0, ANCHOR_LIMITS.symbols)
+        .map((symbol) => ({ file: symbol.file, name: symbol.name, kind: symbol.kind }));
+    if (entryPoints.length + symbols.length === 0)
+        return undefined;
+    const anchors = {
+        schemaVersion: PROMISE_ANCHORS_SCHEMA_VERSION,
+        promiseId: map.promiseId,
+        semanticDigest: map.semanticDigest,
+        anchoredAt: {
+            sha: map.mappedAt.sha,
+            at: at.toISOString(),
+            source: BEHAVIOR_MAP_SOURCE,
+            client: null,
+            model: null,
+        },
+        entryPoints,
+        symbols,
+        resources: map.resources
+            .filter((resource) => isAnchorResourceName(resource.name))
+            .slice(0, ANCHOR_LIMITS.resources)
+            .map((resource) => ({ kind: resource.kind, name: resource.name, access: resource.access })),
+        linkedTests: map.linkedTests
+            .filter((test) => isAnchorPath(test.file))
+            .slice(0, ANCHOR_LIMITS.linkedTests)
+            .map((test) => ({ file: test.file })),
+    };
+    return checkPromiseAnchors(anchors).ok ? anchors : undefined;
+}
+/**
+ * Which anchors have gone at a commit, read off the graph with no model: an
+ * entry point or symbol whose file is not in the tree, or whose name its file
+ * no longer declares. A file the graph does not read (another language, from a
+ * map) is checked for being there only.
+ */
+export function goneAnchors(anchors, repository) {
+    const gone = [];
+    const present = (file, name) => {
+        if (!repository.tree.has(file))
+            return false;
+        const names = repository.declaredNames(file);
+        return names === undefined || names.has(name);
+    };
+    const entryPoints = anchors.entryPoints.filter((entry) => {
+        const kept = present(entry.file, entry.symbol);
+        if (!kept)
+            gone.push(`${entry.file}#${entry.symbol}`);
+        return kept;
+    });
+    const symbols = anchors.symbols.filter((symbol) => {
+        const kept = present(symbol.file, symbol.name);
+        if (!kept)
+            gone.push(`${symbol.file}#${symbol.name}`);
+        return kept;
+    });
+    const linkedTests = anchors.linkedTests.filter((test) => repository.tree.has(test.file));
+    return { surviving: { ...anchors, entryPoints, symbols, linkedTests }, gone };
+}
+/** How many tokens a run spent: input, cache reads and writes included, and output. */
+function spentTokens(agent) {
+    return (agent.inputTokens ?? 0) + (agent.outputTokens ?? 0);
+}
+/**
+ * One promise anchored by one headless call: no tools, in an empty folder,
+ * with an output-token cap and a time limit. Only picks from the shortlist are
+ * kept, linked tests come from the graph, and the result is checked against
+ * the data boundary before anyone sees it.
+ */
+export async function anchorWithCall(input) {
+    const meaning = briefMeaning(input.meaning);
+    const candidates = shortlist(input.index, meaning);
+    const prompt = anchorBrief(meaning, candidates);
+    const cwd = mkdtempSync(join(input.scratch ?? tmpdir(), "balladeer-anchor-"));
+    const started = Date.now();
+    // Shorter than the cap only when the push check has less time than that left; running
+    // into that is the push's time running out, not the call running away.
+    const limit = Math.min(input.timeoutMs ?? ANCHOR_CALL_CAPS.wallMs, ANCHOR_CALL_CAPS.wallMs);
+    let agent;
+    try {
+        agent = await (input.runAgent ?? runHeadlessAgent)({
+            client: input.login.client,
+            login: input.login,
+            cwd,
+            prompt,
+            allowedTools: [],
+            tools: [],
+            sandbox: "read-only",
+            outsideRepository: true,
+            timeoutMs: limit,
+            maxOutputTokens: ANCHOR_CALL_CAPS.outputTokens,
+            env: input.environment,
+            jsonOutput: false,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+            ...(input.scratch === undefined ? {} : { scratch: input.scratch }),
+        });
+    }
+    finally {
+        rmSync(cwd, { recursive: true, force: true });
+    }
+    const tokens = spentTokens(agent);
+    if (agent.aborted)
+        return { status: "stopped", reason: "the push check's time ran out", tokens };
+    if (agent.reason === "output_capped" || agent.overOutputCap === true)
+        return {
+            status: "capped",
+            reason: `its call went past the ${ANCHOR_CALL_CAPS.outputTokens / 1000} thousand output-token cap and was stopped`,
+            tokens,
+        };
+    if (agent.reason === "timed_out")
+        return limit < ANCHOR_CALL_CAPS.wallMs
+            ? { status: "stopped", reason: "the push check's time ran out", tokens }
+            : {
+                status: "capped",
+                reason: `its call ran past ${ANCHOR_CALL_CAPS.wallMs / 1000} seconds and was stopped`,
+                tokens,
+            };
+    if (!agent.ok)
+        return {
+            status: "failed",
+            reason: `its call did not answer (${agent.reason ?? "no answer"})`,
+            tokens,
+        };
+    const raw = firstJsonValue(agent.text);
+    if (raw === undefined || raw === null || typeof raw !== "object")
+        return { status: "failed", reason: "its call's answer held no JSON", tokens };
+    const picks = readPicks(raw, candidates, (file) => input.repository.declaredNames(file));
+    if (picks.entryPoints.length + picks.symbols.length === 0)
+        return { status: "empty", tokens, dropped: picks.dropped };
+    const anchors = {
+        schemaVersion: PROMISE_ANCHORS_SCHEMA_VERSION,
+        promiseId: input.promiseId,
+        semanticDigest: input.semanticDigest,
+        anchoredAt: {
+            sha: input.repository.sha,
+            at: input.now().toISOString(),
+            source: ANCHOR_BRIEF_SOURCE,
+            client: input.login.client,
+            model: anchorModelName(agent.model),
+        },
+        entryPoints: picks.entryPoints,
+        symbols: picks.symbols,
+        resources: [],
+        linkedTests: linkedTestsFor(input.repository.graph, new Set([
+            ...picks.entryPoints.map((entry) => entry.file),
+            ...picks.symbols.map((symbol) => symbol.file),
+        ])),
+    };
+    const checked = checkPromiseAnchors(anchors);
+    if (!checked.ok)
+        return { status: "failed", reason: "its anchors failed the data boundary", tokens };
+    return {
+        status: "anchored",
+        anchors: checked.value,
+        tokens,
+        dropped: picks.dropped,
+        ms: Date.now() - started,
+    };
+}
+/** The model name as the contract carries it, or `unknown` when the run did not say. */
+export function anchorModelName(model) {
+    const name = (model ?? "").trim();
+    return /^[A-Za-z0-9][A-Za-z0-9._:/@+[\]-]{0,127}$/.test(name) ? name : "unknown";
+}
+/**
+ * Every agreed promise brought to current anchors as far as today's budget
+ * and the time allow: kept when current, cut from a current map with no model,
+ * else anchored by a call; anchors whose code has gone are anchored again, and
+ * judged on what is left of them meanwhile. A promise left unanchored says why.
+ */
+export async function bringAnchorsCurrent(input) {
+    const run = await anchorEach(input);
+    const selectBy = new Map();
+    for (const promise of input.promises) {
+        const files = new Set();
+        if (promise.anchors !== null)
+            for (const file of anchorFiles(promise.anchors))
+                files.add(file);
+        const now = run.anchors.get(promise.promiseId);
+        if (now !== undefined)
+            for (const file of anchorFiles(now))
+                files.add(file);
+        if (files.size > 0)
+            selectBy.set(promise.promiseId, [...files].sort());
+    }
+    return { ...run, selectBy };
+}
+async function anchorEach(input) {
+    const anchors = new Map();
+    const outcomes = [];
+    let tokens = 0;
+    const needs = [];
+    for (const promise of input.promises) {
+        const forced = input.force?.has(promise.promiseId) === true;
+        const inScope = input.only === undefined || input.only.has(promise.promiseId) || forced;
+        const existing = promise.anchors;
+        if (existing !== null) {
+            const check = goneAnchors(existing, input.repository);
+            const usable = check.surviving.entryPoints.length + check.surviving.symbols.length > 0;
+            if (usable)
+                anchors.set(promise.promiseId, check.surviving);
+            if (!forced && (check.gone.length === 0 || !inScope)) {
+                if (check.gone.length === 0)
+                    outcomes.push({ promiseId: promise.promiseId, title: promise.title, status: "current" });
+                else
+                    outcomes.push({ promiseId: promise.promiseId, title: promise.title, status: "stale" });
+                continue;
+            }
+            needs.push({ promise, again: check.gone.length > 0 });
+            continue;
+        }
+        if (inScope)
+            needs.push({ promise, again: false });
+    }
+    const record = async (promise, fresh) => {
+        const sent = await input.client.record(fresh);
+        return sent.ok ? { recorded: true } : { recorded: false, recordReason: sent.reason };
+    };
+    // Seeds first: they cost nothing and need no login.
+    const calls = [];
+    for (const need of needs) {
+        const map = input.currentMaps.get(need.promise.promiseId);
+        const seeded = map === undefined ? undefined : seedFromMap(map, input.now());
+        if (seeded === undefined) {
+            calls.push(need);
+            continue;
+        }
+        anchors.set(need.promise.promiseId, goneAnchors(seeded, input.repository).surviving);
+        outcomes.push({
+            promiseId: need.promise.promiseId,
+            title: need.promise.title,
+            status: "seeded",
+            ...(need.again ? { again: true } : {}),
+            ...(await record(need.promise, seeded)),
+        });
+    }
+    if (calls.length === 0)
+        return { anchors, outcomes, tokens, budget: input.budget };
+    const settledKey = (promise) => `${input.repositoryKey}:${promise.promiseId}:${promise.semanticDigest}`;
+    const open = [];
+    for (const need of calls) {
+        const settled = input.budget.settledToday(settledKey(need.promise));
+        if (settled !== undefined && input.force?.has(need.promise.promiseId) !== true)
+            outcomes.push({
+                promiseId: need.promise.promiseId,
+                title: need.promise.title,
+                status: need.promise.anchors !== null && anchors.has(need.promise.promiseId)
+                    ? "stale"
+                    : "settled",
+                reason: settled === "empty"
+                    ? "its call came back empty earlier today"
+                    : "its call went past its cap earlier today",
+            });
+        else
+            open.push(need);
+    }
+    if (open.length === 0)
+        return { anchors, outcomes, tokens, budget: input.budget };
+    const login = await input.login();
+    if (login === undefined) {
+        for (const need of open)
+            outcomes.push({
+                promiseId: need.promise.promiseId,
+                title: need.promise.title,
+                status: anchors.has(need.promise.promiseId) ? "stale" : "no_login",
+                reason: "no Claude Code signed in through claude.ai, and no Codex signed in with ChatGPT, is on this machine",
+            });
+        return { anchors, outcomes, tokens, budget: input.budget };
+    }
+    const client = login.client;
+    const repositoryIndex = anchorIndex(input.repository);
+    const queue = [...open];
+    const worker = async () => {
+        for (;;) {
+            const need = queue.shift();
+            if (need === undefined)
+                return;
+            const { promise } = need;
+            const left = (status, reason, spent) => outcomes.push({
+                promiseId: promise.promiseId,
+                title: promise.title,
+                // A promise with anchors left over is still judged on them.
+                status: anchors.has(promise.promiseId) ? "stale" : status,
+                ...(reason === undefined ? {} : { reason }),
+                ...(spent === undefined ? {} : { tokens: spent }),
+            });
+            if (input.signal?.aborted ||
+                (input.deadline !== undefined && input.deadline - Date.now() < MIN_CALL_TIME_MS)) {
+                left("time", "the push check's time ran out before its turn");
+                continue;
+            }
+            const read = input.reader === undefined ? undefined : await input.reader.get(promise.promiseId);
+            if (read === undefined || !read.ok) {
+                left("unreadable", read?.ok === false ? read.reason : "its meaning could not be read here");
+                continue;
+            }
+            if (read.promise.semanticDigest !== promise.semanticDigest) {
+                left("unreadable", "its meaning changed while this push was being checked");
+                continue;
+            }
+            if (!input.budget.take()) {
+                left("budget", budgetSpent(input.budget.limit));
+                continue;
+            }
+            const remaining = input.deadline === undefined
+                ? ANCHOR_CALL_CAPS.wallMs
+                : Math.max(1000, input.deadline - Date.now());
+            const call = await anchorWithCall({
+                promiseId: promise.promiseId,
+                semanticDigest: promise.semanticDigest,
+                meaning: read.promise.meaning,
+                repository: input.repository,
+                index: repositoryIndex,
+                login,
+                environment: input.environment,
+                now: input.now,
+                timeoutMs: Math.min(ANCHOR_CALL_CAPS.wallMs, remaining),
+                ...(input.signal === undefined ? {} : { signal: input.signal }),
+                ...(input.scratch === undefined ? {} : { scratch: input.scratch }),
+                ...(input.runAgent === undefined ? {} : { runAgent: input.runAgent }),
+            });
+            tokens += call.tokens;
+            if (call.status === "anchored") {
+                anchors.set(promise.promiseId, call.anchors);
+                outcomes.push({
+                    promiseId: promise.promiseId,
+                    title: promise.title,
+                    status: "anchored",
+                    tokens: call.tokens,
+                    ...(need.again ? { again: true } : {}),
+                    ...(await record(promise, call.anchors)),
+                });
+                continue;
+            }
+            if (call.status === "empty") {
+                input.budget.settle(settledKey(promise), "empty");
+                left("empty", "nothing on its shortlist realizes it", call.tokens);
+                continue;
+            }
+            if (call.status === "capped")
+                input.budget.settle(settledKey(promise), "capped");
+            left(call.status === "stopped" ? "time" : call.status, call.reason, call.tokens);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.max(1, Math.min(input.concurrency ?? 3, open.length)) }, worker));
+    return {
+        anchors,
+        outcomes,
+        tokens,
+        client,
+        budget: input.budget,
+    };
+}
+function plural(count, one, many) {
+    return `${count} ${count === 1 ? one : many}`;
+}
+function budgetSpent(limit) {
+    return `this laptop's ${plural(limit, "anchoring", "anchorings")} for today ${limit === 1 ? "is" : "are"} used up`;
+}
+function aboutTokens(tokens) {
+    if (tokens < 1000)
+        return `about ${tokens} tokens`;
+    return `about ${Math.round(tokens / 1000)} thousand tokens`;
+}
+function subscription(client) {
+    return client === "codex" ? "your Codex subscription" : "your Claude subscription";
+}
+function named(outcomes, max = 3) {
+    const shown = outcomes.slice(0, max).map((outcome) => `${outcome.title} (${outcome.promiseId})`);
+    const more = outcomes.length > max ? ` and ${outcomes.length - max} more` : "";
+    return `${shown.join("; ")}${more}`;
+}
+/**
+ * What anchoring did, in at most four lines a person reads in one go: what
+ * was anchored and what it cost with what is left of today's budget; what was
+ * left unanchored, so not checked, and why; what is checked on part of its
+ * anchors; and anchors not shared with the team. Nothing when anchoring had
+ * nothing to do.
+ *
+ * From the push check (`push`), a promise left unanchored that the push
+ * selected anyway (by an anchor file it moved or deleted) is not listed as
+ * unchecked, because it was judged; from `balladeer anchor` there is no push,
+ * and the lines say what the push check can do instead.
+ */
+export function anchoringLines(run, context = { push: true }) {
+    const lines = [];
+    const by = (status) => run.outcomes.filter((outcome) => outcome.status === status &&
+        (status === "anchored" ||
+            status === "seeded" ||
+            context.judged?.has(outcome.promiseId) !== true));
+    const called = by("anchored");
+    const seeded = by("seeded");
+    const fresh = [...called, ...seeded];
+    const left = run.budget.remaining();
+    const remaining = `${plural(left, "anchoring", "anchorings")} left today`;
+    if (fresh.length > 0) {
+        const again = fresh.filter((outcome) => outcome.again === true).length;
+        const againText = again === 0
+            ? ""
+            : ` (${again === fresh.length && again === 1 ? "again, because" : `${again} of them again, because`} code it was anchored to is gone)`;
+        const head = `Balladeer anchored ${plural(fresh.length, "promise", "promises")} to this repository's code${againText}`;
+        if (called.length === 0)
+            lines.push(`${head} from ${seeded.length === 1 ? "its behavior map" : "their behavior maps"}, with no model call (${remaining}).`);
+        else if (seeded.length === 0)
+            lines.push(`${head} on ${subscription(run.client)} (${aboutTokens(run.tokens)}; ${remaining}).`);
+        else
+            lines.push(`${head}: ${seeded.length} from ${seeded.length === 1 ? "its behavior map" : "behavior maps"}, and ${called.length} on ${subscription(run.client)} (${aboutTokens(run.tokens)}; ${remaining}).`);
+    }
+    const reasons = [
+        ["budget", `${budgetSpent(run.budget.limit)}; anchoring starts again on a push tomorrow`],
+        ["capped", "the call went past its cap and was stopped"],
+        ["failed", "the call did not give usable anchors"],
+        ["empty", "its call found nothing in this repository's code that realizes it"],
+        ["settled", "its call came back empty or capped earlier today"],
+        [
+            "no_login",
+            "no Claude Code signed in through claude.ai, and no Codex signed in with ChatGPT, is on this laptop",
+        ],
+        ["unreadable", "its meaning could not be read"],
+        ["time", "the push check ran out of time"],
+    ];
+    const parts = [];
+    let count = 0;
+    for (const [status, why] of reasons) {
+        const these = by(status);
+        if (these.length === 0)
+            continue;
+        count += these.length;
+        parts.push(`${named(these)}: ${why}`);
+    }
+    const one = count === 1;
+    if (count > 0)
+        lines.push(`Balladeer could not anchor ${plural(count, "promise", "promises")}, so ${context.push
+            ? `this push did not check ${one ? "it" : "them"}`
+            : `the push check cannot select ${one ? "it" : "them"} until ${one ? "it is" : "they are"} anchored`}. ${parts.join(". ")}.`);
+    const stale = by("stale");
+    const single = stale.length === 1;
+    if (stale.length > 0)
+        lines.push(`Code that ${plural(stale.length, "promise was", "promises were")} anchored to is gone, and ${single ? "it was" : "they were"} not anchored again yet, so ${single ? "it is" : "they are"} checked on what is left of ${single ? "its" : "their"} anchors: ${named(stale)}.`);
+    const unshared = fresh.filter((outcome) => outcome.recorded === false);
+    if (unshared.length > 0)
+        lines.push(`The anchors for ${named(unshared)} ${context.push ? "were used on this push but " : "were "}not shared with your team: ${unshared[0]?.recordReason ?? "Balladeer did not keep them"}.`);
+    return lines;
+}