balladeer 1.0.19 → 1.0.21

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

@@ -16,6 +16,15 @@ export type SelfUpdateDeps = Readonly<{
 }>;
 /** A short, closed vocabulary: it travels in a header and lands in a column. */
 export type SelfUpdateState = `started:${string}` | `unstartable:${string}` | `installed:${string}` | `failed:${string}`;
+/**
+ * The exact release to ask npx for, or nothing when there is none to ask for.
+ *
+ * Exact, because a range is answered from whatever copy is already on the
+ * laptop (see above). Only a release on this copy's own major, so a 2.x stays a
+ * choice a person makes, and only one newer than this copy, so a server that
+ * names an older number cannot walk a laptop backwards.
+ */
+export declare function updateSpecifier(newer: string): string | undefined;
 /** What the last attempt came to, for the next hook fire to report. Never throws. */
 export declare function recordSelfUpdateState(environment: NodeJS.ProcessEnv, state: SelfUpdateState, at: number): void;
 /** The recorded state, or nothing when none was written or it is not one of ours. */

package/dist/self-update.js

@@ -4,6 +4,7 @@ import { delimiter, dirname, join } from "node:path";
 import { older } from "./currency.js";
 import { HOOK_SPECIFIER } from "./release.js";
 import { configHome } from "./store.js";
+import { CLI_VERSION } from "./wire.js";
 /**
  * Bringing the durable command current without the session ever waiting.
  *
@@ -35,6 +36,18 @@ import { configHome } from "./store.js";
  * 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.
+ *
+ * What changed on 14 October 2026, from Didero's laptops and Robert's again:
+ * seven laptops sat on 1.0.12 to 1.0.14 for two weeks, and Robert's on 1.0.19
+ * with an attempt toward 1.0.20 "started" that morning. Every attempt had
+ * asked npx for `balladeer@1`, a range. npx runs any copy already on the
+ * laptop that satisfies a range without asking the registry: the durable
+ * command itself when it sits in npm's global folder, or whatever the first
+ * attempt left in npx's own cache. That copy's installer installs its own
+ * version and refuses to go down, so every attempt after the first changed
+ * nothing, silently, once a day. Now the attempt names the exact release the
+ * server announced, which npx cannot satisfy from an older copy, and the
+ * installer that runs is the one being installed.
  */
 const STAMP = "self-update.json";
 const STATE = "self-update-state.json";
@@ -79,6 +92,24 @@ function due(newer, last, now) {
     const newerTarget = last.toward === undefined || older(last.toward, newer);
     return newerTarget && since >= HOUR_MS;
 }
+/**
+ * The exact release to ask npx for, or nothing when there is none to ask for.
+ *
+ * Exact, because a range is answered from whatever copy is already on the
+ * laptop (see above). Only a release on this copy's own major, so a 2.x stays a
+ * choice a person makes, and only one newer than this copy, so a server that
+ * names an older number cannot walk a laptop backwards.
+ */
+export function updateSpecifier(newer) {
+    if (!VERSION.test(newer))
+        return undefined;
+    const [name, major] = HOOK_SPECIFIER.split("@");
+    if (newer.split(".")[0] !== major)
+        return undefined;
+    if (!older(CLI_VERSION, newer))
+        return undefined;
+    return `${name}@${newer}`;
+}
 function writePrivate(path, value, environment) {
     mkdirSync(configHome(environment), { recursive: true, mode: 0o700 });
     writeFileSync(path, JSON.stringify(value) + "\n", { mode: 0o600 });
@@ -148,10 +179,13 @@ function detached(command, args, environment) {
 export function startSelfUpdateIfDue(newer, deps) {
     if (newer === undefined)
         return false;
+    const specifier = updateSpecifier(newer);
+    if (specifier === undefined)
+        return false;
     const now = deps.now ?? Date.now;
     if (!due(newer, lastAttempt(deps.environment), now()))
         return false;
-    const launch = resolveLaunch(HOOK_SPECIFIER, deps.environment, deps.execPath, deps.exists);
+    const launch = resolveLaunch(specifier, deps.environment, deps.execPath, deps.exists);
     let started;
     try {
         started = (deps.run ?? detached)(launch.command, launch.args, launch.environment) !== false;

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.19";
+export declare const CLI_VERSION = "1.0.21";
 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.19";
+export declare const CLIENT_HEADER_VALUE = "balladeer/1.0.21";
 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.19";
+export const CLI_VERSION = "1.0.21";
 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.19",
+  "version": "1.0.21",
   "description": "Set up Balladeer from your terminal, or from a coding agent's.",
   "license": "Apache-2.0",
   "private": false,