balladeer 1.0.16 → 1.0.17

package/dist/judge-said.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Which could-not-tell verdicts a coding session has already been told.
+ *
+ * Robert, 30 September 2026: say a given could-not-tell once per session. The
+ * first time a session hears that a promise could not be judged, it hears it
+ * in full; later in the same session, for the same promise and the same
+ * reason, it hears one quiet line. A different reason, a new session, or a
+ * host that names no session is told in full. Kept and broken are never
+ * shortened.
+ *
+ * The record lives in the judge log directory, which carries its own
+ * `.gitignore`. It holds session ids, promise ids and a short gist of each
+ * reason, never the reason's text, and it forgets a session a day after it
+ * was last heard from.
+ */
+export declare const SAID_FILE = "said.json";
+export declare const SAID_SCHEMA_VERSION = "balladeer-judge-said/v1";
+/** A session not heard from for this long is forgotten. */
+export declare const SAID_KEEP_MS: number;
+/** What of a verdict the record reads. */
+export type SaidVerdict = Readonly<{
+    promiseId: string;
+    verdict: "kept" | "broken" | "could_not_tell";
+    notes: string;
+    reproductionRejected: string | null;
+    nextStep?: string;
+}>;
+/**
+ * The gist of why a promise could not be judged, stable across the different
+ * words two runs use for the same reason: a rejected reproduction by the
+ * runner's own sentence, the runner's other reasons by their fixed words,
+ * then what the tests needed and did not have, and otherwise a fingerprint of
+ * the judge's notes with numbers and hashes set aside.
+ */
+export declare function reasonGist(verdict: SaidVerdict): string;
+/** The one quiet line said instead of a could-not-tell this session already heard. */
+export declare function quietLine(title: string, promiseId: string): string;
+export type SessionMemory = Readonly<{
+    /**
+     * The quiet line for a could-not-tell this session was already told for the
+     * same promise and reason. Otherwise nothing, and the verdict is noted as
+     * told; it is then said in full by the caller.
+     */
+    repeat: (verdict: SaidVerdict, title: string) => string | undefined;
+    /** Keep what was told. A record that cannot be written is left as it was. */
+    save: () => void;
+}>;
+/**
+ * What this session has been told, from the record in `directory`, or nothing
+ * without a session id, in which case every verdict is said in full.
+ */
+export declare function sessionMemory(directory: string, sessionId: string | undefined, now: Date): SessionMemory | undefined;

package/dist/judge-said.js

@@ -0,0 +1,181 @@
+import { createHash, randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+/**
+ * Which could-not-tell verdicts a coding session has already been told.
+ *
+ * Robert, 30 September 2026: say a given could-not-tell once per session. The
+ * first time a session hears that a promise could not be judged, it hears it
+ * in full; later in the same session, for the same promise and the same
+ * reason, it hears one quiet line. A different reason, a new session, or a
+ * host that names no session is told in full. Kept and broken are never
+ * shortened.
+ *
+ * The record lives in the judge log directory, which carries its own
+ * `.gitignore`. It holds session ids, promise ids and a short gist of each
+ * reason, never the reason's text, and it forgets a session a day after it
+ * was last heard from.
+ */
+export const SAID_FILE = "said.json";
+export const SAID_SCHEMA_VERSION = "balladeer-judge-said/v1";
+/** A session not heard from for this long is forgotten. */
+export const SAID_KEEP_MS = 24 * 60 * 60 * 1000;
+const MOST_SESSIONS = 50;
+const MOST_PER_SESSION = 200;
+function fingerprint(text) {
+    const flat = text
+        .toLowerCase()
+        .replace(/\b[0-9a-f]{7,64}\b/g, "#")
+        .replace(/\d+/g, "#")
+        .replace(/\s+/g, " ")
+        .trim();
+    return createHash("sha256").update(flat).digest("hex").slice(0, 16);
+}
+/** Reasons the runner writes itself, in fixed words. */
+const RUNNER_REASONS = [
+    ["unexercised", /^The judge answered kept without exercising ([^.]+)\./],
+    ["no-reproduction", /^The judge answered broken without a command that shows it\./],
+    ["no-answer", /^the judge's answer was not a verdict$/],
+];
+/**
+ * What the tests needed and did not have, as a judge tends to say it in its
+ * own words, which differ from one run to the next. Checked in this order.
+ */
+const NEEDS = [
+    ["database", /\b(databases?|postgres(ql)?|psql|mysql|mariadb|mongo(db)?|redis|sqlite)\b/],
+    ["browser", /\b(browsers?|playwright|puppeteer|chromium|selenium|webdriver|cypress)\b/],
+    [
+        "environment",
+        /\b(environment variables?|env vars?|api keys?|secrets?|credentials?|tokens?)\b|\.env\b/,
+    ],
+    [
+        "service",
+        /\b(services?|servers?|econnrefused|connection refused|unreachable|could not (connect|reach)|network|docker)\b/,
+    ],
+    [
+        "dependency",
+        /\b(not installed|missing dependenc(y|ies)|cannot find module|command not found|no such file)\b/,
+    ],
+    ["time", /\b(ran out|run out|running out|out of time|timed out|time limit|still working)\b/],
+];
+/**
+ * The gist of why a promise could not be judged, stable across the different
+ * words two runs use for the same reason: a rejected reproduction by the
+ * runner's own sentence, the runner's other reasons by their fixed words,
+ * then what the tests needed and did not have, and otherwise a fingerprint of
+ * the judge's notes with numbers and hashes set aside.
+ */
+export function reasonGist(verdict) {
+    if (verdict.reproductionRejected)
+        return `rejected:${fingerprint(verdict.reproductionRejected)}`;
+    for (const [gist, pattern] of RUNNER_REASONS) {
+        const found = pattern.exec(verdict.notes);
+        if (found !== null)
+            return found[1] === undefined ? gist : `${gist}:${found[1]}`;
+    }
+    const text = `${verdict.notes} ${verdict.nextStep ?? ""}`.toLowerCase();
+    for (const [gist, pattern] of NEEDS)
+        if (pattern.test(text))
+            return `needs:${gist}`;
+    return `notes:${fingerprint(verdict.notes)}`;
+}
+/** The one quiet line said instead of a could-not-tell this session already heard. */
+export function quietLine(title, promiseId) {
+    return `could not tell again: ${title} (${promiseId}), for the reason given earlier.`;
+}
+function readRecord(path, now) {
+    const empty = { schemaVersion: SAID_SCHEMA_VERSION, sessions: {} };
+    let raw;
+    try {
+        if (!existsSync(path))
+            return empty;
+        raw = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return empty;
+    }
+    if (raw === null || typeof raw !== "object")
+        return empty;
+    const sessions = raw.sessions;
+    if (raw.schemaVersion !== SAID_SCHEMA_VERSION ||
+        sessions === null ||
+        typeof sessions !== "object" ||
+        Array.isArray(sessions))
+        return empty;
+    const kept = {};
+    for (const [id, entry] of Object.entries(sessions)) {
+        const at = entry?.at;
+        const said = entry?.said;
+        if (typeof at !== "string" || !Array.isArray(said))
+            continue;
+        const time = Date.parse(at);
+        if (!Number.isFinite(time) || now.getTime() - time > SAID_KEEP_MS)
+            continue;
+        kept[id] = { at, said: said.filter((key) => typeof key === "string") };
+    }
+    return { schemaVersion: SAID_SCHEMA_VERSION, sessions: kept };
+}
+function writeRecord(directory, record) {
+    mkdirSync(directory, { recursive: true });
+    const ignore = join(directory, ".gitignore");
+    if (!existsSync(ignore))
+        writeFileSync(ignore, "*\n", "utf8");
+    const path = join(directory, SAID_FILE);
+    const temporary = join(directory, `.said-${randomBytes(6).toString("hex")}.tmp`);
+    writeFileSync(temporary, `${JSON.stringify(record)}\n`, { encoding: "utf8", flag: "wx" });
+    try {
+        renameSync(temporary, path);
+    }
+    catch (error) {
+        try {
+            unlinkSync(temporary);
+        }
+        catch {
+            /* Already gone. */
+        }
+        throw error;
+    }
+}
+/**
+ * What this session has been told, from the record in `directory`, or nothing
+ * without a session id, in which case every verdict is said in full.
+ */
+export function sessionMemory(directory, sessionId, now) {
+    if (sessionId === undefined)
+        return undefined;
+    const record = readRecord(join(directory, SAID_FILE), now);
+    const said = new Set(record.sessions[sessionId]?.said ?? []);
+    let heard = false;
+    return {
+        repeat: (verdict, title) => {
+            if (verdict.verdict !== "could_not_tell")
+                return undefined;
+            heard = true;
+            const key = `${verdict.promiseId} ${reasonGist(verdict)}`;
+            if (said.has(key))
+                return quietLine(title, verdict.promiseId);
+            said.add(key);
+            return undefined;
+        },
+        save: () => {
+            if (!heard)
+                return;
+            record.sessions[sessionId] = {
+                at: now.toISOString(),
+                said: [...said].slice(-MOST_PER_SESSION),
+            };
+            const newest = Object.entries(record.sessions)
+                .sort(([, a], [, b]) => Date.parse(b.at) - Date.parse(a.at))
+                .slice(0, MOST_SESSIONS);
+            try {
+                writeRecord(directory, {
+                    schemaVersion: SAID_SCHEMA_VERSION,
+                    sessions: Object.fromEntries(newest),
+                });
+            }
+            catch {
+                /* Unwritable: the next time is said in full, which is the safe side. */
+            }
+        },
+    };
+}

package/dist/promise-meaning.d.ts

@@ -33,6 +33,14 @@ export type PromiseDocument = Readonly<{
     title: string;
     semanticDigest: string;
     meaning: PromiseMeaning;
+    /**
+     * Whether a Balladeer check is bound to this promise, as `get_promise`
+     * answered through this repository's connection. Absent means unknown: a
+     * promise read from a file or rebuilt from a map's excerpt never carries it,
+     * and neither does an answer whose field is missing or not a boolean. It is
+     * never handed to a judge, which works from the meaning alone.
+     */
+    verifierBound?: boolean;
 }>;
 /** Deterministic JSON with sorted keys, the form Balladeer digests a meaning in. */
 export declare function canonicalJson(value: unknown): string;

package/dist/promise-meaning.js

@@ -245,7 +245,15 @@ export function connectionReader(input) {
                     return { ok: false, reason: olderServerRefusal(call.text) ?? call.text };
                 if (call.kind !== "result")
                     return { ok: false, reason: refusal(call.kind) };
-                return normalizePromise(call.structured);
+                const read = normalizePromise(call.structured);
+                if (!read.ok)
+                    return read;
+                // Only the connection's own answer says whether a check is bound;
+                // anything but a boolean there is left as unknown rather than guessed.
+                const bound = call.structured?.verifierBound;
+                return typeof bound === "boolean"
+                    ? { ok: true, promise: { ...read.promise, verifierBound: bound } }
+                    : read;
             },
             async list(options) {
                 const max = options?.max ?? Number.POSITIVE_INFINITY;

package/dist/relay.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The relay: the person hears from their own agent what Balladeer did.
+ *
+ * Robert, 2026-09-30 (plans/promise-relations/rulings-2026-09-30.md, section
+ * 1): every action Balladeer takes is transparent to the person, and it is the
+ * person's own coding agent that tells them, in its own words and in one line,
+ * never by pasting what a tool returned. Agreed as promise
+ * prom_45ef4e3d9e5545a9a411.
+ *
+ * A Balladeer tool that changes something returns `forThePerson`: one sentence
+ * written from what actually happened, and the promise it concerns. Host hooks
+ * can make the relay closer to certain (setup installs only the first):
+ *
+ * - after the tool call, a note the agent reads before it replies: tell the
+ *   person this, in your own words;
+ * - when the agent is about to finish, a check that its reply mentions the
+ *   promise. If it does not, the agent is sent back once, with the reason.
+ *   Never twice, and nothing here writes or rewrites the reply.
+ *
+ * Everything stays on this machine. Only the lab's stop check keeps pending
+ * notes, per session, in a private file it names; nothing from the reply is
+ * stored or sent.
+ */
+export declare const RELAY_FIELD = "forThePerson";
+export type Notice = Readonly<{
+    /** One sentence for the person, from what Balladeer actually did. */
+    sentence: string;
+    /** The promise titles the action concerns; the reply must name at least one. */
+    subjects: readonly string[];
+}>;
+/**
+ * The notice a Balladeer tool returned, read from whatever shape the host hands
+ * a hook: the MCP result object, its text content, or that text parsed.
+ */
+export declare function noticeFromToolResponse(response: unknown): Notice | undefined;
+/** What the agent reads after the tool call, before it replies. */
+export declare function relayNote(notice: Notice): string;
+/**
+ * Whether a reply mentions a promise: most of its title's words, in any order.
+ * Deliberately loose, because the agent is meant to use its own words; a miss
+ * costs one extra nudge, never a blocked reply.
+ */
+export declare function mentions(reply: string, subject: string): boolean;
+/** Whether the reply already tells the person about this notice. */
+export declare function relayed(reply: string, notice: Notice): boolean;
+/** What the stop check sends the agent back with. */
+export declare function reminder(notices: readonly Notice[]): string;
+export declare function readPending(directory: string, sessionId: string): Notice[];
+export declare function writePending(directory: string, sessionId: string, notices: readonly Notice[]): void;
+export type HookInput = Readonly<{
+    hook_event_name?: unknown;
+    session_id?: unknown;
+    tool_name?: unknown;
+    tool_response?: unknown;
+    tool_output?: unknown;
+    last_assistant_message?: unknown;
+    stop_hook_active?: unknown;
+}>;
+/** Only Balladeer's own tools are read, whatever the host names the server. */
+export declare function isBalladeerTool(name: unknown): boolean;
+/**
+ * One hook event, start to finish. The product installs only the post-tool
+ * note and passes no directory, so it keeps no state at all: across 135 lab
+ * sessions the stop check sent an agent back once, because agents always name
+ * the promise, so it was not installed (plans/promise-relations/plan.md, step
+ * 1 result). The relay lab still passes a directory to measure it.
+ *
+ * Returns what to print on stdout (the host's JSON), or nothing. Never throws:
+ * a relay that fails must not stop the work.
+ */
+export declare function relayHook(input: HookInput, directory?: string): string | undefined;

package/dist/relay.js

@@ -0,0 +1,193 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * The relay: the person hears from their own agent what Balladeer did.
+ *
+ * Robert, 2026-09-30 (plans/promise-relations/rulings-2026-09-30.md, section
+ * 1): every action Balladeer takes is transparent to the person, and it is the
+ * person's own coding agent that tells them, in its own words and in one line,
+ * never by pasting what a tool returned. Agreed as promise
+ * prom_45ef4e3d9e5545a9a411.
+ *
+ * A Balladeer tool that changes something returns `forThePerson`: one sentence
+ * written from what actually happened, and the promise it concerns. Host hooks
+ * can make the relay closer to certain (setup installs only the first):
+ *
+ * - after the tool call, a note the agent reads before it replies: tell the
+ *   person this, in your own words;
+ * - when the agent is about to finish, a check that its reply mentions the
+ *   promise. If it does not, the agent is sent back once, with the reason.
+ *   Never twice, and nothing here writes or rewrites the reply.
+ *
+ * Everything stays on this machine. Only the lab's stop check keeps pending
+ * notes, per session, in a private file it names; nothing from the reply is
+ * stored or sent.
+ */
+export const RELAY_FIELD = "forThePerson";
+const MAX_SENTENCE = 400;
+const MAX_SUBJECT = 200;
+const MAX_PENDING = 8;
+function clean(value, limit) {
+    if (typeof value !== "string")
+        return undefined;
+    const text = value.replace(/[\u0000-\u001f\u007f]/g, " ").trim();
+    return text ? text.slice(0, limit) : undefined;
+}
+function noticeFrom(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    const sentence = clean(record.sentence, MAX_SENTENCE);
+    if (!sentence)
+        return undefined;
+    const subjects = (Array.isArray(record.subjects) ? record.subjects : [])
+        .map((s) => clean(s, MAX_SUBJECT))
+        .filter((s) => s !== undefined)
+        .slice(0, 4);
+    return { sentence, subjects };
+}
+/**
+ * The notice a Balladeer tool returned, read from whatever shape the host hands
+ * a hook: the MCP result object, its text content, or that text parsed.
+ */
+export function noticeFromToolResponse(response) {
+    const visit = (value, depth) => {
+        if (depth > 4 || value === null || value === undefined)
+            return undefined;
+        if (typeof value === "string") {
+            if (!value.includes(RELAY_FIELD))
+                return undefined;
+            try {
+                return visit(JSON.parse(value), depth + 1);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                const found = visit(item, depth + 1);
+                if (found)
+                    return found;
+            }
+            return undefined;
+        }
+        if (typeof value !== "object")
+            return undefined;
+        const record = value;
+        if (RELAY_FIELD in record)
+            return noticeFrom(record[RELAY_FIELD]);
+        for (const key of ["structuredContent", "content", "text", "result", "tool_response"]) {
+            const found = visit(record[key], depth + 1);
+            if (found)
+                return found;
+        }
+        return undefined;
+    };
+    return visit(response, 0);
+}
+/** What the agent reads after the tool call, before it replies. */
+export function relayNote(notice) {
+    return (`Balladeer just acted on the person's behalf: ${notice.sentence} ` +
+        "Make sure your reply tells them this, in your own words and in about one line.");
+}
+const WORD = /[a-z0-9]+/g;
+const QUIET = new Set("a an the and or of to in on for with is are be by as at from that this it its not no".split(" "));
+function words(text) {
+    return (text.toLowerCase().match(WORD) ?? []).filter((w) => w.length > 2 && !QUIET.has(w));
+}
+/**
+ * Whether a reply mentions a promise: most of its title's words, in any order.
+ * Deliberately loose, because the agent is meant to use its own words; a miss
+ * costs one extra nudge, never a blocked reply.
+ */
+export function mentions(reply, subject) {
+    const wanted = [...new Set(words(subject))];
+    if (!wanted.length)
+        return true;
+    const said = new Set(words(reply));
+    const found = wanted.filter((w) => said.has(w) || said.has(w.replace(/s$/, ""))).length;
+    return found / wanted.length >= 0.5;
+}
+/** Whether the reply already tells the person about this notice. */
+export function relayed(reply, notice) {
+    return notice.subjects.length === 0 || notice.subjects.some((s) => mentions(reply, s));
+}
+/** What the stop check sends the agent back with. */
+export function reminder(notices) {
+    const told = notices.map((n) => n.sentence).join(" ");
+    return (`Your reply does not yet tell the person what Balladeer did: ${told} ` +
+        "Add it in your own words, in about one line.");
+}
+function pendingPath(directory, sessionId) {
+    return join(directory, `${createHash("sha256").update(sessionId).digest("hex")}.relay.json`);
+}
+export function readPending(directory, sessionId) {
+    try {
+        const parsed = JSON.parse(readFileSync(pendingPath(directory, sessionId), "utf8"));
+        return parsed.schemaVersion === 1 && Array.isArray(parsed.notices)
+            ? parsed.notices.map(noticeFrom).filter((n) => n !== undefined)
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function writePending(directory, sessionId, notices) {
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const path = pendingPath(directory, sessionId);
+    const temporary = `${path}.${process.pid}.tmp`;
+    const body = { schemaVersion: 1, notices: notices.slice(-MAX_PENDING) };
+    writeFileSync(temporary, JSON.stringify(body), { mode: 0o600 });
+    renameSync(temporary, path);
+}
+/** Only Balladeer's own tools are read, whatever the host names the server. */
+export function isBalladeerTool(name) {
+    return typeof name === "string" && /^mcp__balladeer[a-z0-9_-]*__/i.test(name);
+}
+/**
+ * One hook event, start to finish. The product installs only the post-tool
+ * note and passes no directory, so it keeps no state at all: across 135 lab
+ * sessions the stop check sent an agent back once, because agents always name
+ * the promise, so it was not installed (plans/promise-relations/plan.md, step
+ * 1 result). The relay lab still passes a directory to measure it.
+ *
+ * Returns what to print on stdout (the host's JSON), or nothing. Never throws:
+ * a relay that fails must not stop the work.
+ */
+export function relayHook(input, directory) {
+    try {
+        const sessionId = typeof input.session_id === "string" ? input.session_id : undefined;
+        if (input.hook_event_name === "PostToolUse") {
+            if (!isBalladeerTool(input.tool_name))
+                return undefined;
+            const notice = noticeFromToolResponse(input.tool_response ?? input.tool_output);
+            if (!notice)
+                return undefined;
+            if (sessionId && directory)
+                writePending(directory, sessionId, [...readPending(directory, sessionId), notice]);
+            return JSON.stringify({
+                hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: relayNote(notice) },
+            });
+        }
+        if (input.hook_event_name === "Stop") {
+            if (!sessionId || !directory)
+                return undefined;
+            const pending = readPending(directory, sessionId);
+            if (!pending.length)
+                return undefined;
+            const reply = typeof input.last_assistant_message === "string" ? input.last_assistant_message : "";
+            const missing = pending.filter((n) => !relayed(reply, n));
+            // Relayed, or already sent back once: either way, this note is done.
+            writePending(directory, sessionId, []);
+            if (!missing.length || input.stop_hook_active === true)
+                return undefined;
+            return JSON.stringify({ decision: "block", reason: reminder(missing) });
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/remove-earlier.js

@@ -99,10 +99,12 @@ function claudeConnector(home, controlPlane, now) {
 // path (1.0.11 and later). The July client's hook ran nothing of the kind, so
 // that shape is the line: a hook that names it is ours and is never "earlier".
 // Found on 22 September 2026: the installed-path form was being removed as
-// the older client on every setup run, leaving the laptop with no hook.
+// the older client on every setup run, leaving the laptop with no hook. The
+// push check setup writes beside it (`judge --hook claude|codex`, from 30
+// September 2026) is ours by the same rule.
 const isEarlierHook = (command) => typeof command === "string" &&
     /balladeer/i.test(command) &&
-    !/\bguidance --hook (?:claude|codex)\b/.test(command) &&
+    !/\b(?:guidance|judge) --hook (?:claude|codex)\b/.test(command) &&
     !/balladeer@(?:latest|\d+\.\d+\.\d+)\b/.test(command) &&
     !/\bpackages[/\\]cli[/\\]dist[/\\]cli\.js\b/.test(command);
 function claudeSettings(home, now) {

package/dist/risk/index.d.ts

@@ -14,7 +14,7 @@ export { isTestPath, languageOf } from "./paths.js";
 export { assessChange, buildGraphAt, readBehaviorMaps, watchedResources, type AssessOptions, type Assessment, type MapProblem, } from "./pipeline.js";
 export { churnPriors, priorBreaksFromJudgeLog, readPriors } from "./priors.js";
 export { mentionsResource, normalizeRoute, parseResourceRef, resourceKey, resourcesInLine, resourcesMatch, routeFromPath, type ResourceRef, } from "./resources.js";
-export { BAND_THRESHOLDS, bandFor, byRisk, directness, forwardDecay, mapSeeds, reverseDecay, scoreChange, seededShuffle, WEIGHTS, type Prior, type ScoreOptions, type Weights, } from "./score.js";
+export { BAND_THRESHOLDS, bandFor, byRisk, directness, forwardDecay, mapSeeds, reverseDecay, riskOrder, scoreChange, seededShuffle, WEIGHTS, type Prior, type RiskOrderKey, type ScoreOptions, type Weights, } from "./score.js";
 export { declaredSymbols, loadTypeScript, type DeclaredSymbol } from "./symbols.js";
 export { buildIdf, cosine, identifierTokens, STOP_WORDS, words } from "./text.js";
 export { parseChangeExtraction, parseRiskReport, type ParseResult } from "./validate.js";

package/dist/risk/index.js

@@ -14,7 +14,7 @@ export { isTestPath, languageOf } from "./paths.js";
 export { assessChange, buildGraphAt, readBehaviorMaps, watchedResources, } from "./pipeline.js";
 export { churnPriors, priorBreaksFromJudgeLog, readPriors } from "./priors.js";
 export { mentionsResource, normalizeRoute, parseResourceRef, resourceKey, resourcesInLine, resourcesMatch, routeFromPath, } from "./resources.js";
-export { BAND_THRESHOLDS, bandFor, byRisk, directness, forwardDecay, mapSeeds, reverseDecay, scoreChange, seededShuffle, WEIGHTS, } from "./score.js";
+export { BAND_THRESHOLDS, bandFor, byRisk, directness, forwardDecay, mapSeeds, reverseDecay, riskOrder, scoreChange, seededShuffle, WEIGHTS, } from "./score.js";
 export { declaredSymbols, loadTypeScript } from "./symbols.js";
 export { buildIdf, cosine, identifierTokens, STOP_WORDS, words } from "./text.js";
 export { parseChangeExtraction, parseRiskReport } from "./validate.js";

package/dist/risk/score.d.ts

@@ -65,6 +65,16 @@ export declare function directness(features: PromiseRisk["features"]): 0 | 1 | 2
  * is a tier and not a larger number. Scores and bands are unchanged.
  */
 export declare function byRisk(a: PromiseRisk, b: PromiseRisk): number;
+/** What the order reads from one entry: enough to order a report read back from its JSON. */
+export type RiskOrderKey = Readonly<{
+    promiseId: string;
+    score: number;
+    features: PromiseRisk["features"];
+    /** The total weight of the entry's reasons. */
+    evidence: number;
+}>;
+/** The order `byRisk` describes, on the fields it reads, so the judge ranks by the same rule. */
+export declare function riskOrder(a: RiskOrderKey, b: RiskOrderKey): number;
 /** The files the promise's behavior runs through, where the import closures start. Tests excluded. */
 export declare function mapSeeds(map: BehaviorMap): string[];
 /** A seeded shuffle, so the random baseline is the same list every time for the same change. */

package/dist/risk/score.js

@@ -95,10 +95,19 @@ export function directness(features) {
  * is a tier and not a larger number. Scores and bands are unchanged.
  */
 export function byRisk(a, b) {
-    const evidence = (p) => p.reasons.reduce((sum, reason) => sum + reason.weight, 0);
+    const key = (p) => ({
+        promiseId: p.promiseId,
+        score: p.score,
+        features: p.features,
+        evidence: p.reasons.reduce((sum, reason) => sum + reason.weight, 0),
+    });
+    return riskOrder(key(a), key(b));
+}
+/** The order `byRisk` describes, on the fields it reads, so the judge ranks by the same rule. */
+export function riskOrder(a, b) {
     return (directness(b.features) - directness(a.features) ||
         b.score - a.score ||
-        evidence(b) - evidence(a) ||
+        b.evidence - a.evidence ||
         a.promiseId.localeCompare(b.promiseId));
 }
 /** Independent signals combined so that none can push past 1 and more never lowers it. */

package/dist/scratch-worktree.d.ts

@@ -48,4 +48,8 @@ export type CarriedFile = Readonly<{
  * a reproduction in a new file for that reason.
  */
 export declare function newFiles(worktree: string): Promise<CarriedFile[]>;
-export declare function carryFiles(from: string, to: string, files: readonly CarriedFile[]): void;
+/**
+ * Copy files from one directory into another at the same relative paths, and
+ * return the ones copied. A path that would land outside `to` is skipped.
+ */
+export declare function carryFiles(from: string, to: string, files: readonly CarriedFile[]): CarriedFile[];

package/dist/scratch-worktree.js

@@ -2,7 +2,7 @@ import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, symlinkSync, } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join, relative, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { runCommand } from "./gh.js";
 /** Every worktree this process made and has not removed, for a signal handler to clear. */
 const live = new Map();
@@ -141,13 +141,20 @@ export async function newFiles(worktree) {
     }
     return files.sort((a, b) => a.path.localeCompare(b.path));
 }
+/**
+ * Copy files from one directory into another at the same relative paths, and
+ * return the ones copied. A path that would land outside `to` is skipped.
+ */
 export function carryFiles(from, to, files) {
+    const carried = [];
     for (const file of files) {
         const target = resolve(to, file.path);
         const inside = relative(to, target);
-        if (inside.startsWith("..") || inside === "")
+        if (inside.startsWith("..") || inside === "" || isAbsolute(inside))
             continue;
         mkdirSync(dirname(target), { recursive: true });
         copyFileSync(join(from, file.path), target);
+        carried.push(file);
     }
+    return carried;
 }