balladeer 1.0.6 → 1.0.8

package/README.md

@@ -41,10 +41,11 @@ To upgrade the executable and refresh in one command, run `npx -y balladeer@late
 
 Run `balladeer setup --refresh` to refresh repository instructions without replacing other tools'
 settings. For Codex, keep `--client codex`: `balladeer setup --client codex --refresh`. Existing
-instructions are not refreshed just because a package was installed. Refresh can contact npm and
-write the local toolchain when ensuring the executable is installed; it does not perform a Balladeer
-authority action. The repository MCP entry continues to use `npx -y balladeer@latest mcp` so native
-tools can pick up published updates.
+policy updates arrive through the project guidance loader after its initial activation. Installing a
+package alone does not prove the host loaded that guidance. Refresh can contact npm and write the
+local toolchain when ensuring the executable is installed; it does not perform a Balladeer authority
+action. The repository MCP entry continues to use `npx -y balladeer@latest mcp` so native tools can
+pick up published updates.
 
 Automatic installation supports macOS/Linux with zsh, bash or sh. It uses the active npm global
 prefix or a writable personal prefix; when needed, it adds a bounded PATH block to your shell
@@ -79,6 +80,22 @@ is refused, authorized MCP reads, coding and explicitly requested capture may co
 session ID. Do not invent an ID or trailer. This does not fix missing credentials, installation or
 authorization failures, and does not guarantee every CLI command works in every sandbox.
 
+## Current project guidance
+
+Version 1.0.7 introduces a stable instruction block and project-local guidance hooks. Setup writes
+Codex hooks in the connected project's `.codex/config.toml`, or Claude Code hooks in its
+`.claude/settings.json`. It never installs global hooks. The loader checks that the current
+project's MCP entry matches the requested repository and deployment before reading credentials or
+fetching guidance. An unrelated repository remains untouched.
+
+The next MCP launch can migrate recognized older Balladeer blocks; customized or conflicting blocks
+are left for an explicit repair. Review your coding host's normal hook trust prompt once. Project
+trust alone does not prove the hook is trusted or running. After activation, guidance is fetched at
+supported work boundaries, so policy revisions and rollbacks do not require another package
+installation or repository edit. A fetch failure keeps ordinary work moving and suppresses
+unsolicited capture until the current workspace mode is available. A delivery receipt proves context
+was emitted, not that an agent followed it.
+
 ## If npm cannot start the bootstrap
 
 An EPERM or EACCES error naming npm's cache happens before Balladeer starts. Use an allowed writable

package/dist/cli.d.ts

@@ -19,6 +19,7 @@ type Parsed = Readonly<{
      */
     claudeDesktop: boolean | undefined;
     repo: string | undefined;
+    repoScope: boolean;
     file: string | undefined;
     repository: string | undefined;
     /**
@@ -30,6 +31,8 @@ type Parsed = Readonly<{
      * rather than quietly resolved to the last one.
      */
     repositories: readonly string[];
+    hook: "codex" | "claude" | undefined;
+    event: "SessionStart" | "UserPromptSubmit" | "SubagentStart" | undefined;
     owner: string | undefined;
     /** `check-seals --install-hook`: write the optional pre-push hook. */
     installHook: boolean;

package/dist/cli.js

@@ -7,6 +7,7 @@ import { runCheckSeals } from "./commands/check-seals.js";
 import { runDiscover } from "./commands/discover.js";
 import { runExplain } from "./commands/explain.js";
 import { parseRole, runInvite } from "./commands/invite.js";
+import { runGuidance } from "./commands/guidance.js";
 import { runMcp } from "./commands/mcp.js";
 import { runPrepare } from "./commands/prepare.js";
 import { runPropose } from "./commands/propose.js";
@@ -17,15 +18,24 @@ import { runStatus } from "./commands/status.js";
 import { runTouchMap } from "./commands/touch-map.js";
 import { runWhoami } from "./commands/whoami.js";
 import { runInstall } from "./install.js";
+import { installUserScope, runningFromCheckout } from "./user-scope.js";
+import { setQuiet } from "./quiet.js";
 import { updateNotice } from "./currency.js";
 import { StoreError, normalizeControlPlane } from "./store.js";
 import { CLI_INVOCATION, CLI_VERSION, DEFAULT_CONTROL_PLANE } from "./wire.js";
 const USAGE = `balladeer ${CLI_VERSION}
 
   ${CLI_INVOCATION} install [--json]
-      Install this exact release as the durable balladeer command, without pairing
-      or changing any workspace, repository, or CI configuration. Use the latest
-      npx bootstrap to upgrade an older global command.
+      Install this exact release as the durable balladeer command, and register
+      Balladeer once for every Claude Code and Codex session on this machine:
+      it decides per folder, from the git remote, which connection applies.
+      Pairs nothing and changes no workspace, repository, or CI configuration.
+
+  ${CLI_INVOCATION} quiet [--repo]
+  ${CLI_INVOCATION} track [--repo]
+      In a folder Balladeer does not track, each session hears that once. quiet
+      stops it for this folder (or --repo, for every checkout of this
+      repository); track undoes it.
 
   ${CLI_INVOCATION} setup [--repository owner/name]... [--json] [--wait] [--control-plane <url>]
                   [--create-workspace <name>] [--choose-workspace] [--refresh] [--force]
@@ -170,6 +180,8 @@ export function parseArguments(argv) {
             throw new StoreError("usage", `${command} needs one of: ${SUBCOMMANDS[command].join(", ")}.`);
         }
     }
+    let hook;
+    let event;
     let json = false;
     let wait = false;
     let refresh = false;
@@ -185,6 +197,7 @@ export function parseArguments(argv) {
     let runner;
     let controlPlane;
     let repo;
+    let repoScope = false;
     let file;
     let owner;
     let createWorkspace;
@@ -216,7 +229,21 @@ export function parseArguments(argv) {
         }
         const [name, ...rest] = flag.split("=");
         const inline = rest.length > 0 ? rest.join("=") : undefined;
-        if (name === "--json")
+        if (name === "--hook") {
+            const requested = value("--hook", inline);
+            if (requested !== "codex" && requested !== "claude")
+                throw new StoreError("usage", "--hook needs codex or claude.");
+            hook = requested;
+        }
+        else if (name === "--event") {
+            const requested = value("--event", inline);
+            if (requested !== "SessionStart" &&
+                requested !== "UserPromptSubmit" &&
+                requested !== "SubagentStart")
+                throw new StoreError("usage", "--event needs SessionStart, UserPromptSubmit or SubagentStart.");
+            event = requested;
+        }
+        else if (name === "--json")
             json = true;
         else if (name === "--again")
             again = true;
@@ -250,6 +277,8 @@ export function parseArguments(argv) {
             claudeDesktop = false;
         else if (name === "--control-plane")
             controlPlane = value("--control-plane", inline);
+        else if (name === "--repo" && (command === "quiet" || command === "track"))
+            repoScope = true;
         else if (name === "--repo")
             repo = value("--repo", inline);
         else if (name === "--file")
@@ -334,6 +363,10 @@ export function parseArguments(argv) {
     if (command !== "setup" && repositories.length > 1) {
         throw new StoreError("usage", `${command} acts on one repository. Name --repository once, or run it again for the other.`);
     }
+    if (hook !== undefined && command !== "guidance")
+        throw new StoreError("usage", "--hook belongs to guidance.");
+    if (event !== undefined && command !== "guidance")
+        throw new StoreError("usage", "--event belongs to guidance.");
     const chosen = controlPlane ?? process.env.BALLADEER_CONTROL_PLANE?.trim() ?? DEFAULT_CONTROL_PLANE;
     return {
         command,
@@ -347,9 +380,12 @@ export function parseArguments(argv) {
         existingOnly,
         claudeDesktop,
         repo,
+        repoScope,
         file,
         repository: repositories[0],
         repositories,
+        hook,
+        event,
         owner,
         installHook,
         fresh,
@@ -386,8 +422,46 @@ async function dispatch(parsed, write) {
     switch (parsed.command) {
         case "explain":
             return runExplain(write, parsed.controlPlane);
-        case "install":
-            return runInstall({ environment: process.env, json: parsed.json, write });
+        case "install": {
+            // Once per laptop: the same server and hook, registered where every
+            // session on this machine reads them, deciding per folder at run time.
+            // Registered first and independently: the entries run through npx and
+            // need no durable command, so a blocked PATH must not keep a laptop
+            // from getting them.
+            const writes = installUserScope({
+                environment: process.env,
+                published: !runningFromCheckout(),
+            });
+            for (const w of writes)
+                if (!parsed.json)
+                    write(`${w.status === "refused" ? "Not changed" : w.status === "written" ? "Registered" : "Already current"}: ${w.path}${w.reason ? ` (${w.reason})` : ""}\n`);
+            if (!parsed.json && writes.some((w) => w.status === "written"))
+                write("Balladeer now runs in every Claude Code" +
+                    (writes.some((w) => w.host === "codex") ? " and Codex" : "") +
+                    " session on this machine. In a folder of a connected repository it works as before; anywhere else it says once that the folder isn't tracked. Approve the new hook when your coding host asks.\n");
+            const code = runInstall({
+                environment: process.env,
+                json: parsed.json,
+                write,
+                extra: { userScope: writes },
+            });
+            return writes.some((w) => w.status === "refused") ? 4 : code;
+        }
+        case "quiet":
+        case "track": {
+            const scope = parsed.repoScope ? "repo" : "folder";
+            try {
+                const { key, changed } = setQuiet(process.cwd(), scope, parsed.command === "quiet", process.env);
+                write(parsed.command === "quiet"
+                    ? `${changed ? "Balladeer will stay quiet" : "Balladeer was already quiet"} in ${scope === "repo" ? `every checkout of ${key}` : key}. Run \`balladeer track${scope === "repo" ? " --repo" : ""}\` here to undo.\n`
+                    : `${changed ? "Balladeer will speak again" : "Balladeer was not quiet"} in ${scope === "repo" ? `checkouts of ${key}` : key}.\n`);
+                return 0;
+            }
+            catch (error) {
+                write(`${error instanceof Error ? error.message : String(error)}\n`);
+                return 4;
+            }
+        }
         case "setup":
             return runSetup({
                 installCommand: () => {
@@ -552,6 +626,21 @@ async function dispatch(parsed, write) {
                 environment: process.env,
                 write,
             });
+        case "guidance":
+            if (parsed.hook === undefined) {
+                write("guidance needs --hook codex or claude.\n");
+                return 4;
+            }
+            return runGuidance({
+                controlPlane: parsed.controlPlane,
+                hook: parsed.hook,
+                ...(parsed.event === undefined ? {} : { event: parsed.event }),
+                ...(parsed.repository === undefined ? {} : { repositoryId: parsed.repository }),
+                environment: process.env,
+                cwd: process.cwd(),
+                stdin: process.stdin,
+                write,
+            });
         case "mcp":
             return runMcp({
                 controlPlane: parsed.controlPlane,

package/dist/commands/guidance.d.ts

@@ -0,0 +1,19 @@
+import { type GuidanceEvent } from "../guidance.js";
+/** What a session hears, once, in a folder Balladeer is not tracking. */
+export declare function untrackedLine(remote: string): string;
+export type GuidanceOptions = Readonly<{
+    controlPlane: string;
+    repositoryId?: string;
+    hook: "codex" | "claude";
+    event?: GuidanceEvent;
+    runtimeGeneration?: string;
+    environment: NodeJS.ProcessEnv;
+    cwd: string;
+    stdin: NodeJS.ReadableStream;
+    write: (text: string) => void;
+    error?: (text: string) => void;
+    fetchImpl?: typeof fetch;
+    now?: () => number;
+}>;
+/** Hook stdout is bounded context only. Host prompts and transcript paths never leave this process. */
+export declare function runGuidance(options: GuidanceOptions): Promise<number>;

package/dist/commands/guidance.js

@@ -0,0 +1,136 @@
+import { validateProjectGuidanceScope } from "../guidance-install.js";
+import { GUIDANCE_UNAVAILABLE, loadGuidance, recordGuidanceContext, } from "../guidance.js";
+import { readCredentials } from "../store.js";
+import { selectAgent } from "../agent.js";
+import { repositoryHint } from "../repository.js";
+import { isQuiet } from "../quiet.js";
+import { PUBLISHED_SPECIFIER } from "../release.js";
+/** What a session hears, once, in a folder Balladeer is not tracking. */
+export function untrackedLine(remote) {
+    const here = remote === "unknown/unknown" ? "This folder" : `This folder (${remote})`;
+    return (`${here} isn't tracked by Balladeer, so promises can't be tracked from here. ` +
+        `To track it, run \`npx -y ${PUBLISHED_SPECIFIER} setup\` in this folder. ` +
+        `To stop this message here, run \`npx -y ${PUBLISHED_SPECIFIER} quiet\` (or \`quiet --repo\` for the whole repository).`);
+}
+function readInput(stream) {
+    return new Promise((resolve, reject) => {
+        let bytes = 0;
+        const chunks = [];
+        const finish = (error) => {
+            clearTimeout(timer);
+            stream.removeListener("data", data);
+            stream.removeListener("end", end);
+            stream.removeListener("error", failed);
+            stream.pause();
+            if (error)
+                reject(error);
+            else {
+                try {
+                    resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+                }
+                catch {
+                    reject(new Error("invalid_hook_input"));
+                }
+            }
+        };
+        const data = (chunk) => {
+            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            bytes += buffer.length;
+            if (bytes > 65_536)
+                finish(new Error("hook_input_oversized"));
+            else
+                chunks.push(buffer);
+        };
+        const end = () => finish();
+        const failed = () => finish(new Error("hook_input_unavailable"));
+        const timer = setTimeout(() => finish(new Error("hook_input_deadline")), 250);
+        stream.on("data", data);
+        stream.once("end", end);
+        stream.once("error", failed);
+    });
+}
+function eventFrom(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return undefined;
+    const event = input.hook_event_name;
+    return event === "SessionStart" || event === "SubagentStart" || event === "UserPromptSubmit"
+        ? event
+        : undefined;
+}
+function identifier(input) {
+    return typeof input === "string" && input.length > 0 && input.length <= 256 ? input : undefined;
+}
+/** Hook stdout is bounded context only. Host prompts and transcript paths never leave this process. */
+export async function runGuidance(options) {
+    // A project hook names its repository and must match the checkout it sits
+    // in. A user-scope hook names none: the folder's remote decides, and a folder
+    // with no connection hears that it is untracked rather than nothing at all.
+    const projectScoped = options.repositoryId !== undefined;
+    if (projectScoped &&
+        !validateProjectGuidanceScope({
+            cwd: options.cwd,
+            hook: options.hook,
+            repositoryId: options.repositoryId,
+            controlPlane: options.controlPlane,
+        }))
+        return 0;
+    let event = options.event ?? "SessionStart";
+    const emit = (context) => options.write(`${JSON.stringify({
+        hookSpecificOutput: { hookEventName: event, additionalContext: context },
+    })}\n`);
+    try {
+        const input = await readInput(options.stdin);
+        const parsedEvent = eventFrom(input);
+        if (!parsedEvent || (options.event && parsedEvent !== options.event))
+            throw new Error("invalid_hook_event");
+        event = parsedEvent;
+        const record = input;
+        const credentials = readCredentials(options.environment).agents;
+        const agents = projectScoped
+            ? credentials.filter((agent) => agent.controlPlane === options.controlPlane &&
+                agent.repositoryId === options.repositoryId)
+            : (() => {
+                const selection = selectAgent(credentials, options.controlPlane, undefined, repositoryHint(options.cwd));
+                return selection.kind === "refused" ? [] : [selection.agent];
+            })();
+        if (agents.length !== 1 || !agents[0]) {
+            if (projectScoped)
+                throw new Error("guidance_connection_unavailable");
+            // Untracked. Said once, at session start, and never when silenced.
+            if (event === "SessionStart" && !isQuiet(options.cwd, options.environment))
+                emit(untrackedLine(repositoryHint(options.cwd)));
+            return 0;
+        }
+        const loaded = await loadGuidance({
+            agent: agents[0],
+            environment: options.environment,
+            timeoutMs: 750,
+            ...(options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}),
+        });
+        const sessionId = identifier(record.session_id);
+        const agentId = identifier(record.agent_id);
+        recordGuidanceContext({
+            environment: options.environment,
+            scopeKey: loaded.scopeKey,
+            hook: options.hook,
+            event,
+            ...(options.runtimeGeneration ? { runtimeGeneration: options.runtimeGeneration } : {}),
+            load: loaded,
+            ...(sessionId ? { sessionId } : {}),
+            ...(agentId ? { agentId } : {}),
+            ...(options.now ? { now: options.now() } : {}),
+        }, () => emit(loaded.document
+            ? `Current Balladeer guidance (${loaded.document.revision}). This supersedes earlier Balladeer workflow and capture guidance in this context.\n\n${loaded.document.instructions}`
+            : GUIDANCE_UNAVAILABLE));
+    }
+    catch {
+        // A fixed fallback contains neither raw input nor credential/error details. Work continues.
+        try {
+            emit(GUIDANCE_UNAVAILABLE);
+        }
+        catch {
+            /* Closed stdout cannot block the host. */
+        }
+    }
+    return 0;
+}

package/dist/commands/mcp.js

@@ -1,7 +1,10 @@
 import { createInterface } from "node:readline";
+import { installGuidanceLoader } from "../guidance-install.js";
 import { callAgentTool, forwarderHeaders, noAgentCredentialSentence, safeJson, selectAgent, structuredString, updateLine, } from "../agent.js";
 import { noteServerVersion, updateNotice } from "../currency.js";
 import { repositoryHint } from "../repository.js";
+import { CLI_VERSION } from "../wire.js";
+import { untrackedLine } from "./guidance.js";
 import { StoreError, readCredentials } from "../store.js";
 // The three commands that use an agent connection select and address it through
 // one module. These are re-exported because this is where the forwarder's
@@ -126,6 +129,39 @@ function frameId(line) {
     }
     return null;
 }
+/** The smallest server a host accepts: initialize, an empty tools list, ping. */
+async function serveUntracked(options, instructions) {
+    const lines = createInterface({ input: options.stdin, crlfDelay: Infinity });
+    for await (const line of lines) {
+        if (line.trim().length === 0)
+            continue;
+        let request;
+        try {
+            request = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (request.id === undefined)
+            continue; // a notification
+        const result = request.method === "initialize"
+            ? {
+                protocolVersion: request.params?.protocolVersion ?? "2025-06-18",
+                capabilities: { tools: {} },
+                serverInfo: { name: "balladeer", version: CLI_VERSION },
+                instructions,
+            }
+            : request.method === "tools/list"
+                ? { tools: [] }
+                : request.method === "ping"
+                    ? {}
+                    : undefined;
+        options.write(JSON.stringify(result === undefined
+            ? { jsonrpc: "2.0", id: request.id, error: { code: -32601, message: "Method not found" } }
+            : { jsonrpc: "2.0", id: request.id, result }) + "\n");
+    }
+    return 0;
+}
 export async function runMcp(options) {
     let credentials;
     try {
@@ -143,9 +179,24 @@ export async function runMcp(options) {
         options.error(selection.missingFor === undefined
             ? `${selection.reason} Run setup in this repository, or issue the connection at ${options.controlPlane}/setup.\n`
             : `${noAgentCredentialSentence(selection.missingFor)}\n`);
-        return 4;
+        // A project entry named its repository and got it wrong: that is an error
+        // the host should show. A user-scope entry named none and simply landed in
+        // a folder nobody tracks: that is ordinary, and a server that dies here
+        // shows up red in every untracked folder on the laptop. Answer the host
+        // with an empty catalog and the one sentence the hook also says.
+        if (options.repositoryId !== undefined)
+            return 4;
+        return serveUntracked(options, untrackedLine(repositoryHint(options.cwd)));
     }
     const { agent } = selection;
+    const guidanceInstall = installGuidanceLoader({
+        environment: options.environment,
+        cwd: options.cwd,
+        repositoryId: agent.repositoryId,
+        controlPlane: agent.controlPlane,
+    });
+    if (guidanceInstall.status !== "not_applicable")
+        options.error(`Balladeer guidance loader: ${guidanceInstall.status}${guidanceInstall.reason ? ` (${guidanceInstall.reason})` : ""}. New project hooks may need host trust; no trust is assumed.\n`);
     let saidUpdate = false;
     const lines = createInterface({ input: options.stdin, crlfDelay: Infinity });
     for await (const line of lines) {

package/dist/commands/propose.js

@@ -123,8 +123,13 @@ export function readTeachBackFile(raw) {
             reason: 'teachBack.wrongOutcome is missing. Say what going wrong looks like, in the words the person used and as a must-not: "a second payment must not go out". If no sentence of that shape exists, nothing could ever fail this promise, so do not propose it',
         };
     }
-    if (teachBack.leastSure !== undefined && typeof teachBack.leastSure !== "string") {
-        return { ok: false, reason: "teachBack.leastSure must be one sentence of text" };
+    if (teachBack.leastSure !== undefined ||
+        (teachBack.unresolvedQuestions !== undefined &&
+            (!Array.isArray(teachBack.unresolvedQuestions) || teachBack.unresolvedQuestions.length > 0))) {
+        return {
+            ok: false,
+            reason: "Outstanding questions are retired. Clarify material ambiguity with the person before writing, and put their actual answer in the meaning and cases. Nothing was sent.",
+        };
     }
     return {
         ok: true,

package/dist/commands/setup.js

@@ -11,6 +11,7 @@ import { CI_BRANCH, commitWorkflowOnBranch, repositoryRoot, workflowOnDefaultBra
 import { MCP_CONFIG_FILE, currentEntry, entryRepositoryId, isOurEntry, mergeMcpConfig, readMcpConfig, stdioEntry, } from "../mcp-config.js";
 import { DESKTOP_CONFIG_FILE, desktopConfigLocation, desktopServerKey, desktopStdioEntry, mergeDesktopConfig, } from "../desktop-config.js";
 import { selectAgent } from "../agent.js";
+import { installGuidanceLoader } from "../guidance-install.js";
 import { findLegacyInstall, legacyMessage } from "../legacy.js";
 import { formatInstant } from "../local-time.js";
 import { checkoutEntryPath, commandLine, runningFromRegistryInstall } from "../release.js";
@@ -932,13 +933,35 @@ function hostConfigFile(options) {
     return options.client === "codex" ? CODEX_CONFIG_FILE : MCP_CONFIG_FILE;
 }
 function mergeHostConfig(options, root, repositoryId, published) {
-    const entry = stdioEntry(repositoryId, published);
+    const base = stdioEntry(repositoryId, published);
+    const entry = { ...base, args: [...base.args, "--control-plane", options.controlPlane] };
     return options.client === "codex"
-        ? mergeCodexConfig(root, { ...entry, args: [...entry.args, "--control-plane", options.controlPlane] }, options.controlPlane)
+        ? mergeCodexConfig(root, entry, options.controlPlane)
         : mergeMcpConfig(root, entry, options.controlPlane);
 }
 function writeHostConventions(options, root) {
-    return writeConventions(root, options.client === "codex" ? { file: "AGENTS.md" } : {});
+    const result = writeConventions(root, options.client === "codex" ? { file: "AGENTS.md" } : {});
+    if (result.kind === "written") {
+        const entry = options.client === "codex" ? readCodexEntry(root) : currentEntry(readMcpConfig(root));
+        const repositoryId = entryRepositoryId(entry);
+        if (repositoryId !== undefined) {
+            const loader = installGuidanceLoader({
+                environment: options.environment,
+                cwd: root,
+                repositoryId,
+                controlPlane: options.controlPlane,
+                host: options.client === "codex" ? "codex" : "claude",
+            });
+            emit(options, { step: "guidance_loader", ...loader });
+            say(options, loader.status === "installed_needs_host_trust" ||
+                loader.status === "installed_trust_unverified"
+                ? "Project guidance loader installed. Review new hooks in your coding host once; future policy updates do not change that hook definition. A fresh session is needed to observe it."
+                : loader.status === "unavailable"
+                    ? `Project guidance loader needs repair (${loader.reason}). No active hook is claimed.`
+                    : "No matching project guidance integration was found. No guidance hook was installed or activated.");
+        }
+    }
+    return result;
 }
 function hostNextSteps(options) {
     if (options.client === "codex")

package/dist/conventions.d.ts

@@ -27,7 +27,7 @@ export declare const CONVENTIONS_END = "<!-- balladeer:conventions:end -->";
  * instructions marker instead. A bump here with no change to the block would
  * rewrite twelve repositories to say exactly what they already said.
  */
-export declare const CONVENTIONS_VERSION = 18;
+export declare const CONVENTIONS_VERSION = 20;
 export declare function managedByLine(version: number): string;
 /**
  * Which version of the block a file already carries, or nothing when it carries

package/dist/conventions.js

@@ -31,7 +31,7 @@ export const CONVENTIONS_END = "<!-- balladeer:conventions:end -->";
  * instructions marker instead. A bump here with no change to the block would
  * rewrite twelve repositories to say exactly what they already said.
  */
-export const CONVENTIONS_VERSION = 18;
+export const CONVENTIONS_VERSION = 20;
 /** Both spellings: the stable marker, and the versioned one version 1 wrote. */
 const START_MARKER = /<!-- balladeer:conventions:start(?: v(\d{1,4}))? -->/g;
 const END_MARKER = /<!-- balladeer:conventions:end -->/g;