balladeer 1.0.18 → 1.0.20

package/dist/review-reporting.js

@@ -0,0 +1,319 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { runCommand } from "./gh.js";
+import { agentEndpoint } from "./guidance.js";
+import { connectionAgent } from "./promise-meaning.js";
+import { CLIENT_HEADER, CLIENT_HEADER_VALUE } from "./wire.js";
+const SHA = /^[0-9a-f]{40}$/;
+const DIGEST = /^sha256:[0-9a-f]{64}$/;
+const REF = /^refs\/heads\/[A-Za-z0-9._/-]{1,244}$/;
+const REASONS = new Set([
+    "test_setup_needed",
+    "cases_not_checked",
+    "reproduction_not_confirmed",
+    "review_inconclusive",
+]);
+const FIELDS = new Set([
+    "promiseId",
+    "semanticDigest",
+    "sourceSha",
+    "baseSha",
+    "verdict",
+    "reproductionDigest",
+    "briefRevision",
+    "client",
+    "sessionId",
+    "changeRef",
+    "reasonCode",
+    "supersedes",
+]);
+/** Validate the exact upload shape again, including retries of local files. */
+export function isReviewPayload(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const p = value;
+    return (Object.keys(p).every((k) => FIELDS.has(k)) &&
+        typeof p.promiseId === "string" &&
+        /^prom_[A-Za-z0-9_-]{1,120}$/.test(p.promiseId) &&
+        typeof p.semanticDigest === "string" &&
+        DIGEST.test(p.semanticDigest) &&
+        typeof p.sourceSha === "string" &&
+        SHA.test(p.sourceSha) &&
+        typeof p.baseSha === "string" &&
+        SHA.test(p.baseSha) &&
+        p.sourceSha !== p.baseSha &&
+        typeof p.verdict === "string" &&
+        ["kept", "broken", "could_not_tell"].includes(p.verdict) &&
+        typeof p.briefRevision === "string" &&
+        /^[a-z][a-z0-9-]{0,47}\/v[1-9][0-9]{0,5}$/.test(p.briefRevision) &&
+        typeof p.client === "string" &&
+        ["claude", "codex", "git", "other"].includes(p.client) &&
+        (p.reproductionDigest === undefined ||
+            (typeof p.reproductionDigest === "string" && DIGEST.test(p.reproductionDigest))) &&
+        (p.verdict !== "broken" || p.reproductionDigest !== undefined) &&
+        (p.sessionId === undefined ||
+            (typeof p.sessionId === "string" && /^bs_[0-9a-f]{32}$/.test(p.sessionId))) &&
+        (p.changeRef === undefined || (typeof p.changeRef === "string" && REF.test(p.changeRef))) &&
+        (p.reasonCode === undefined ||
+            (typeof p.reasonCode === "string" && REASONS.has(p.reasonCode))) &&
+        (p.supersedes === undefined ||
+            (Array.isArray(p.supersedes) &&
+                p.supersedes.length <= 64 &&
+                p.supersedes.every((v) => typeof v === "string" && SHA.test(v)))));
+}
+/** Validate what serialization produced, then reuse those exact upload bytes. */
+function snapshot(value) {
+    try {
+        if (!isReviewPayload(value))
+            return;
+        const body = JSON.stringify(value);
+        if (Buffer.byteLength(body, "utf8") > 8192)
+            return;
+        const payload = JSON.parse(body);
+        return isReviewPayload(payload) ? { payload, body } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function reviewPayload(verdict, options = {}) {
+    return {
+        promiseId: verdict.promiseId,
+        semanticDigest: verdict.semanticDigest,
+        sourceSha: verdict.head,
+        baseSha: verdict.base,
+        verdict: verdict.verdict,
+        briefRevision: verdict.briefRevision,
+        client: options.client ?? verdict.judge.client,
+        ...(verdict.verdict === "broken" && verdict.reproduction
+            ? { reproductionDigest: verdict.reproduction.digest }
+            : {}),
+        ...(options.changeRef ? { changeRef: options.changeRef } : {}),
+        ...(options.sessionId ? { sessionId: options.sessionId } : {}),
+        ...(verdict.verdict !== "could_not_tell"
+            ? {}
+            : {
+                reasonCode: verdict.nextStep
+                    ? "test_setup_needed"
+                    : verdict.reproductionRejected
+                        ? "reproduction_not_confirmed"
+                        : verdict.notes.startsWith("The judge answered kept without exercising")
+                            ? "cases_not_checked"
+                            : "review_inconclusive",
+            }),
+    };
+}
+function atomic(path, value) {
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, JSON.stringify(value), { mode: 0o600 });
+    renameSync(temporary, path);
+}
+function read(path) {
+    try {
+        const text = readFileSync(path, "utf8");
+        if (text.length > 8192)
+            return;
+        const value = JSON.parse(text);
+        return isReviewPayload(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function reporterFor(agent, fetchImpl = fetch) {
+    return async (payload) => {
+        const captured = snapshot(payload);
+        if (captured === undefined)
+            return 400;
+        try {
+            const response = await fetchImpl(agentEndpoint(agent, "/api/promise-checks"), {
+                method: "POST",
+                redirect: "manual",
+                signal: AbortSignal.timeout(3000),
+                headers: {
+                    authorization: `Bearer ${agent.token}`,
+                    [CLIENT_HEADER]: CLIENT_HEADER_VALUE,
+                    "content-type": "application/json",
+                },
+                body: captured.body,
+            });
+            if (response.status !== 200 && response.status !== 201) {
+                await response.body?.cancel();
+                return response.status;
+            }
+            // An HTTP success alone is not a receipt for this particular review.
+            const reader = response.body?.getReader();
+            if (!reader)
+                return 503;
+            let text = "";
+            for (;;) {
+                const part = await reader.read();
+                if (part.done)
+                    break;
+                text += new TextDecoder().decode(part.value);
+                if (text.length > 8192) {
+                    await reader.cancel();
+                    return 503;
+                }
+            }
+            const receipt = JSON.parse(text);
+            return receipt.recorded === true &&
+                receipt.promiseId === captured.payload.promiseId &&
+                receipt.sourceSha === captured.payload.sourceSha &&
+                receipt.verdict === captured.payload.verdict &&
+                receipt.protectionChanged === false
+                ? response.status
+                : 503;
+        }
+        catch {
+            return 503;
+        }
+    };
+}
+/** Durable, idempotent retries, partitioned by server/workspace/repository. */
+export async function deliverReviews(input) {
+    if (input.send === null)
+        return;
+    const found = connectionAgent({
+        environment: input.environment,
+        controlPlane: input.controlPlane,
+        cwd: input.root,
+    });
+    if (!found.ok && input.send === undefined)
+        return;
+    const partition = found.ok
+        ? `${found.agent.controlPlane}:${found.agent.workspaceId}:${found.agent.repositoryId}`
+        : "test";
+    const directory = join(input.root, ".continuity/judge-log/reporting", createHash("sha256").update(partition).digest("hex"));
+    const pending = join(directory, "pending"), sent = join(directory, "sent");
+    mkdirSync(pending, { recursive: true });
+    mkdirSync(sent, { recursive: true });
+    const refResult = await runCommand("git", ["-C", input.root, "symbolic-ref", "-q", "HEAD"]);
+    const currentHead = await runCommand("git", ["-C", input.root, "rev-parse", "HEAD"]);
+    const changeRef = REF.test(refResult.stdout.trim()) ? refResult.stdout.trim() : undefined;
+    for (const original of input.payloads) {
+        const captured = snapshot(original);
+        if (captured === undefined)
+            continue;
+        const frozen = captured.payload;
+        const payload = {
+            ...frozen,
+            ...(frozen.changeRef || frozen.sourceSha !== currentHead.stdout.trim()
+                ? {}
+                : changeRef
+                    ? { changeRef }
+                    : {}),
+        };
+        if (!isReviewPayload(payload))
+            continue;
+        const key = createHash("sha256")
+            .update([
+            payload.promiseId,
+            payload.semanticDigest,
+            payload.sourceSha,
+            payload.verdict,
+            payload.changeRef ?? "",
+        ].join(":"))
+            .digest("hex") + ".json";
+        if (existsSync(join(sent, key)) || existsSync(join(pending, key)))
+            continue;
+        const historyKey = createHash("sha256")
+            .update([payload.promiseId, payload.semanticDigest, payload.changeRef ?? ""].join(":"))
+            .digest("hex") + ".heads";
+        let previous = [];
+        try {
+            const value = JSON.parse(readFileSync(join(sent, historyKey), "utf8"));
+            if (Array.isArray(value))
+                previous = value
+                    .filter((sha) => typeof sha === "string" && SHA.test(sha))
+                    .slice(-64);
+        }
+        catch {
+            /* First report of this meaning and branch. */
+        }
+        // A later fixed change may be queued while an earlier failure is still
+        // offline. Preserve its ancestry before either receipt reaches the server.
+        for (const name of readdirSync(pending)
+            .filter((name) => /^[0-9a-f]{64}\.json$/.test(name))
+            .slice(-64)) {
+            const queued = read(join(pending, name));
+            if (queued &&
+                queued.promiseId === payload.promiseId &&
+                queued.semanticDigest === payload.semanticDigest &&
+                queued.changeRef === payload.changeRef)
+                previous.push(queued.sourceSha);
+        }
+        previous = [...new Set(previous)].slice(-64);
+        const supersedes = [];
+        for (const sha of previous) {
+            if (sha === payload.sourceSha)
+                continue;
+            const ancestor = await runCommand("git", [
+                "-C",
+                input.root,
+                "merge-base",
+                "--is-ancestor",
+                sha,
+                payload.sourceSha,
+            ]);
+            if (ancestor.code === 0)
+                supersedes.push(sha);
+        }
+        if (supersedes.length)
+            payload.supersedes = supersedes;
+        atomic(join(pending, key), payload);
+    }
+    const send = input.send ?? (found.ok ? reporterFor(found.agent) : undefined);
+    if (!send)
+        return;
+    let failures = 0, refused = 0;
+    const deadline = Date.now() + 5000;
+    // Stop on a transient failure to preserve delivery order; retry next push.
+    for (const name of readdirSync(pending)
+        .filter((name) => /^[0-9a-f]{64}\.json$/.test(name))
+        .sort((a, b) => statSync(join(pending, a)).mtimeMs - statSync(join(pending, b)).mtimeMs ||
+        a.localeCompare(b))
+        .slice(0, 64)) {
+        if (Date.now() >= deadline)
+            break;
+        const path = join(pending, name), payload = read(path);
+        if (!payload) {
+            refused++;
+            renameSync(path, `${path}.refused`);
+            continue;
+        }
+        const status = await send(payload).catch(() => 503);
+        if (status === 200 || status === 201) {
+            atomic(join(sent, name), payload);
+            const historyKey = createHash("sha256")
+                .update([payload.promiseId, payload.semanticDigest, payload.changeRef ?? ""].join(":"))
+                .digest("hex") + ".heads";
+            let heads = [];
+            try {
+                const value = JSON.parse(readFileSync(join(sent, historyKey), "utf8"));
+                if (Array.isArray(value))
+                    heads = value.filter((sha) => typeof sha === "string" && SHA.test(sha));
+            }
+            catch {
+                /* First delivery. */
+            }
+            atomic(join(sent, historyKey), [...new Set([...heads, payload.sourceSha])].slice(-64));
+            rmSync(path);
+        }
+        else if (status === 400 || status === 404 || status === 409 || status === 410) {
+            refused++;
+            renameSync(path, `${path}.refused`);
+        }
+        else {
+            failures++;
+            break;
+        }
+    }
+    const waiting = readdirSync(pending).filter((name) => name.endsWith(".json")).length;
+    if (failures || waiting)
+        return `Review results are kept on this machine for retry; ${waiting} have not reached Balladeer yet.`;
+    if (refused)
+        return "Balladeer could not accept some review results. They stay on this machine; read the current commitment and review again.";
+    return undefined;
+}

package/dist/review-selection.d.ts

@@ -0,0 +1,33 @@
+import type { Features } from "./risk/contract.js";
+/** A challenger selector. The direct baseline remains the serving default. */
+export type ReviewRiskEntry = Readonly<{
+    promiseId: string;
+    score: number;
+    band: string;
+    features?: Features;
+    evidence?: number;
+}>;
+export type TargetedRiskCandidate = Readonly<{
+    promiseId: string;
+    signals: readonly ("resource" | "sink" | "intent")[];
+}>;
+/**
+ * Strong indirect evidence deserves measurement separately from graph distance.
+ * A high score alone is insufficient: weak topic/graph signals can saturate it.
+ * These additions have tier-2 resource, sink, or reversal evidence, and no cap
+ * can quietly drop one. Nothing here enables them in the push-check default.
+ */
+export declare function targetedRiskCandidates(entries: readonly ReviewRiskEntry[], excluded?: ReadonlySet<string>): TargetedRiskCandidate[];
+/** Only repository-visible, already authorized targets reach a local backstop. */
+export declare function remainingVisibleTargets(visible: readonly string[], selected: ReadonlySet<string>): string[];
+/**
+ * Parse a local model's bounded selection. It can choose only offered ids;
+ * malformed output is Unknown, never an authoritative "nothing applies".
+ */
+export declare function readRelevanceBackstopSelection(value: unknown, candidates: ReadonlySet<string>): {
+    ok: true;
+    promiseIds: string[];
+} | {
+    ok: false;
+    reason: string;
+};

package/dist/review-selection.js

@@ -0,0 +1,64 @@
+import { BAND_THRESHOLDS, directness, riskOrder } from "./risk/score.js";
+/**
+ * Strong indirect evidence deserves measurement separately from graph distance.
+ * A high score alone is insufficient: weak topic/graph signals can saturate it.
+ * These additions have tier-2 resource, sink, or reversal evidence, and no cap
+ * can quietly drop one. Nothing here enables them in the push-check default.
+ */
+export function targetedRiskCandidates(entries, excluded = new Set()) {
+    const eligible = entries
+        .filter((entry) => {
+        const f = entry.features;
+        return (!excluded.has(entry.promiseId) &&
+            entry.band !== "unmapped" &&
+            Number.isFinite(entry.score) &&
+            entry.score >= BAND_THRESHOLDS.high &&
+            f !== undefined &&
+            directness(f) === 2 &&
+            ((Number.isFinite(f.resource_overlap) && f.resource_overlap > 0) ||
+                (Number.isFinite(f.sink_reach) && f.sink_reach > 0) ||
+                (Number.isFinite(f.intent_clash) && f.intent_clash >= 0.5)));
+    })
+        .sort((a, b) => riskOrder({
+        promiseId: a.promiseId,
+        score: a.score,
+        features: a.features,
+        evidence: a.evidence ?? 0,
+    }, {
+        promiseId: b.promiseId,
+        score: b.score,
+        features: b.features,
+        evidence: b.evidence ?? 0,
+    }));
+    const seen = new Set();
+    return eligible.flatMap((entry) => {
+        if (seen.has(entry.promiseId))
+            return [];
+        seen.add(entry.promiseId);
+        const f = entry.features;
+        const signals = [];
+        if (Number.isFinite(f.resource_overlap) && f.resource_overlap > 0)
+            signals.push("resource");
+        if (Number.isFinite(f.sink_reach) && f.sink_reach > 0)
+            signals.push("sink");
+        if (Number.isFinite(f.intent_clash) && f.intent_clash >= 0.5)
+            signals.push("intent");
+        return [{ promiseId: entry.promiseId, signals }];
+    });
+}
+/** Only repository-visible, already authorized targets reach a local backstop. */
+export function remainingVisibleTargets(visible, selected) {
+    return [...new Set(visible)].filter((id) => !selected.has(id));
+}
+/**
+ * Parse a local model's bounded selection. It can choose only offered ids;
+ * malformed output is Unknown, never an authoritative "nothing applies".
+ */
+export function readRelevanceBackstopSelection(value, candidates) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return { ok: false, reason: "the relevance backstop did not return a selection" };
+    const ids = value.promiseIds;
+    if (!Array.isArray(ids) || ids.some((id) => typeof id !== "string" || !candidates.has(id)))
+        return { ok: false, reason: "the relevance backstop selected a promise it was not offered" };
+    return { ok: true, promiseIds: [...new Set(ids)] };
+}

package/dist/review-settings.d.ts

@@ -0,0 +1,6 @@
+/** Wire values from app Settings. Keep this dependency-free for the installed CLI. */
+export type ReviewSettings = Readonly<{
+    concurrency: number;
+    budgetSeconds: number;
+}>;
+export declare function readReviewSettings(raw: unknown): ReviewSettings | undefined;

package/dist/review-settings.js

@@ -0,0 +1,9 @@
+export function readReviewSettings(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return undefined;
+    const value = raw;
+    const whole = (n, max) => typeof n === "number" && Number.isInteger(n) && n >= 1 && n <= max;
+    return whole(value.concurrency, 16) && whole(value.budgetSeconds, 600)
+        ? { concurrency: value.concurrency, budgetSeconds: value.budgetSeconds }
+        : undefined;
+}

package/dist/self-update.d.ts

@@ -29,10 +29,10 @@ export declare function selfUpdateState(environment: NodeJS.ProcessEnv): SelfUpd
  */
 export declare function resolveLaunch(specifier: string, environment: NodeJS.ProcessEnv, execPath?: string, exists?: (path: string) => boolean): Launch;
 /**
- * Start the update when the server named a newer release and none was
- * started today. Answers whether one was started, for the caller's own
+ * Start the update when the server named a newer release and an attempt
+ * toward it is due (`due`). Answers whether one was started, for the caller's own
  * record; the session hears nothing either way. A launch that could not start
- * leaves no stamp, so the next session start tries again rather than waiting
+ * leaves no stamp, so the next hook fire tries again rather than waiting
  * a day for the same failure.
  */
 export declare function startSelfUpdateIfDue(newer: string | undefined, deps: SelfUpdateDeps): boolean;

package/dist/self-update.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { delimiter, dirname, join } from "node:path";
+import { older } from "./currency.js";
 import { HOOK_SPECIFIER } from "./release.js";
 import { configHome } from "./store.js";
 /**
@@ -24,10 +25,22 @@ import { configHome } from "./store.js";
  * and what happened is kept in a small state file the next hook fire reports
  * to the server, so a laptop that cannot update is visible on the scorecard
  * instead of looking merely behind.
+ *
+ * What changed on 1 October 2026, from Robert's own laptop: it stayed on
+ * 1.0.16 through two releases while in use all day. Two rules held it. Only a
+ * session start began an install, and his sessions run for days, so the hooks
+ * that did fire (a prompt, a subagent) never asked. And the day's stamp was
+ * one stamp for every version: an attempt toward 1.0.15 at 03:20 held back
+ * 1.0.17 until 03:20 the next day, though a manual update had already passed
+ * 1.0.15. Now any guidance hook fire can begin the install, and a release
+ * newer than the one the last attempt aimed at may begin one an hour after
+ * it, rather than a day.
  */
 const STAMP = "self-update.json";
 const STATE = "self-update-state.json";
 const DAY_MS = 24 * 60 * 60 * 1000;
+const HOUR_MS = 60 * 60 * 1000;
+const VERSION = /^\d{1,4}\.\d{1,4}\.\d{1,4}$/;
 /** Set on the child so the install it runs can record how it ended. */
 export const SELF_UPDATE_ENVIRONMENT = "BALLADEER_SELF_UPDATE";
 const STATE_PATTERN = /^(?:started|unstartable|installed|failed):[A-Za-z0-9._-]{1,40}$/;
@@ -37,18 +50,35 @@ function stampPath(environment) {
 function statePath(environment) {
     return join(configHome(environment), STATE);
 }
-function lastStarted(environment) {
+/** The last attempt: when it started and which release it aimed at, when it said. */
+function lastAttempt(environment) {
     const path = stampPath(environment);
     if (!existsSync(path))
-        return 0;
+        return { startedAt: 0 };
     try {
         const parsed = JSON.parse(readFileSync(path, "utf8"));
-        return typeof parsed.startedAt === "number" ? parsed.startedAt : 0;
+        const startedAt = typeof parsed.startedAt === "number" ? parsed.startedAt : 0;
+        return typeof parsed.toward === "string" && VERSION.test(parsed.toward)
+            ? { startedAt, toward: parsed.toward }
+            : { startedAt };
     }
     catch {
-        return 0;
+        return { startedAt: 0 };
     }
 }
+/**
+ * Whether an attempt toward `newer` may start now. Once a day toward the same
+ * release, so a laptop whose install keeps failing is not hammered; but a
+ * release newer than the last attempt's target is a new reason, and waits only
+ * an hour, so one stale attempt cannot hold back the next release for a day.
+ */
+function due(newer, last, now) {
+    const since = now - last.startedAt;
+    if (since >= DAY_MS)
+        return true;
+    const newerTarget = last.toward === undefined || older(last.toward, newer);
+    return newerTarget && since >= HOUR_MS;
+}
 function writePrivate(path, value, environment) {
     mkdirSync(configHome(environment), { recursive: true, mode: 0o700 });
     writeFileSync(path, JSON.stringify(value) + "\n", { mode: 0o600 });
@@ -109,17 +139,17 @@ function detached(command, args, environment) {
     return child.pid !== undefined;
 }
 /**
- * Start the update when the server named a newer release and none was
- * started today. Answers whether one was started, for the caller's own
+ * Start the update when the server named a newer release and an attempt
+ * toward it is due (`due`). Answers whether one was started, for the caller's own
  * record; the session hears nothing either way. A launch that could not start
- * leaves no stamp, so the next session start tries again rather than waiting
+ * leaves no stamp, so the next hook fire tries again rather than waiting
  * a day for the same failure.
  */
 export function startSelfUpdateIfDue(newer, deps) {
     if (newer === undefined)
         return false;
     const now = deps.now ?? Date.now;
-    if (now() - lastStarted(deps.environment) < DAY_MS)
+    if (!due(newer, lastAttempt(deps.environment), now()))
         return false;
     const launch = resolveLaunch(HOOK_SPECIFIER, deps.environment, deps.execPath, deps.exists);
     let started;

package/dist/user-scope.d.ts

@@ -41,16 +41,7 @@ export type PushCheckState = "on" | "off" | "unavailable";
 export declare function pushCheckState(environment: NodeJS.ProcessEnv, published: boolean, installed?: string): PushCheckState;
 /** Setup's one line about the push check. */
 export declare function pushCheckSetupLine(state: PushCheckState): string;
-/**
- * What the push check's entry asks grep before Node starts: whether the
- * payload's `"command"`, read as JSON (a string, or a list of words as Codex
- * can send it), so much as mentions `push`, `create` or `merge`. Every line
- * the judge reads as a push (`git push`, `gh pr create`, `gh pr merge`) spells
- * one of them out, so none is dropped, and a folder or an output that says
- * "push" wakes nothing. A word split by quotes (`pu''sh`) is the one spelling
- * the judge reads as a push and this does not.
- */
-export declare const PUSH_CHECK_FILTER = "\"command\" *: *(\\[( *\"([^\"\\\\]|\\\\.)*\" *,)* *)?\"([^\"\\\\]|\\\\.)*(push|create|merge)";
+export declare const PUSH_CHECK_FILTER: string;
 /**
  * The push check's entry as the host runs it. It runs on every shell command
  * an agent runs, before and after, so a POSIX shell looks first and starts

package/dist/user-scope.js

@@ -3,7 +3,7 @@ import { existsSync, lstatSync, mkdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { parse } from "@iarna/toml";
-import { JUDGE_HOOK_EVENTS, JUDGE_HOOK_TIMEOUT_SECONDS, pushCheckOff } from "./judge-hook.js";
+import { JUDGE_HOOK_EVENTS, JUDGE_HOOK_TIMEOUT_SECONDS, judgeHookEvents, pushCheckOff, } from "./judge-hook.js";
 import { HOOK_SPECIFIER, checkoutEntryPath } from "./release.js";
 import { writeJsonAtomically } from "./mcp-config.js";
 /**
@@ -67,7 +67,7 @@ export function pushCheckSetupLine(state) {
         return "The push check is off on this laptop; `balladeer judge --push-check on` turns it back on.";
     if (state === "unavailable")
         return "The push check is not on: it needs the installed balladeer command, which is not installed here, and without it every shell command your agent runs would wait for npm. Run setup again once the command installs.";
-    return 'The push check is on for every connected repository: after your agent pushes, it reports any promise the push may have broken and never holds the push (a promise needs a behavior map, which `balladeer map --all` builds). Turn it off on this laptop with `balladeer judge --push-check off`; a repository can have it hold a breaking push instead with "mode": "block" in .continuity/judge.json.';
+    return 'The push check is on for every connected repository: after your agent pushes, it reports any promise the push may have broken and never holds the push. Each agreed promise is tied to the code it lives in on the first push after it is agreed, on your own Claude Code or Codex login, with nothing for you to run. Turn it off on this laptop with `balladeer judge --push-check off`; a repository can have it hold a breaking push instead with "mode": "block" in .continuity/judge.json.';
 }
 /**
  * What the push check's entry asks grep before Node starts: whether the
@@ -75,10 +75,15 @@ export function pushCheckSetupLine(state) {
  * can send it), so much as mentions `push`, `create` or `merge`. Every line
  * the judge reads as a push (`git push`, `gh pr create`, `gh pr merge`) spells
  * one of them out, so none is dropped, and a folder or an output that says
- * "push" wakes nothing. A word split by quotes (`pu''sh`) is the one spelling
- * the judge reads as a push and this does not.
+ * "push" wakes nothing. Between letters it permits punctuation, including
+ * shell quotes and escapes: `pu''sh` must reach the full parser too. This
+ * deliberately admits a few extra commands instead of losing an observed push.
  */
-export const PUSH_CHECK_FILTER = '"command" *: *(\\[( *"([^"\\\\]|\\\\.)*" *,)* *)?"([^"\\\\]|\\\\.)*(push|create|merge)';
+const FILTER_GAP = '([^"[:alnum:]]|\\\\.)*';
+const FILTER_WORDS = ["push", "create", "merge"]
+    .map((word) => [...word].join(FILTER_GAP))
+    .join("|");
+export const PUSH_CHECK_FILTER = `"command" *: *(\\[( *"([^"\\\\]|\\\\.)*" *,)* *)?"([^"\\\\]|\\\\.)*(${FILTER_WORDS})`;
 /** A word as a POSIX shell reads it back unchanged: bare when it is plain. */
 function shellWord(word) {
     return /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replaceAll("'", "'\\''")}'`;
@@ -293,7 +298,7 @@ export function mergeClaudeUserHooks(home, published, installed, platform = proc
     // note included: only rows with its own mark are its to replace or remove.
     const pushCheck = pushCheckInstallable(published, installed);
     const judgeLine = pushCheckCommand(host, published, installed, { platform });
-    for (const event of JUDGE_HOOK_EVENTS) {
+    for (const event of judgeHookEvents(host)) {
         const rows = hooks[event] === undefined ? [] : hooks[event];
         if (!Array.isArray(rows))
             return { host, path, status: "refused", reason: `hooks.${event} is not a list` };
@@ -347,7 +352,7 @@ export function mergeClaudeUserHooks(home, published, installed, platform = proc
     // under PreToolUse are not the guidance hooks' to take out.
     const sets = [
         [USER_SCOPE_OWNER, CLAUDE_EVENTS],
-        [USER_SCOPE_PUSH_CHECK_OWNER, JUDGE_HOOK_EVENTS],
+        [USER_SCOPE_PUSH_CHECK_OWNER, judgeHookEvents(host)],
     ];
     for (const [event, rows] of Object.entries(hooks)) {
         if (!Array.isArray(rows))

package/dist/wire.d.ts

@@ -5,14 +5,14 @@
  * runtime dependency at all: Node 22 builtins and global fetch, nothing else.
  * A contract test compares the scope list below against the server's.
  */
-export declare const CLI_VERSION = "1.0.18";
+export declare const CLI_VERSION = "1.0.20";
 export declare const CLI_INVOCATION = "npx -y balladeer@latest";
 export declare const CLIENT_HEADER = "x-balladeer-client";
 /** What the last background update came to: `started:1.0.17`, `installed:1.0.17`, `failed:exit-1`, `unstartable:launcher`. */
 export declare const UPDATE_STATE_HEADER = "x-balladeer-update-state";
 /** Which host's hook made this guidance fetch: `claude` or `codex`. */
 export declare const HOOK_HOST_HEADER = "x-balladeer-hook";
-export declare const CLIENT_HEADER_VALUE = "balladeer/1.0.18";
+export declare const CLIENT_HEADER_VALUE = "balladeer/1.0.20";
 export declare const DEFAULT_CONTROL_PLANE = "https://envelopes.balladeer.ai";
 export type DelegatedScope = "repository:enroll" | "agent:issue" | "ci:connect" | "workspace:invite" | "candidate:propose";
 export declare const DELEGATED_SCOPES: readonly DelegatedScope[];
@@ -747,7 +747,7 @@ export type JsonStep = Readonly<{
     remainingToday: number;
 }> | Readonly<{
     step: "judge";
-    status: "not_judged" | "still_judging" | "nothing_to_judge";
+    status: "not_judged" | "still_judging" | "nothing_to_judge" | "review_receipt_remains_local" | "review_settings_unavailable";
     reason: string;
     message: string;
     promiseIds?: readonly string[];

package/dist/wire.js

@@ -5,7 +5,7 @@
  * runtime dependency at all: Node 22 builtins and global fetch, nothing else.
  * A contract test compares the scope list below against the server's.
  */
-export const CLI_VERSION = "1.0.18";
+export const CLI_VERSION = "1.0.20";
 export const CLI_INVOCATION = "npx -y balladeer@latest";
 export const CLIENT_HEADER = "x-balladeer-client";
 /** What the last background update came to: `started:1.0.17`, `installed:1.0.17`, `failed:exit-1`, `unstartable:launcher`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "balladeer",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "description": "Set up Balladeer from your terminal, or from a coding agent's.",
   "license": "Apache-2.0",
   "private": false,