balladeer 1.0.16 → 1.0.17

package/dist/user-scope.d.ts

@@ -15,6 +15,59 @@
  * shape, never by trust in the name.
  */
 export declare const USER_SCOPE_OWNER = "Balladeer current guidance (user scope, loader 1)";
+/**
+ * The push check at user scope. Robert, 30 September 2026: setup turns it on
+ * for everyone, where it writes Balladeer's other hooks, report-only unless a
+ * repository says block, so it runs in every connected repository and every
+ * worktree with no step per repository. Two entries on matcher `Bash`, the
+ * same pair `balladeer judge --install-hook` writes into a checkout: after the
+ * command, where report mode judges, and before it, where block mode does.
+ *
+ * Its own mark, apart from the guidance hooks' and from the project entry's
+ * `Balladeer judge`, so each is recognised, replaced and removed only by
+ * itself. The relay note and the push check both sit under PostToolUse.
+ */
+export declare const USER_SCOPE_PUSH_CHECK_OWNER = "Balladeer push check (user scope)";
+/**
+ * The push check runs on every shell command an agent runs, twice, so it is
+ * written only where the command starts in milliseconds: the installed command
+ * by path, or this checkout's own entry file. The `npx` form costs npm's own
+ * start and a registry lookup each time, which would slow every command the
+ * agent runs, so a laptop on it gets no push check until the command installs.
+ */
+export declare function pushCheckInstallable(published: boolean, installed?: string): boolean;
+/** Where the push check stands on this laptop after setup wrote the user scope. */
+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)";
+/**
+ * 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
+ * Node only for a command that could push: a few milliseconds on anything
+ * else instead of Node's start (measured 30 September 2026: 4 to 6 ms against
+ * 45 to 90). Both hosts run a hook's command through a shell (Codex checked
+ * natively the same day). Only grep's plain "no match" ends it there: a grep
+ * that cannot run lets the command through, so a laptop without one pays
+ * Node's start and loses nothing. `awaiting` is a file that exists while
+ * Codex has yet to run the entry; every command goes through while it does,
+ * so that first run is noted without waiting for a push. Windows gets the
+ * plain command: there is no /bin/sh to count on.
+ */
+export declare function pushCheckCommand(host: UserScopeHost, published: boolean, installed?: string, options?: Readonly<{
+    awaiting?: string;
+    platform?: NodeJS.Platform;
+}>): string;
 /** Every tool of the server named `balladeer`, in Claude Code's permission rule form. */
 export declare const USER_SCOPE_ALLOW_RULE = "mcp__balladeer__*";
 export type UserScopeHost = "claude" | "codex";
@@ -52,12 +105,28 @@ export declare function isOurUserEntry(entry: unknown): boolean;
  */
 export declare function isInstalledCommandPath(command: string): boolean;
 /** `~/.claude/settings.json` carries user-scope hooks. */
-export declare function mergeClaudeUserHooks(home: string, published: boolean, installed?: string): UserScopeWrite;
-/** What a person has to do once in Codex, which no command can do for them. */
-export declare const CODEX_HOOK_APPROVAL = "Codex: type /hooks in a Codex session and trust Balladeer's three hooks. Codex skips a hook until you have trusted it, so until then Codex has Balladeer's tools and none of its session-start guidance or updates.";
+export declare function mergeClaudeUserHooks(home: string, published: boolean, installed?: string, platform?: NodeJS.Platform): UserScopeWrite;
+/**
+ * What a person has to do once in Codex, which no command can do for them,
+ * counting the hooks this run gave Codex: the guidance hooks, and the push
+ * check's two where it was written.
+ */
+export declare function codexHookApproval(pushCheck: boolean): string;
 /** `~/.codex/config.toml` carries both the server and the hooks for Codex, in
  * one fenced block this command owns end to end. */
 export declare function mergeCodexUserConfig(home: string, published: boolean, installed?: string): UserScopeWrite;
+/**
+ * The push check's two entries in `~/.codex/config.toml`, in a fenced block of
+ * their own after Balladeer's other one, so the guidance block and this one are
+ * each written, replaced and removed only by themselves, and Codex's trust in
+ * the one says nothing about the other. TOML lets a later block add to
+ * `[[hooks.PostToolUse]]`, and Codex 0.144.5 reads the file that results
+ * (checked 30 September 2026 with `codex mcp list` on a file of this shape).
+ */
+export declare function mergeCodexPushCheck(home: string, published: boolean, installed?: string, options?: Readonly<{
+    awaiting?: string;
+    platform?: NodeJS.Platform;
+}>): UserScopeWrite;
 /** A copy of this command running out of a source checkout registers the
  * checkout; any installed or npx copy registers the published package. */
 export declare function runningFromCheckout(entry?: string): boolean;
@@ -72,4 +141,6 @@ export declare function installUserScope(options: {
     home?: string;
     /** The durable command's absolute path, when one is installed. */
     installed?: string;
+    /** The clock the Codex trust marks are stamped with. */
+    now?: () => number;
 }): UserScopeWrite[];

package/dist/user-scope.js

@@ -1,8 +1,9 @@
-import { noteHooksWritten } from "./hook-trust.js";
+import { countWord, noteHooksRemoved, noteHooksWritten, pushCheckAwaitingFile, } from "./hook-trust.js";
 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 { HOOK_SPECIFIER, checkoutEntryPath } from "./release.js";
 import { writeJsonAtomically } from "./mcp-config.js";
 /**
@@ -22,7 +23,99 @@ import { writeJsonAtomically } from "./mcp-config.js";
  * shape, never by trust in the name.
  */
 export const USER_SCOPE_OWNER = "Balladeer current guidance (user scope, loader 1)";
-const CLAUDE_EVENTS = ["SessionStart", "UserPromptSubmit", "SubagentStart"];
+const CLAUDE_EVENTS = ["SessionStart", "UserPromptSubmit", "SubagentStart", "PostToolUse"];
+/**
+ * The relay note runs after Balladeer's own tools only, never after anyone
+ * else's: a regex on the tool name, which both hosts match against
+ * `mcp__<server>__<tool>`. Robert, 30 September 2026: installed on both hosts
+ * (plans/promise-relations/plan.md, step 1).
+ */
+const RELAY_MATCHER = "mcp__balladeer.*";
+const matcherFor = (event) => event === "PostToolUse" ? { matcher: RELAY_MATCHER } : {};
+/**
+ * The push check at user scope. Robert, 30 September 2026: setup turns it on
+ * for everyone, where it writes Balladeer's other hooks, report-only unless a
+ * repository says block, so it runs in every connected repository and every
+ * worktree with no step per repository. Two entries on matcher `Bash`, the
+ * same pair `balladeer judge --install-hook` writes into a checkout: after the
+ * command, where report mode judges, and before it, where block mode does.
+ *
+ * Its own mark, apart from the guidance hooks' and from the project entry's
+ * `Balladeer judge`, so each is recognised, replaced and removed only by
+ * itself. The relay note and the push check both sit under PostToolUse.
+ */
+export const USER_SCOPE_PUSH_CHECK_OWNER = "Balladeer push check (user scope)";
+const PUSH_CHECK_MATCHER = "Bash";
+/**
+ * The push check runs on every shell command an agent runs, twice, so it is
+ * written only where the command starts in milliseconds: the installed command
+ * by path, or this checkout's own entry file. The `npx` form costs npm's own
+ * start and a registry lookup each time, which would slow every command the
+ * agent runs, so a laptop on it gets no push check until the command installs.
+ */
+export function pushCheckInstallable(published, installed) {
+    return installed !== undefined || !published;
+}
+export function pushCheckState(environment, published, installed) {
+    if (!pushCheckInstallable(published, installed))
+        return "unavailable";
+    return pushCheckOff(environment) ? "off" : "on";
+}
+/** Setup's one line about the push check. */
+export function pushCheckSetupLine(state) {
+    if (state === "off")
+        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.';
+}
+/**
+ * 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 const PUSH_CHECK_FILTER = '"command" *: *(\\[( *"([^"\\\\]|\\\\.)*" *,)* *)?"([^"\\\\]|\\\\.)*(push|create|merge)';
+/** 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("'", "'\\''")}'`;
+}
+/**
+ * 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
+ * Node only for a command that could push: a few milliseconds on anything
+ * else instead of Node's start (measured 30 September 2026: 4 to 6 ms against
+ * 45 to 90). Both hosts run a hook's command through a shell (Codex checked
+ * natively the same day). Only grep's plain "no match" ends it there: a grep
+ * that cannot run lets the command through, so a laptop without one pays
+ * Node's start and loses nothing. `awaiting` is a file that exists while
+ * Codex has yet to run the entry; every command goes through while it does,
+ * so that first run is noted without waiting for a push. Windows gets the
+ * plain command: there is no /bin/sh to count on.
+ */
+export function pushCheckCommand(host, published, installed, options = {}) {
+    const { command, args } = userScopeCommand(published, installed);
+    const run = [command, ...args, "judge", "--hook", host, "--user-scope"];
+    if ((options.platform ?? process.platform) === "win32")
+        return run.join(" ");
+    const awaiting = options.awaiting === undefined ? [] : [options.awaiting];
+    const script = [
+        'i=$(cat); printf %s "$i" | grep -qE "$1" || [ $? -ne 1 ] || ',
+        awaiting.length > 0 ? '[ -e "$2" ] || exit 0; shift 2; ' : "exit 0; shift; ",
+        'printf %s "$i" | exec "$@"',
+    ].join("");
+    return ["/bin/sh", "-c", script, "balladeer-push-check", PUSH_CHECK_FILTER, ...awaiting, ...run]
+        .map(shellWord)
+        .join(" ");
+}
+const ownedBy = (owner) => (row) => {
+    const handlers = row?.hooks;
+    return (Array.isArray(handlers) &&
+        handlers.some((handler) => handler?.statusMessage === owner));
+};
 /** Every tool of the server named `balladeer`, in Claude Code's permission rule form. */
 export const USER_SCOPE_ALLOW_RULE = "mcp__balladeer__*";
 /**
@@ -146,7 +239,7 @@ export function isInstalledCommandPath(command) {
         existsSync(join(dirname(bin), "lib", "node_modules", "balladeer", "package.json")));
 }
 /** `~/.claude/settings.json` carries user-scope hooks. */
-export function mergeClaudeUserHooks(home, published, installed) {
+export function mergeClaudeUserHooks(home, published, installed, platform = process.platform) {
     const path = join(home, ".claude", "settings.json");
     const host = "claude";
     if (!homeExists(home))
@@ -177,6 +270,7 @@ export function mergeClaudeUserHooks(home, published, installed) {
             return { host, path, status: "refused", reason: `hooks.${event} is not a list` };
         const own = rows.filter((row) => row?.hooks?.some((h) => h.statusMessage === USER_SCOPE_OWNER));
         const expected = {
+            ...matcherFor(event),
             hooks: [
                 {
                     type: "command",
@@ -195,6 +289,44 @@ export function mergeClaudeUserHooks(home, published, installed) {
         hooks[event] = [...rows.filter((row) => !own.includes(row)), expected];
         changed = true;
     }
+    // The push check, beside whatever else is under the same event, the relay
+    // 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) {
+        const rows = hooks[event] === undefined ? [] : hooks[event];
+        if (!Array.isArray(rows))
+            return { host, path, status: "refused", reason: `hooks.${event} is not a list` };
+        const own = rows.filter(ownedBy(USER_SCOPE_PUSH_CHECK_OWNER));
+        if (own.length > 1)
+            return { host, path, status: "refused", reason: `two Balladeer push checks under ${event}` };
+        const others = rows.filter((row) => !own.includes(row));
+        if (!pushCheck) {
+            if (own.length === 0)
+                continue;
+            if (others.length === 0)
+                delete hooks[event];
+            else
+                hooks[event] = others;
+            changed = true;
+            continue;
+        }
+        const expected = {
+            matcher: PUSH_CHECK_MATCHER,
+            hooks: [
+                {
+                    type: "command",
+                    command: judgeLine,
+                    timeout: JUDGE_HOOK_TIMEOUT_SECONDS,
+                    statusMessage: USER_SCOPE_PUSH_CHECK_OWNER,
+                },
+            ],
+        };
+        if (own.length === 1 && JSON.stringify(own[0]) === JSON.stringify(expected))
+            continue;
+        hooks[event] = [...others, expected];
+        changed = true;
+    }
     // Claude Code asks the person before every call to a server's tools unless
     // a rule allows them. Without one, each read the guidance asks for costs a
     // click, and a session that says no once hears no offer at all (measured
@@ -211,10 +343,16 @@ export function mergeClaudeUserHooks(home, published, installed) {
     // An event this release no longer hooks: its own entry there is deprecated
     // and comes out. Robert, 29 September 2026: a hook that should no longer
     // exist is removed, a new one is added, one that still belongs persists.
+    // Each set of hooks answers for its own events only: the push check's rows
+    // 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],
+    ];
     for (const [event, rows] of Object.entries(hooks)) {
-        if (CLAUDE_EVENTS.includes(event) || !Array.isArray(rows))
+        if (!Array.isArray(rows))
             continue;
-        const kept = rows.filter((row) => !row?.hooks?.some((h) => h.statusMessage === USER_SCOPE_OWNER));
+        const kept = rows.filter((row) => !sets.some(([owner, events]) => !events.includes(event) && ownedBy(owner)(row)));
         if (kept.length === rows.length)
             continue;
         if (kept.length === 0)
@@ -235,8 +373,19 @@ export function mergeClaudeUserHooks(home, published, installed) {
     writeJsonAtomically(path, JSON.stringify(root, null, 2) + "\n");
     return { host, path, status: "written" };
 }
-/** What a person has to do once in Codex, which no command can do for them. */
-export const CODEX_HOOK_APPROVAL = "Codex: type /hooks in a Codex session and trust Balladeer's three hooks. Codex skips a hook until you have trusted it, so until then Codex has Balladeer's tools and none of its session-start guidance or updates.";
+/**
+ * What a person has to do once in Codex, which no command can do for them,
+ * counting the hooks this run gave Codex: the guidance hooks, and the push
+ * check's two where it was written.
+ */
+export function codexHookApproval(pushCheck) {
+    const count = CLAUDE_EVENTS.length + (pushCheck ? JUDGE_HOOK_EVENTS.length : 0);
+    return (`Codex: type /hooks in a Codex session and trust Balladeer's ${countWord(count)} hooks. ` +
+        "Codex skips a hook until you have trusted it, so until then Codex has Balladeer's tools and none of its session-start guidance, updates, " +
+        (pushCheck
+            ? "the note that reminds your agent to tell you what Balladeer did, or its check after a push."
+            : "or the note that reminds your agent to tell you what Balladeer did."));
+}
 const CODEX_START = "# balladeer:user:start";
 const CODEX_END = "# balladeer:user:end";
 /** `~/.codex/config.toml` carries both the server and the hooks for Codex, in
@@ -264,6 +413,7 @@ export function mergeCodexUserConfig(home, published, installed) {
         `args = ${JSON.stringify([...args, "mcp"])}`,
         ...CLAUDE_EVENTS.flatMap((event) => [
             `[[hooks.${event}]]`,
+            ...(event === "PostToolUse" ? [`matcher = ${JSON.stringify(RELAY_MATCHER)}`] : []),
             `[[hooks.${event}.hooks]]`,
             'type = "command"',
             `command = ${JSON.stringify(`${line} --event ${event}`)}`,
@@ -301,6 +451,87 @@ export function mergeCodexUserConfig(home, published, installed) {
     writeJsonAtomically(path, after);
     return { host, path, status: "written" };
 }
+const PUSH_CHECK_START = "# balladeer:push-check:start";
+const PUSH_CHECK_END = "# balladeer:push-check:end";
+/**
+ * The push check's two entries in `~/.codex/config.toml`, in a fenced block of
+ * their own after Balladeer's other one, so the guidance block and this one are
+ * each written, replaced and removed only by themselves, and Codex's trust in
+ * the one says nothing about the other. TOML lets a later block add to
+ * `[[hooks.PostToolUse]]`, and Codex 0.144.5 reads the file that results
+ * (checked 30 September 2026 with `codex mcp list` on a file of this shape).
+ */
+export function mergeCodexPushCheck(home, published, installed, options = {}) {
+    const path = join(home, ".codex", "config.toml");
+    const host = "codex";
+    if (!ordinaryFile(path))
+        return { host, path, status: "refused", reason: "not an ordinary file" };
+    let previous = "";
+    try {
+        if (existsSync(path))
+            previous = readFileSync(path, "utf8");
+        parse(previous);
+    }
+    catch {
+        return { host, path, status: "refused", reason: "could not read valid TOML" };
+    }
+    const wanted = pushCheckInstallable(published, installed);
+    const line = pushCheckCommand(host, published, installed, options);
+    const block = [
+        PUSH_CHECK_START,
+        ...JUDGE_HOOK_EVENTS.flatMap((event) => [
+            `[[hooks.${event}]]`,
+            `matcher = ${JSON.stringify(PUSH_CHECK_MATCHER)}`,
+            `[[hooks.${event}.hooks]]`,
+            'type = "command"',
+            `command = ${JSON.stringify(line)}`,
+            `timeout = ${JUDGE_HOOK_TIMEOUT_SECONDS}`,
+            `statusMessage = ${JSON.stringify(USER_SCOPE_PUSH_CHECK_OWNER)}`,
+        ]),
+        PUSH_CHECK_END,
+    ].join("\n");
+    const starts = [...previous.matchAll(/^# balladeer:push-check:start\r?$/gm)];
+    const ends = [...previous.matchAll(/^# balladeer:push-check:end\r?$/gm)];
+    if (starts.length !== ends.length || starts.length > 1)
+        return { host, path, status: "refused", reason: "the Balladeer push check block is malformed" };
+    let after;
+    if (starts[0] && ends[0]) {
+        if (starts[0].index >= ends[0].index)
+            return {
+                host,
+                path,
+                status: "refused",
+                reason: "the Balladeer push check block is malformed",
+            };
+        const from = starts[0].index;
+        const to = ends[0].index + PUSH_CHECK_END.length;
+        if (wanted && previous.slice(from, to) === block)
+            return { host, path, status: "current" };
+        after = wanted
+            ? previous.slice(0, from) + block + previous.slice(to)
+            : previous.slice(0, from) + previous.slice(to + (previous[to] === "\n" ? 1 : 0));
+    }
+    else {
+        if (!wanted)
+            return { host, path, status: "current" };
+        after = previous + (previous.endsWith("\n") || previous === "" ? "" : "\n") + block + "\n";
+    }
+    try {
+        parse(after);
+    }
+    catch {
+        // A `hooks` table the person wrote in a form an added entry cannot join.
+        return {
+            host,
+            path,
+            status: "refused",
+            reason: "the push check's entries would not join the hooks already in the file",
+        };
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeJsonAtomically(path, after);
+    return { host, path, status: "written" };
+}
 /** A copy of this command running out of a source checkout registers the
  * checkout; any installed or npx copy registers the published package. */
 export function runningFromCheckout(entry = process.argv[1] ?? "") {
@@ -316,17 +547,47 @@ export function userHome(environment = process.env) {
 /** Register both hosts. Codex is skipped, not refused, on a laptop without it. */
 export function installUserScope(options) {
     const home = options.home ?? userHome(options.environment);
+    const now = options.now?.() ?? Date.now();
     const writes = [
         mergeClaudeUserMcp(home, options.published, options.installed),
         mergeClaudeUserHooks(home, options.published, options.installed),
     ];
     if (existsSync(join(home, ".codex"))) {
         const codex = mergeCodexUserConfig(home, options.published, options.installed);
-        writes.push(codex);
         // Codex has to run these once before anybody assumes it does; the mark is
         // what lets its own session say so after a silent background update.
         if (codex.status !== "refused")
-            noteHooksWritten(options.environment, "codex", codex.status === "written");
+            noteHooksWritten(options.environment, "codex", codex.status === "written", now, {
+                set: "guidance",
+                hooks: CLAUDE_EVENTS.length,
+            });
+        // The push check after it, into the same file, with marks of its own: the
+        // guidance hooks already trusted keep running, and must not be taken as
+        // Codex having run the push check.
+        const pushCheck = codex.status === "refused"
+            ? codex
+            : mergeCodexPushCheck(home, options.published, options.installed, {
+                awaiting: pushCheckAwaitingFile(options.environment, "codex"),
+            });
+        if (pushCheck.status !== "refused") {
+            if (pushCheckInstallable(options.published, options.installed))
+                noteHooksWritten(options.environment, "codex", pushCheck.status === "written", now, {
+                    set: "push-check",
+                    hooks: JUDGE_HOOK_EVENTS.length,
+                });
+            else
+                noteHooksRemoved(options.environment, "codex", "push-check");
+        }
+        // One line per file for the person: refused if either part was refused,
+        // written if either part changed it.
+        writes.push(pushCheck.status === "refused"
+            ? {
+                ...pushCheck,
+                ...(codex.status === "refused" ? {} : { reason: `push check: ${pushCheck.reason}` }),
+            }
+            : codex.status === "written" || pushCheck.status === "written"
+                ? { host: "codex", path: codex.path, status: "written" }
+                : codex);
     }
     return writes;
 }

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.16";
+export declare const CLI_VERSION = "1.0.17";
 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.16`, `installed:1.0.16`, `failed:exit-1`, `unstartable:launcher`. */
+/** 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.16";
+export declare const CLIENT_HEADER_VALUE = "balladeer/1.0.17";
 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[];

package/dist/wire.js

@@ -5,10 +5,10 @@
  * 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.16";
+export const CLI_VERSION = "1.0.17";
 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.16`, `installed:1.0.16`, `failed:exit-1`, `unstartable:launcher`. */
+/** What the last background update came to: `started:1.0.17`, `installed:1.0.17`, `failed:exit-1`, `unstartable:launcher`. */
 export const UPDATE_STATE_HEADER = "x-balladeer-update-state";
 /** Which host's hook made this guidance fetch: `claude` or `codex`. */
 export const HOOK_HOST_HEADER = "x-balladeer-hook";

package/package.json

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