@wirecat/cli-base 0.50.4 → 0.51.1

package/CHANGELOG.md

@@ -8,6 +8,37 @@ Versions before 0.8.0 are in the [git tags](https://github.com/WireCatLabs/cli-b
 Every entry says what changed as a caller sees it, why, and what to watch for — the rules are
 [`docs/dev/CONVENTIONS.md`](docs/dev/CONVENTIONS.md#the-changelog).
 
+## 0.51.1 — 24.10.2026
+
+### Fixed
+
+- The shared vocabulary recognizes `--draft` as a switch that saves text for review without sending. Enabling an adapter’s draft capability no longer creates an unknown-option-role lint failure.
+
+### Removed
+
+- **No wait between releases and no weekly limit on breaking changes** (`WC-REL-8`, [Releases](docs/standards/releases.md)). A messenger CLI no longer waits two hours after its last version, and a shared library may ship a change that makes the CLIs change their code at any time. `WC-REL-9` is merged into `WC-REL-8`. The release lock stays. Nothing changes in code.
+
+## 0.51.0 — 24.10.2026
+
+### Added
+
+- **Comparison pages live in the site repository, and our marks are re-checked at each release** (`WC-CMP-11`, [Comparisons](docs/standards/comparisons.md)). The page is written in `cli-docs` (wirecat.dev) because a comparison changes when other tools change, not when we release; the CLI repository keeps a short `docs/compare.md` that links to it. The release report lists the compare page as checked. Nothing changes in code.
+
+### Changed — may break callers
+
+- **Shared command contracts require explicit overrides before host edits.** `sharedCommand`, `assertSharedContracts`, `overrideSharedContract` and `customizeSharedCommand` live in `/commands`; original definitions and exact accepted edits remain available for audits. Independent shell replacements must supply static, exact before/after declarations; a new Core default or a changed provider builder fails until those declarations are reviewed. Provider additions are allowed; inherited subcommands cannot disappear silently. `/commands` now loads Commander at runtime.
+
+- **Cross-CLI contract drift cannot be accepted through a lint baseline.** Declare intentional differences with
+  their exact expected values and a specific reason; a changed or stale exemption fails. `audit --complete`
+  collects actual schemas and error reasons from `commands info --json` and refuses missing coverage. Canonical capability manifests and validated inherited definitions distinguish explicit provider variants from drift. Global
+  options satisfy matching command-local controls, so their placement alone is no longer a divergence.
+
+### Fixed
+
+- **Complete audits keep runtime availability separate from static contracts.** A currently denied or available command retains the same protected grammar and output definition.
+
+- **Command lint distinguishes list filters from computation and output controls.** Ranking weights, timezone, output context and byte pagination remain controls even when an answer exposes similarly named fields; singleton targets are not list filters. Native query fields and id/time filtering remain checked.
+
 ## 0.50.4 — 24.10.2026
 
 ### Added

package/dist/commands/contracts.d.ts

@@ -0,0 +1,19 @@
+import { Command } from "commander";
+export interface SharedContractOverride {
+    command: readonly string[];
+    field: string;
+    before: unknown;
+    after: unknown;
+    reason: string;
+}
+export declare const hasSharedContract: (command: Command) => boolean;
+export declare const assertSharedContracts: (root: Command) => void;
+/** The callback names the deliberate edit; an already changed contract cannot be acknowledged after the fact. */
+export declare const overrideSharedContract: <T extends Command>(command: T, reason: string, change: (command: T) => void) => T;
+export declare const sharedContractOverrides: (root: Command) => SharedContractOverride[];
+/** The original core definitions remain available independently of each host's accepted edits. */
+export declare const sharedContracts: (root: Command) => Record<string, unknown>;
+/** Preserve the factory signature while recording the definition before host composition can edit it. */
+export declare const sharedCommand: <Args extends unknown[], Result>(factory: (...args: Args) => Result) => (...args: Args) => Result;
+/** Bind a provider shell only when its exact, reviewed differences still match Core. */
+export declare const customizeSharedCommand: (reference: Command, reason: string, build: () => Command, expectedOverrides: readonly SharedContractOverride[]) => Command;

package/dist/commands/contracts.js

@@ -0,0 +1,207 @@
+import { isDeepStrictEqual } from "node:util";
+import { Command } from "commander";
+import { CliError } from "../errors.js";
+import { describeProgram } from "./registry.js";
+const protectedCommands = new WeakMap();
+export const hasSharedContract = (command) => protectedCommands.has(command);
+const snapshot = (command, children) => {
+    const root = new Command("contract");
+    const parent = command.parent;
+    root.addCommand(command);
+    const described = describeProgram(root)[0];
+    command.parent = parent;
+    if (!described)
+        throw new Error("a hidden command cannot own a shared contract");
+    const { commands: _, usage: __, path: ___, ...contract } = described;
+    return structuredClone({
+        ...contract,
+        aliases: [...command.aliases()],
+        children: (children ?? protectedCommands.get(command)?.originalChildren ?? command.commands)
+            .filter((child) => command.commands.includes(child) && !child._hidden)
+            .map((child) => child.name()),
+    });
+};
+const same = isDeepStrictEqual;
+const visit = (root, fn) => {
+    fn(root);
+    for (const child of root.commands)
+        visit(child, fn);
+};
+const pathOf = (command) => {
+    const path = [command.name()];
+    for (let at = command.parent; at?.parent; at = at.parent)
+        path.unshift(at.name());
+    return path;
+};
+const differences = (before, after) => [...new Set([...Object.keys(before), ...Object.keys(after)])].filter((field) => !same(before[field], after[field]));
+export const assertSharedContracts = (root) => {
+    const changed = [];
+    visit(root, (command) => {
+        const protectedContract = protectedCommands.get(command);
+        if (!protectedContract)
+            return;
+        const fields = differences(protectedContract.contract, snapshot(command));
+        if (fields.length)
+            changed.push({ command: pathOf(command).join(" "), fields });
+    });
+    if (changed.length)
+        throw new CliError("configuration_error", `shared contract changed without an explicit override: ${changed.map((one) => `${one.command} (${one.fields.join(", ")})`).join("; ")}; use overrideSharedContract before changing it`, { reason: "contract.unacknowledged-override", contracts: changed });
+};
+/** The callback names the deliberate edit; an already changed contract cannot be acknowledged after the fact. */
+export const overrideSharedContract = (command, reason, change) => {
+    if (reason.trim().length < 10)
+        throw new Error("a shared contract override needs a specific reason");
+    const protectedContract = protectedCommands.get(command);
+    if (!protectedContract)
+        throw new Error("only a core-owned command contract can be overridden");
+    assertSharedContracts(command);
+    const before = snapshot(command);
+    change(command);
+    const after = snapshot(command);
+    const fields = differences(before, after);
+    if (fields.length === 0)
+        throw new Error("a shared contract override must change its named command");
+    for (const field of fields)
+        protectedContract.overrides.push({
+            command: pathOf(command),
+            field,
+            before: before[field] ?? null,
+            after: after[field] ?? null,
+            reason: reason.trim(),
+        });
+    protectedContract.contract = after;
+    return command;
+};
+export const sharedContractOverrides = (root) => {
+    assertSharedContracts(root);
+    const result = [];
+    visit(root, (command) => {
+        for (const override of protectedCommands.get(command)?.overrides ?? [])
+            result.push({ ...structuredClone(override), command: pathOf(command) });
+    });
+    return result;
+};
+/** The original core definitions remain available independently of each host's accepted edits. */
+export const sharedContracts = (root) => {
+    assertSharedContracts(root);
+    const result = {};
+    visit(root, (command) => {
+        const contract = protectedCommands.get(command);
+        if (contract)
+            result[pathOf(command).join(" ")] = structuredClone(contract.reference);
+    });
+    return result;
+};
+/** Preserve the factory signature while recording the definition before host composition can edit it. */
+export const sharedCommand = (factory) => (...args) => {
+    const first = args[0];
+    const before = new Set();
+    if (first instanceof Command)
+        visit(first, (command) => {
+            before.add(command);
+        });
+    const result = factory(...args);
+    const roots = [];
+    if (result instanceof Command)
+        roots.push(result);
+    else if (Array.isArray(result))
+        for (const item of result)
+            if (item instanceof Command)
+                roots.push(item);
+    if (first instanceof Command)
+        visit(first, (command) => {
+            if (!before.has(command) && command.parent && before.has(command.parent) && !roots.includes(command))
+                roots.push(command);
+        });
+    for (const shared of roots) {
+        visit(shared, (command) => {
+            const first = command.description().split("\n")[0] ?? "";
+            if (!command.summary() && first.length > 80)
+                command.summary(`${first.slice(0, 77).replace(/\s+\S*$/, "")}…`);
+        });
+        visit(shared, (command) => {
+            if (!command._hidden && !protectedCommands.has(command))
+                protectedCommands.set(command, {
+                    contract: snapshot(command),
+                    reference: snapshot(command),
+                    overrides: [],
+                    originalChildren: [...command.commands],
+                });
+        });
+        shared.hook("preAction", () => {
+            let root = shared;
+            while (root.parent)
+                root = root.parent;
+            assertSharedContracts(root);
+        });
+    }
+    return result;
+};
+/** Bind a provider shell only when its exact, reviewed differences still match Core. */
+export const customizeSharedCommand = (reference, reason, build, expectedOverrides) => {
+    if (reason.trim().length < 10)
+        throw new Error("a shared contract override needs a specific reason");
+    assertSharedContracts(reference);
+    if (!hasSharedContract(reference))
+        throw new Error("a provider shell needs a protected shared definition");
+    const command = build();
+    assertSharedContracts(command);
+    const pending = [];
+    const edits = [];
+    const bindingPath = (own) => {
+        const path = [own.name()];
+        for (let at = own.parent; at && own !== command; at = at.parent) {
+            path.unshift(at.name());
+            if (at === command)
+                break;
+        }
+        return path;
+    };
+    const adopt = (shared, own) => {
+        const inherited = protectedCommands.get(shared);
+        if (!inherited)
+            return;
+        if (!protectedCommands.has(own)) {
+            const originalChildren = own.commands.filter((child) => inherited.reference.children.includes(child.name()));
+            const actual = snapshot(own, originalChildren);
+            const overrides = differences(inherited.contract, actual).map((field) => ({
+                command: bindingPath(own),
+                field,
+                before: inherited.contract[field] ?? null,
+                after: actual[field] ?? null,
+                reason: reason.trim(),
+            }));
+            for (const edit of overrides)
+                edits.push(edit);
+            pending.push({
+                command: own,
+                record: {
+                    reference: structuredClone(inherited.reference),
+                    contract: actual,
+                    overrides: [...structuredClone(inherited.overrides), ...overrides],
+                    originalChildren,
+                },
+            });
+        }
+        for (const child of shared.commands) {
+            const actual = own.commands.find((one) => one.name() === child.name());
+            if (actual)
+                adopt(child, actual);
+        }
+    };
+    adopt(reference, command);
+    const ordered = (records) => [...records].sort((a, b) => JSON.stringify([a.command, a.field]).localeCompare(JSON.stringify([b.command, b.field])));
+    if (!Array.isArray(expectedOverrides) || !same(ordered(edits), ordered(expectedOverrides)))
+        throw new CliError("configuration_error", `provider shell ${command.name()} differs from its reviewed shared contract overrides; review Core and provider definitions before updating the explicit declarations`, { reason: "contract.unacknowledged-override", expected: expectedOverrides ?? null, actual: edits });
+    for (const { command: own, record } of pending) {
+        protectedCommands.set(own, record);
+        own.hook("preAction", () => {
+            let root = own;
+            while (root.parent)
+                root = root.parent;
+            assertSharedContracts(root);
+        });
+    }
+    assertSharedContracts(command);
+    return command;
+};

package/dist/commands/index.d.ts

@@ -6,7 +6,7 @@
  * a command came from, whether it changes anything, whether it is on its way out — is attached with
  * `annotate`, and to an option with `annotateOption`.
  *
- * Behind its own entry point for the same reason `/http` is: Commander is only a type here, and the
+ * Behind its own entry point for the same reason `/http` is: Commander is loaded by contract guards here, and the
  * root of this package stays free of any command-line framework.
  */
 import type { Command } from "commander";
@@ -20,3 +20,4 @@ export * from "./registry.js";
  * `prefix` keeps those caller-supplied words between the tool name and path in the hint.
  */
 export declare const refuseJoinedPath: (root: Command, args: readonly string[], prefix?: readonly string[]) => void;
+export { assertSharedContracts, customizeSharedCommand, hasSharedContract, overrideSharedContract, type SharedContractOverride, sharedCommand, sharedContractOverrides, sharedContracts, } from "./contracts.js";

package/dist/commands/index.js

@@ -24,3 +24,4 @@ export const refuseJoinedPath = (root, args, prefix = []) => {
         command = next;
     }
 };
+export { assertSharedContracts, customizeSharedCommand, hasSharedContract, overrideSharedContract, sharedCommand, sharedContractOverrides, sharedContracts, } from "./contracts.js";

package/dist/dev/audit.d.ts

@@ -3,12 +3,16 @@ import { type AuditRule, type ParityGroup, type RequiredRoot } from "../standard
 import { type ErrorReason } from "../standards/errors.js";
 import { type Override } from "../standards/lint.js";
 import type { Vocabulary } from "../standards/vocabulary.js";
+import { type Capabilities } from "./capabilities.js";
+import { type ContractEdit } from "./shared-contracts.js";
 export interface AuditInput {
     document: CommandsDocument;
     /** As the CLI printed it, for `key-casing`. */
     raw: unknown;
     schemas?: Readonly<Record<string, unknown>>;
     reasons?: readonly ErrorReason[];
+    contracts?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    overrides?: readonly ContractEdit[];
     /** The CLI's own `lint/` baseline and overrides; its lint rules are then judged by them, not the audit's. */
     lint?: {
         baseline: Readonly<Record<string, readonly string[]>>;
@@ -41,6 +45,7 @@ export interface AuditOptions {
     vocabulary: Vocabulary;
     /** `audit/baseline/<rule>.json`, by rule. */
     baseline: Readonly<Record<string, readonly string[]>>;
+    capabilities?: Capabilities;
     blocks: "new" | "never";
     /** Only new findings that name this CLI block: the one being released. */
     only?: string;

package/dist/dev/audit.js

@@ -1,7 +1,17 @@
 import { AUDIT_RULES } from "../standards/audit.js";
 import { BASE_REASONS } from "../standards/errors.js";
 import { LINT_RULES, OVERRIDE_BUDGET } from "../standards/lint.js";
+import { capabilityDifference } from "./capabilities.js";
 import { judge, kindOf, lintCommands, longName, summaryOf, walk } from "./lint.js";
+import { sharedContractProblems } from "./shared-contracts.js";
+const STRICT_CONTRACT_RULES = new Set([
+    "shared-command-contract",
+    "same-path-contract",
+    "same-flag-meaning",
+    "same-entity-schema",
+    "same-error-reason",
+    "required-root",
+]);
 const byText = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
 const toSnake = (key) => key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 const VALUE_KEYS = new Set(["default", "implies"]);
@@ -66,8 +76,16 @@ const samePathContract = (inputs, groups) => {
                     message: describe(values),
                 });
         };
-        const kinds = new Map([...commands].map(([cli, command]) => [cli, optionKinds(command.options)]));
-        const flags = [...new Set([...kinds.values()].flatMap((one) => [...one.keys()]))].sort(byText);
+        const kinds = new Map([...commands].map(([cli, command]) => [
+            cli,
+            optionKinds([
+                ...(inputs.find((input) => input.document.cli === cli)?.document.global_options ?? []),
+                ...command.options,
+            ]),
+        ]));
+        const flags = [
+            ...new Set([...commands.values()].flatMap((command) => [...optionKinds(command.options).keys()])),
+        ].sort(byText);
         for (const flag of flags)
             push(` ${flag}`, new Map([...kinds].map(([cli, one]) => [cli, shownKind(one.get(flag))])));
         push(": output", new Map([...commands].map(([cli, command]) => [
@@ -166,6 +184,14 @@ const sameErrorReason = (inputs) => {
     return found;
 };
 const CROSS = {
+    "shared-command-contract": (inputs) => inputs.flatMap((input) => input.contracts
+        ? sharedContractProblems(snakeKeys(input.raw).commands, input.contracts, input.overrides).map((problem) => ({
+            rule: "shared-command-contract",
+            clis: [input.document.cli],
+            target: `${input.document.cli} ${problem.path}`,
+            message: problem.message,
+        }))
+        : []),
     "required-root": (inputs, options) => requiredRoots(inputs, options.roots),
     "same-path-contract": (inputs, options) => samePathContract(inputs, options.groups),
     "same-flag-meaning": (inputs) => sameFlagMeaning(inputs),
@@ -173,6 +199,7 @@ const CROSS = {
     "same-error-reason": (inputs) => sameErrorReason(inputs),
 };
 const measuredBy = {
+    "shared-command-contract": (input) => input.contracts !== undefined,
     "same-entity-schema": (input) => input.schemas !== undefined,
     "same-error-reason": (input) => input.reasons !== undefined,
 };
@@ -208,15 +235,44 @@ export const auditClis = (inputs, options, rules = AUDIT_RULES) => {
             return check(inputs, options);
         }),
     ];
+    const protectedInputs = new Set(inputs
+        .filter((input) => input.contracts &&
+        sharedContractProblems(snakeKeys(input.raw).commands, input.contracts, input.overrides)
+            .length === 0)
+        .map((input) => input.document.cli));
+    const inheritedAccepted = new Set(findings
+        .filter((finding) => {
+        if (finding.rule !== "same-path-contract" || finding.target.endsWith(": presence"))
+            return false;
+        const path = finding.target.slice(finding.target.indexOf(" ") + 1).split(/ --|: /)[0] ?? "";
+        return finding.clis.every((cli) => protectedInputs.has(cli) && inputs.find((input) => input.document.cli === cli)?.contracts?.[path]);
+    })
+        .map((finding) => `${finding.rule} ${finding.target}`));
+    const capabilityAccepted = new Set(findings
+        .filter((finding) => finding.rule === "same-path-contract" &&
+        options.capabilities &&
+        capabilityDifference(finding.target, finding.clis, inputs.map((input) => input.document), options.capabilities))
+        .map((finding) => `${finding.rule} ${finding.target}`));
     const declared = new Map(options.groups.flatMap((group) => group.differences.map((entry) => [`${entry.rule} ${entry.target}`, group.name])));
     const found = new Set(findings.map((finding) => `${finding.rule} ${finding.target}`));
     for (const [key, group] of declared)
         if (!found.has(key))
             problems.push(`stale difference in ${group}, no such divergence — remove it: ${key}`);
+    for (const group of options.groups) {
+        for (const difference of group.differences) {
+            const finding = findings.find((one) => one.rule === difference.rule && one.target === difference.target);
+            if (finding && difference.expected !== finding.message) {
+                declared.delete(`${difference.rule} ${difference.target}`);
+                problems.push(`difference in ${group.name} must match the exact current values: ${difference.rule} ${difference.target}`);
+            }
+        }
+    }
     for (const group of options.groups)
         if (group.differences.length > OVERRIDE_BUDGET)
             problems.push(`${group.name} declares ${group.differences.length} differences; the budget is ${OVERRIDE_BUDGET}`);
-    const baselined = new Set(Object.entries(options.baseline).flatMap(([rule, targets]) => targets.map((target) => `${rule} ${target}`)));
+    const baselined = new Set(Object.entries(options.baseline)
+        .filter(([rule]) => !STRICT_CONTRACT_RULES.has(rule))
+        .flatMap(([rule, targets]) => targets.map((target) => `${rule} ${target}`)));
     // A cross-CLI entry names every CLI it compared; a run without one of them can neither see it nor fix it.
     const judged = (target) => clisOf(target).every((cli) => clis.includes(cli));
     const ownLint = (cli, rule) => lintIds.includes(rule) ? inputs.find((input) => input.document.cli === cli)?.lint : undefined;
@@ -245,7 +301,9 @@ export const auditClis = (inputs, options, rules = AUDIT_RULES) => {
                 blocking.push(...mine.filter((finding) => row.new_targets.includes(finding.target)));
             }
             else {
-                const open = mine.filter((finding) => !declared.has(`${rule} ${finding.target}`));
+                const open = mine.filter((finding) => !declared.has(`${rule} ${finding.target}`) &&
+                    !capabilityAccepted.has(`${rule} ${finding.target}`) &&
+                    !inheritedAccepted.has(`${rule} ${finding.target}`));
                 const fresh = open.filter((finding) => !baselined.has(`${rule} ${finding.target}`));
                 const here = new Set(mine.map((finding) => finding.target));
                 row = {
@@ -272,10 +330,13 @@ export const auditClis = (inputs, options, rules = AUDIT_RULES) => {
     const nextBaseline = Object.fromEntries([...lintIds, ...rules.map((rule) => rule.id)].map((rule) => {
         const kept = (options.baseline[rule] ?? []).filter((target) => !judged(target));
         const now = findings
-            .filter((finding) => finding.rule === rule && !declared.has(`${rule} ${finding.target}`))
+            .filter((finding) => finding.rule === rule &&
+            !declared.has(`${rule} ${finding.target}`) &&
+            !capabilityAccepted.has(`${rule} ${finding.target}`) &&
+            !inheritedAccepted.has(`${rule} ${finding.target}`))
             .filter((finding) => !(lintIds.includes(rule) && selfJudged.has(finding.clis[0] ?? "")))
             .map((finding) => finding.target);
-        return [rule, [...new Set([...kept, ...now])].sort(byText)];
+        return [rule, STRICT_CONTRACT_RULES.has(rule) ? kept : [...new Set([...kept, ...now])].sort(byText)];
     }));
     const unique = new Map(blocking.map((finding) => [`${finding.rule} ${finding.target}`, finding]));
     return {

package/dist/dev/capabilities.d.ts

@@ -0,0 +1,20 @@
+import * as v from "valibot";
+import type { CommandsDocument } from "../commands/index.js";
+declare const manifestSchema: v.ObjectSchema<{
+    readonly clis: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly commands: v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
+        readonly in: v.UnionSchema<[v.LiteralSchema<"all", undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>;
+        readonly reason: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly planned: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+        readonly options: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnionSchema<[v.LiteralSchema<"all", undefined>, v.ObjectSchema<{
+            readonly in: v.UnionSchema<[v.LiteralSchema<"all", undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>;
+            readonly reason: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly planned: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>], undefined>, undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type Capabilities = v.InferOutput<typeof manifestSchema>;
+export declare const readCapabilities: (input: unknown) => Capabilities;
+/** Presence differences are accepted only when every observed value matches a declared provider capability. */
+export declare const capabilityDifference: (target: string, clis: readonly string[], documents: readonly CommandsDocument[], manifest: Capabilities) => boolean;
+export {};

package/dist/dev/capabilities.js

@@ -0,0 +1,48 @@
+import * as v from "valibot";
+import { kindOf, longName, walk } from "./lint.js";
+const availability = v.union([v.literal("all"), v.array(v.string())]);
+const entry = v.object({
+    in: availability,
+    reason: v.optional(v.string()),
+    planned: v.optional(v.record(v.string(), v.string())),
+});
+const option = v.union([v.literal("all"), entry]);
+const manifestSchema = v.object({
+    clis: v.array(v.string()),
+    commands: v.record(v.string(), v.object({ ...entry.entries, options: v.optional(v.record(v.string(), option)) })),
+});
+export const readCapabilities = (input) => v.parse(manifestSchema, input);
+/** Presence differences are accepted only when every observed value matches a declared provider capability. */
+export const capabilityDifference = (target, clis, documents, manifest) => {
+    if (clis.some((cli) => !manifest.clis.includes(cli)))
+        return false;
+    const words = target.slice(target.indexOf(" ") + 1);
+    if (words.endsWith(": presence")) {
+        const path = words.slice(0, -10);
+        const ancestor = path
+            .split(" ")
+            .map((_, index, parts) => parts.slice(0, parts.length - index).join(" "))
+            .find((name) => manifest.commands[name] !== undefined);
+        const policy = ancestor ? manifest.commands[ancestor] : undefined;
+        if (!policy || policy.in === "all" || (!policy.reason && !policy.planned))
+            return false;
+        return clis.every((cli) => walk(documents.find((doc) => doc.cli === cli)?.commands ?? []).some((command) => command.path.join(" ") === path) === policy.in.includes(cli));
+    }
+    const flagAt = words.lastIndexOf(" --");
+    if (flagAt < 0)
+        return false;
+    const path = words.slice(0, flagAt), flag = words.slice(flagAt + 1);
+    const policy = manifest.commands[path]?.options?.[flag];
+    if (!policy || policy === "all" || policy.in === "all" || (!policy.reason && !policy.planned))
+        return false;
+    const signatures = new Set();
+    const matches = clis.every((cli) => {
+        const doc = documents.find((doc) => doc.cli === cli);
+        const command = walk(doc?.commands ?? []).find((command) => command.path.join(" ") === path);
+        const option = [...(doc?.global_options ?? []), ...(command?.options ?? [])].find((option) => longName(option.flags) === flag);
+        if (option)
+            signatures.add(kindOf(option));
+        return (option !== undefined) === policy.in.includes(cli);
+    });
+    return matches && signatures.size <= 1;
+};

package/dist/dev/lint.js

@@ -173,14 +173,16 @@ const filteredBy = (flag) => {
         return { window: "id" };
     return { field: bare.replace(/-(time|id|n)$/, "").replaceAll("-", "_") };
 };
-/** An entity's fields: the query's, then its registered schema's properties; `time` for a date-time. */
+/** A declared query is authoritative; without one, scalar schema fields reveal legacy list filters. */
 const entityFields = (command, context) => {
     const fields = new Map((command.query?.fields ?? []).map((field) => [field.name, field.type]));
-    const entity = command.output?.entity ?? command.query?.entity;
+    if (command.query)
+        return fields;
+    const entity = command.output?.entity;
     const schema = entity === undefined ? undefined : context.schemas?.[entity];
     const properties = isObject(schema) && isObject(schema.properties) ? schema.properties : {};
     for (const [name, property] of Object.entries(properties))
-        if (!fields.has(name))
+        if (!fields.has(name) && !typesOf(property).includes("array"))
             fields.set(name, isObject(property) && property.format === "date-time" ? "time" : "other");
     return fields;
 };
@@ -299,11 +301,22 @@ const CHECKS = {
     "filter-flag": (document, vocabulary, context) => {
         const roles = new Map(vocabulary.flags.map((flag) => [flag.name, flag.role]));
         return walk(document.commands)
-            .filter((command) => command.origin === "handwritten" && !declaredWrite(command) && (command.query || command.output))
+            .filter((command) => command.origin === "handwritten" &&
+            !declaredWrite(command) &&
+            (command.query || (["list", "events", "runs"].includes(command.name) && command.output)))
             .flatMap((command) => {
             const fields = entityFields(command, context);
             return command.options
-                .filter((option) => roles.get(longName(option.flags)) !== "scope")
+                .filter((option) => {
+                const flag = longName(option.flags), role = roles.get(flag);
+                if (role === "scope")
+                    return false;
+                const { field, window } = filteredBy(flag);
+                const queryField = command.query?.fields.some((one) => one.name === field);
+                return (window !== undefined ||
+                    queryField ||
+                    !["paging", "output", "sort", "mode", "budget", "action"].includes(role ?? ""));
+            })
                 .flatMap((option) => {
                 const { field, window } = filteredBy(longName(option.flags));
                 const hit = window === "time"

package/dist/dev/main.js

@@ -11,12 +11,13 @@ import spawn from "cross-spawn";
 import * as v from "valibot";
 import { parseCommandsDocument } from "../commands/document.js";
 import { changelogProblems, docsProblems, JOURNAL_IDS, markdownFiles, packageVersion, structureProblems, versionScript, } from "../release/index.js";
-import { AUDIT_BLOCKS, PARITY_GROUPS, REQUIRED_ROOTS } from "../standards/audit.js";
+import { AUDIT_BLOCKS, defineParityGroups, PARITY_GROUPS, REQUIRED_ROOTS } from "../standards/audit.js";
 import { defineReasons } from "../standards/errors.js";
 import { baselineProblems, baselineSchema, LINT_RULES, OVERRIDE_BUDGET, OVERRIDE_RULE_REVIEW, overridesProblems, overridesSchema, rulesForReview, } from "../standards/lint.js";
 import { issuesOf } from "../standards/registry.js";
 import { VOCABULARY } from "../standards/vocabulary.js";
 import { auditClis, scorecardTable, snakeKeys } from "./audit.js";
+import { readCapabilities } from "./capabilities.js";
 import { changelogChange, landFold, processShell } from "./land.js";
 import { baselineOf, judge, lintCommands } from "./lint.js";
 import { nextVersion } from "./next-version.js";
@@ -48,7 +49,7 @@ const USAGE = `usage: cli-dev <command> [options]
                                        lint/baseline/<rule>.json to today's violations. --schemas
                                        is a JSON object of the CLI's own JSON Schemas by name
   audit (--cli <bin> | --commands <file>)... [--schemas <cli>=<file>]... [--reasons <cli>=<file>]...
-        [--lint <cli>=<dir>]... [--baseline <dir>] [--for <cli>] [--json] [--write-baseline]
+        [--lint <cli>=<dir>]... [--capabilities <file>] [--complete] [--differences <file>] [--baseline <dir>] [--for <cli>] [--json] [--write-baseline]
                                        several CLIs against every lint rule and against each other:
                                        required roots, same path same contract, same flag same
                                        meaning, same entity same schema, same failure same reason.
@@ -186,12 +187,12 @@ const readJson = (path) => {
         throw new Error(`${path}: ${error.message}`);
     }
 };
-const commandsJson = (io, cli, file) => {
+const commandsJson = (io, cli, file, commandArgs = ["commands", "--json"]) => {
     if (file)
         return readJson(isAbsolute(file) ? file : join(io.cwd, file));
     const bin = cli ?? "";
     const script = /\.[cm]?js$/.test(bin);
-    const run = spawn.sync(script ? process.execPath : bin, [...(script ? [bin] : []), "commands", "--json"], {
+    const run = spawn.sync(script ? process.execPath : bin, [...(script ? [bin] : []), ...commandArgs], {
         cwd: io.cwd,
         encoding: "utf8",
         maxBuffer: 64 * 1024 * 1024,
@@ -331,6 +332,9 @@ const auditRun = (args, io) => {
             cli: { type: "string", multiple: true },
             commands: { type: "string", multiple: true },
             schemas: { type: "string", multiple: true },
+            capabilities: { type: "string" },
+            complete: { type: "boolean", default: false },
+            differences: { type: "string" },
             reasons: { type: "string", multiple: true },
             lint: { type: "string", multiple: true },
             baseline: { type: "string", default: "audit/baseline" },
@@ -352,18 +356,60 @@ const auditRun = (args, io) => {
     const reasons = byCli(values.reasons, "--reasons");
     const lintDirs = byCli(values.lint, "--lint");
     const problems = [];
+    const evidence = new Map();
+    if (values.complete) {
+        for (const [index, bin] of (values.cli ?? []).entries()) {
+            const raw = raws[index];
+            const data = commandsJson(io, bin, undefined, ["commands", "info", "--json"]);
+            if (typeof raw.cli === "string")
+                evidence.set(raw.cli, data);
+        }
+    }
     const inputs = raws.map((raw) => {
         const parsed = parseCommandsDocument(snakeKeys(raw));
         if (!parsed.document)
             throw new Error(`a commands document is not the shape cli-base's commandsDocument() writes: ${parsed.problems[0]}`);
         const cli = parsed.document.cli;
-        const input = { document: parsed.document, raw };
+        const input = { document: parsed.document, raw, ...evidence.get(cli) };
         const schemaFile = schemas.get(cli);
         if (schemaFile)
             input.schemas = readJson(at(schemaFile));
         const reasonFile = reasons.get(cli);
         if (reasonFile)
             input.reasons = defineReasons(readJson(at(reasonFile)));
+        if (values.complete) {
+            if (!input.contracts ||
+                typeof input.contracts !== "object" ||
+                Array.isArray(input.contracts) ||
+                Object.keys(input.contracts).length === 0)
+                problems.push(`${cli}: complete audit needs core contract references from commands info`);
+            for (const root of REQUIRED_ROOTS) {
+                const path = root.path.join(" ");
+                if (!input.contracts?.[path])
+                    problems.push(`${cli}: complete audit needs an inherited contract reference for ${path}`);
+            }
+            if (!input.schemas ||
+                typeof input.schemas !== "object" ||
+                Array.isArray(input.schemas) ||
+                Object.keys(input.schemas).length === 0)
+                problems.push(`${cli}: complete audit needs nonempty entity schemas from commands info or --schemas`);
+            if (!Array.isArray(input.reasons) || input.reasons.length === 0)
+                problems.push(`${cli}: complete audit needs declared error reasons from commands info or --reasons`);
+            if (input.reasons)
+                input.reasons = defineReasons(input.reasons);
+            if (input.schemas) {
+                const visit = (commands) => {
+                    for (const command of commands) {
+                        const names = [command.output?.entity, command.query?.entity].filter((name) => name !== undefined);
+                        for (const name of names)
+                            if (input.schemas?.[name] === undefined)
+                                problems.push(`${cli}: complete audit has no schema for ${name} (${command.path.join(" ")})`);
+                        visit(command.commands);
+                    }
+                };
+                visit(input.document.commands);
+            }
+        }
         const dir = lintDirs.get(cli);
         if (dir) {
             const overridesPath = join(at(dir), "overrides.json");
@@ -398,8 +444,32 @@ const auditRun = (args, io) => {
         problems.push(`--for names ${values.for}, which is not audited`);
     const baselineDir = at(values.baseline);
     const baseline = readBaseline(baselineDir, values.baseline, problems);
+    let groups = PARITY_GROUPS;
+    if (values.differences) {
+        const schema = v.array(v.strictObject({
+            group: v.string(),
+            rule: v.string(),
+            target: v.string(),
+            expected: v.string(),
+            reason: v.string(),
+        }));
+        const parsed = v.safeParse(schema, readJson(at(values.differences)));
+        if (!parsed.success)
+            throw new Error(`${values.differences}: ${issuesOf(parsed.issues).join("; ")}`);
+        for (const entry of parsed.output)
+            if (!groups.some((group) => group.name === entry.group))
+                throw new Error(`${values.differences}: unknown group ${entry.group}`);
+        groups = defineParityGroups(groups.map((group) => ({
+            ...group,
+            differences: [
+                ...group.differences,
+                ...parsed.output.filter((entry) => entry.group === group.name).map(({ group: _, ...entry }) => entry),
+            ],
+        })));
+    }
     const result = auditClis(inputs, {
-        groups: PARITY_GROUPS,
+        ...(values.capabilities ? { capabilities: readCapabilities(readJson(at(values.capabilities))) } : {}),
+        groups,
         roots: REQUIRED_ROOTS,
         vocabulary: VOCABULARY,
         baseline,

package/dist/dev/shared-contracts.d.ts

@@ -0,0 +1,13 @@
+import type { CommandInfo } from "../commands/index.js";
+export interface ContractEdit {
+    command: readonly string[];
+    field: string;
+    before: unknown;
+    after: unknown;
+    reason: string;
+}
+/** A baseline cannot replace a core definition: only an exact, reasoned edit changes its effective value. */
+export declare const sharedContractProblems: (commands: readonly CommandInfo[], references: Readonly<Record<string, Readonly<Record<string, unknown>>>>, edits?: readonly ContractEdit[]) => {
+    path: string;
+    message: string;
+}[];

package/dist/dev/shared-contracts.js

@@ -0,0 +1,85 @@
+const stable = (value) => {
+    if (Array.isArray(value))
+        return value.map(stable);
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, child]) => [key, stable(child)]));
+    return value;
+};
+const same = (left, right) => JSON.stringify(stable(left ?? null)) === JSON.stringify(stable(right ?? null));
+const FIELDS = new Set([
+    "name",
+    "summary",
+    "description",
+    "origin",
+    "api_operation",
+    "effects",
+    "state",
+    "partial",
+    "lifetime",
+    "reaches",
+    "mcp",
+    "offline",
+    "cooperative",
+    "examples",
+    "output",
+    "query",
+    "runnable",
+    "arguments",
+    "options",
+    "aliases",
+    "children",
+]);
+/** A baseline cannot replace a core definition: only an exact, reasoned edit changes its effective value. */
+export const sharedContractProblems = (commands, references, edits = []) => {
+    const effective = new Map(Object.entries(references).map(([path, contract]) => [path, structuredClone(contract)]));
+    const problems = [];
+    for (const edit of edits) {
+        const path = edit.command.join(" ");
+        const contract = effective.get(path);
+        if (!contract ||
+            !FIELDS.has(edit.field) ||
+            edit.reason.trim().length < 10 ||
+            !same(contract[edit.field], edit.before) ||
+            same(edit.before, edit.after)) {
+            problems.push({ path, message: `invalid or stale explicit override for ${edit.field}` });
+            continue;
+        }
+        if (edit.after === null)
+            delete contract[edit.field];
+        else
+            contract[edit.field] = structuredClone(edit.after);
+    }
+    const walk = (items, inherited) => {
+        for (const command of items) {
+            const path = command.path.join(" ");
+            const expected = effective.get(path);
+            if (expected) {
+                const { path: _, usage: __, commands: nested, ...fields } = command;
+                const original = references[path]?.children;
+                const actual = {
+                    ...fields,
+                    ...(Array.isArray(original)
+                        ? { children: nested.filter((child) => original.includes(child.name)).map((child) => child.name) }
+                        : {}),
+                };
+                const wanted = { ...expected, ...inherited };
+                const changed = [...new Set([...Object.keys(actual), ...Object.keys(wanted)])].filter((field) => field !== "aliases" &&
+                    field !== "availability" &&
+                    !same(actual[field], wanted[field]));
+                if (changed.length)
+                    problems.push({ path, message: `core contract differs without an exact override: ${changed.join(", ")}` });
+                effective.delete(path);
+            }
+            walk(command.commands, {
+                ...(inherited.mcp === false || expected?.mcp === false ? { mcp: false } : {}),
+                ...(inherited.offline === false || expected?.offline === false ? { offline: false } : {}),
+            });
+        }
+    };
+    walk(commands, {});
+    for (const path of effective.keys())
+        problems.push({ path, message: "core contract names a command absent from discovery" });
+    return problems;
+};

package/dist/standards/audit.d.ts

@@ -23,6 +23,7 @@ declare const parityGroupSchema: v.StrictObjectSchema<{
     readonly differences: v.ArraySchema<v.StrictObjectSchema<{
         readonly rule: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a lower-case word, words joined by -">]>;
         readonly target: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+        readonly expected: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>, undefined>;
         readonly reason: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>, v.MinLengthAction<string, 10, "say why, in a sentence">]>;
     }, undefined>, undefined>;
 }, undefined>;

package/dist/standards/audit.js

@@ -10,6 +10,11 @@ const auditRuleSchema = v.strictObject({ id: word, severity: v.picklist(LINT_SEV
 export const defineAuditRules = (input) => parseRegistry("audit rules", v.array(auditRuleSchema), input, (rules) => duplicates(rules.map((rule) => rule.id)).map((id) => `"${id}" is listed twice`));
 /** The rules that compare CLIs; each CLI is also judged alone by every lint rule. */
 export const AUDIT_RULES = defineAuditRules([
+    {
+        id: "shared-command-contract",
+        severity: "high",
+        summary: "core-owned command definitions change only through exact, reasoned overrides",
+    },
     {
         id: "required-root",
         severity: "high",
@@ -44,7 +49,12 @@ const parityGroupSchema = v.strictObject({
     /** `tree` compares every path; otherwise the root words whose paths are compared. */
     covers: v.union([v.literal("tree"), v.pipe(v.array(segment), v.minLength(1))]),
     /** Permanent differences, each with its reason; they count against the override budget of the group. */
-    differences: v.array(v.strictObject({ rule: word, target: text, reason: v.pipe(text, v.minLength(10, "say why, in a sentence")) })),
+    differences: v.array(v.strictObject({
+        rule: word,
+        target: text,
+        expected: v.optional(text),
+        reason: v.pipe(text, v.minLength(10, "say why, in a sentence")),
+    })),
 });
 export const defineParityGroups = (input) => parseRegistry("parity groups", v.array(parityGroupSchema), input, (groups) => [
     ...duplicates(groups.map((group) => group.name)).map((name) => `"${name}" is listed twice`),

package/dist/standards/flags-how.js

@@ -291,6 +291,12 @@ export const HOW_FLAGS = [
         type: "duration",
         meaning: "how old a stored snapshot may be and still count as fresh",
     },
+    {
+        name: "--draft",
+        role: "mode",
+        type: "switch",
+        meaning: "save text for the owner to review and send, without sending a message",
+    },
     { name: "--md", role: "mode", type: "switch", meaning: "the text is the messenger's Markdown" },
     { name: "--no-backup", role: "mode", type: "switch", meaning: "do not back the file up before deleting it" },
     { name: "--no-input", role: "mode", type: "switch", meaning: "never prompt or open an interactive login" },
@@ -448,6 +454,12 @@ export const HOW_FLAGS = [
         meaning: "override one permission for this run; repeat it for more",
     },
     { name: "--read-only", role: "mode", type: "switch", meaning: "refuse every write, local and remote" },
+    {
+        name: "--append",
+        role: "mode",
+        type: "switch",
+        meaning: "keep existing entries and add the explicitly named one beside them",
+    },
     { name: "--replace", role: "mode", type: "switch", meaning: "overwrite an existing one of the same name" },
     {
         name: "--rescan",

package/dist/standards/flags-what.js

@@ -436,6 +436,13 @@ export const WHAT_FLAGS = [
     },
     { name: "--task", value: "<id>", role: "target", type: "id", meaning: "a task, by id" },
     { name: "--to", value: "<chat>", role: "target", type: "id", meaning: "the chat it goes to" },
+    {
+        name: "--topic-name",
+        value: "<name>",
+        role: "target",
+        type: "string",
+        meaning: "a stored meeting topic label, by name or alias",
+    },
     { name: "--topic", value: "<id>", role: "target", type: "id", meaning: "the forum topic, in a chat that has topics" },
     { name: "--transcript-id", value: "<id>", role: "target", type: "id", meaning: "one transcript version, by id" },
     { name: "--until-id", value: "<id>", role: "target", type: "id", meaning: "up to and including this message id" },

package/docs/standards/README.md

@@ -38,8 +38,8 @@ rules it keeps. A new CLI is ready for its first release when every check under
 | [Testing](testing.md) | `TEST` | 17 | Sandbox, no network, no real waits, leak tests, coverage, contracts, test matrix, parity |
 | [Security](security.md) | `SECR` | 20 | Secrets, logs, keyring, argv, error text, untrusted text, scanners, workflow hardening, reporting |
 | [Documents](docs.md) | `DOC` | 20 | User pages and developer pages, generated pages, current facts, changelog |
-| [Comparisons](comparisons.md) | `CMP` | 10 | Which tools a comparison page lists, rows as user tasks, agents and safety, where others are better, proof of marks |
-| [Releases](releases.md) | `REL` | 16 | `bin/release`, the release lock, versions, release reports, trusted publishing |
+| [Comparisons](comparisons.md) | `CMP` | 11 | Which tools a comparison page lists, rows as user tasks, agents and safety, where others are better, proof of marks |
+| [Releases](releases.md) | `REL` | 15 | `bin/release`, the release lock, versions, release reports, trusted publishing |
 | [CI](ci.md) | `CI` | 12 | Hooks, the pull request budget, full validation, monthly runs |
 | [Time](time.md) | `TIME` | 6 | UTC in the store and in answers, the zone at input and display edges, date-only filters, tests in another zone |
 | [Style](style.md) | `STYLE` | 10 | Comments, TypeScript habits, commit messages |

package/docs/standards/comparisons.md

@@ -2,9 +2,13 @@
 
 ## Scope
 
-How a CLI's comparison page (`docs/compare.md`) is written: which tools it compares, which rows it has, how a mark is
-proven, and what it says about the places where another tool is better. The page is read by someone choosing a tool
-for a job, not by someone reviewing our code.
+How a CLI's comparison page is written: which tools it compares, which rows it has, how a mark is proven, and what it
+says about the places where another tool is better. The page is read by someone choosing a tool for a job, not by
+someone reviewing our code.
+
+The page lives in the site repository (`cli-docs`, published on wirecat.dev), not in the CLI repository, because a
+comparison changes when the other tools change, not when we release. The CLI repository keeps a short
+`docs/compare.md` that links to the site page, and its other docs link there too.
 
 Rule ids on this page are `WC-CMP-<n>`. How to read a rule, how ids work and which rule wins are in the
 [index](README.md). The general rules for user pages are in [Documents](docs.md).
@@ -112,7 +116,18 @@ Rule ids on this page are `WC-CMP-<n>`. How to read a rule, how ids work and whi
 - **Exceptions:** none.
 - **Applies to:** all CLIs. **Since:** cli-base 0.50.4. **Rulings:** owner, 2026-10-24.
 
+### WC-CMP-11 · Our marks are re-checked at each release
+
+- **Why:** our own marks go stale with every release, and a mark that says we lack something we have shipped, or the
+  reverse, is the error a reader finds first.
+- **Enforced by:** review only.
+- **Example:** the release report lists the compare page as checked. Before a release, each ✅, 🟡 and ❌ for the CLI is re-proven against the release build, the check date
+  and version in the intro are updated in the site repository, and the release report names the page.
+- **Exceptions:** none.
+- **Applies to:** all CLIs. **Since:** cli-base 0.50.5. **Rulings:** owner, 2026-10-24.
+
 ## Sources
 
 - Owner review of the max, zm and memo comparison pages, 2026-10-24.
-- The tg comparison page, `tg-cli/docs/compare.md`, the first page written this way.
+- The tg comparison page, the first page written this way.
+- Owner decision, 2026-10-24: comparison pages live in `cli-docs`; each CLI's docs link to them.

package/docs/standards/new-cli.md

@@ -92,8 +92,8 @@ whatsapp-cli is the worked example: it has every file below. Compare with it whe
 8. **`SECURITY.md`**: how to report a vulnerability, linking cli-testing's security method. See
    [Security](security.md).
 9. **`bin/release`**, **`release.yml`** and a release skill, copied from the nearest CLI. `bin/release` takes the
-   release lock (WC-REL-3) and npm's trusted publisher settings name `release.yml`. A messenger CLI also waits two
-   hours between releases and checks a signed release report (WC-REL-8, WC-REL-10). See [Releases](releases.md).
+   release lock (WC-REL-3) and npm's trusted publisher settings name `release.yml`. A messenger CLI also checks a signed
+   release report (WC-REL-10). See [Releases](releases.md).
 10. **`src/version.ts`** kept in step with `package.json`. Proved by: `pnpm version:check`.
 
 ## Done when

package/docs/standards/releases.md

@@ -88,29 +88,17 @@ on the [CI](ci.md) page.
 - **Exceptions:** a pre-release version (`0.41.0-rc.1`) is chosen by hand.
 - **Applies to:** all CLIs and shared libraries. **Since:** cli-base 0.41.0. **Rulings:** none.
 
-### WC-REL-8 · A messenger CLI waits two hours between releases; a shared library does not wait
+### WC-REL-8 · Any package may release at any time
 
-- **Why:** a broken CLI release must be noticed before the next one lands on top of it. Every CLI waits for a library
-  release, so a gap there only delays them.
-- **Enforced by:** `<app>: bin/release`.
-- **Example:** tg-cli, max-cli and whatsapp-cli's `bin/release` refuse to start within two hours of the last version
-  on npm. cli-base and cli-core release one after another with no gap.
-- **Exceptions:** memo, drive and zoom have no gap in their `bin/release` today.
-- **Applies to:** messenger CLIs (gap); shared libraries (no gap). **Since:** cli-base 0.41.0. **Rulings:** NEED-854.
-
-### WC-REL-9 · A change to a stable shared-library export that makes a CLI change its code ships at most once a week
-
-- **Why:** the limit keeps the CLIs from chasing versions; a change that no CLI has to follow gives them nothing to
-  chase.
-- **Enforced by:** `cli-core: parity.yml` (it decides which changes count; review keeps the week).
-- **Example:** cli-core's parity jobs build tg-cli, max-cli and whatsapp-cli from their `main` against every pull
-  request. A change to a stable export counts unless all three jobs pass with each CLI's `main` unchanged; its
-  changelog still lists it under "Changed — may break callers" for outside users. It counts when a job fails, when it
-  passes only against a CLI branch made for the change, and when it compiles but changes behaviour that any CLI must
-  adapt to. Parity cannot see that last case, so when in doubt the change counts. Gather the changes that count into
-  one release a week, and bump the library in every CLI that uses it on the same day.
-- **Exceptions:** none.
-- **Applies to:** shared libraries. **Since:** cli-base 0.41.0. **Rulings:** NEED-473, NEED-1552.
+- **Why:** a wait between releases or a weekly limit on breaking changes only delays a fix; the owner removed both
+  limits on 2026-10-24.
+- **Enforced by:** review only.
+- **Example:** tg-cli can release an hour after its last version, and cli-core can ship a breaking change on the same
+  day as the previous one. Bump the library in every CLI that uses it on the day it ships.
+- **Exceptions:** none. The release lock (WC-REL-3) still keeps two releases on one machine from running at once.
+- **Applies to:** all CLIs and shared libraries. **Since:** cli-base 0.52.0. **Rulings:** NEED-1741.
+
+### WC-REL-9 · Merged into [WC-REL-8](#wc-rel-8--any-package-may-release-at-any-time)
 
 ### WC-REL-10 · A messenger CLI is released only with a release report the owner signed for that commit
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-base",
-  "version": "0.50.4",
+  "version": "0.51.1",
   "description": "The parts every command line tool needs: output modes, terminal rendering, error model, exit codes, credentials, clocks",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",