@wirecat/cli-base 0.68.0 → 0.68.1

package/CHANGELOG.md

@@ -8,6 +8,17 @@ 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.68.1 — 31.10.2026
+
+### Added
+
+- **The audit accepts a flag that one CLI lacks by design, by name.** A parity difference may carry `absent: "<cli>"`
+  with a target of `<path> <flag>` and no CLI list; it covers every finding where only that CLI lacks the flag and the
+  others agree, so another CLI joining the group does not make it stale. `PARITY_GROUPS` uses it to declare that memo
+  has no profiles of its own (no `--profiles` on `mcp serve`, `mcp revoke`, `mcp server start|status|stop`); memo
+  selects other CLIs' accounts with `--source` and `--account`. A run without the absent CLI does not call it stale.
+  WC-MCP-9 and WC-ACCT-1 say so. See [#390](https://github.com/WireCatLabs/cli-base/issues/390).
+
 ## 0.68.0 — 31.10.2026
 
 ### Removed

package/dist/dev/audit.d.ts

@@ -26,6 +26,8 @@ export interface Finding {
     /** `<clis> <what>`: `max+tg chats list --limit`, `zm upgrade`, `tg: chats grab` for a lint violation. */
     target: string;
     message: string;
+    /** What each CLI showed, for a finding about one flag or output; `absent` when it lacks the flag. */
+    values?: Record<string, string>;
 }
 export interface ScoreRow {
     cli: string;

package/dist/dev/audit.js

@@ -74,6 +74,7 @@ const samePathContract = (inputs, groups) => {
                     clis: having,
                     target: `${named(having)} ${path}${what}`,
                     message: describe(values),
+                    values: Object.fromEntries(values),
                 });
         };
         const kinds = new Map([...commands].map(([cli, command]) => [
@@ -253,18 +254,35 @@ export const auditClis = (inputs, options, rules = AUDIT_RULES) => {
         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])));
+    // An `absent` difference names no CLI list: it stands for every finding where only that CLI lacks the flag.
+    const differences = options.groups.flatMap((group) => group.differences.flatMap((entry) => {
+        if (!entry.absent)
+            return [{ group: group.name, ...entry }];
+        const matching = findings.filter((finding) => {
+            if (finding.rule !== entry.rule || finding.target !== `${named(finding.clis)} ${entry.target}`)
+                return false;
+            const others = Object.entries(finding.values ?? {}).filter(([cli]) => cli !== entry.absent);
+            return (finding.values?.[entry.absent] === "absent" && new Set(others.map(([, value]) => value)).size === 1);
+        });
+        if (matching.length === 0 && clis.includes(entry.absent))
+            problems.push(`stale difference in ${group.name}, no such divergence — remove it: ${entry.rule} ${entry.target} (absent in ${entry.absent})`);
+        return matching.map((finding) => ({
+            ...entry,
+            group: group.name,
+            target: finding.target,
+            expected: finding.message,
+        }));
+    }));
+    const declared = new Map(differences.map((entry) => [`${entry.rule} ${entry.target}`, entry.group]));
     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 difference of 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 ${difference.group} must match the exact current values: ${difference.rule} ${difference.target}`);
         }
     }
     for (const group of options.groups)

package/dist/dev/main.js

@@ -575,7 +575,8 @@ const auditRun = (args, io) => {
             group: v.string(),
             rule: v.string(),
             target: v.string(),
-            expected: v.string(),
+            expected: v.optional(v.string()),
+            absent: v.optional(v.string()),
             reason: v.string(),
         }));
         const parsed = v.safeParse(schema, readJson(at(values.differences)));

package/dist/standards/audit.d.ts

@@ -22,8 +22,11 @@ declare const parityGroupSchema: v.StrictObjectSchema<{
     /** Permanent differences, each with its reason; they count against the override budget of the group. */
     readonly differences: v.ArraySchema<v.StrictObjectSchema<{
         readonly rule: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a lower-case word, words joined by -">]>;
+        /** `<clis> <path> <flag>`; with `absent`, only `<path> <flag>`: the CLI list is whoever else has it. */
         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>;
+        /** The CLI that lacks the path or flag by design; the rest must agree, so other CLIs joining do not stale it. */
+        readonly absent: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a lower-case word, words joined by -">]>, 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

@@ -51,14 +51,22 @@ const parityGroupSchema = v.strictObject({
     /** Permanent differences, each with its reason; they count against the override budget of the group. */
     differences: v.array(v.strictObject({
         rule: word,
+        /** `<clis> <path> <flag>`; with `absent`, only `<path> <flag>`: the CLI list is whoever else has it. */
         target: text,
         expected: v.optional(text),
+        /** The CLI that lacks the path or flag by design; the rest must agree, so other CLIs joining do not stale it. */
+        absent: v.optional(word),
         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`),
-    ...groups.flatMap((group) => duplicates(group.differences.map((entry) => `${entry.rule} ${entry.target}`)).map((both) => `${group.name}: "${both}" is listed twice`)),
+    ...groups.flatMap((group) => [
+        ...duplicates(group.differences.map((entry) => `${entry.rule} ${entry.target}`)).map((both) => `${group.name}: "${both}" is listed twice`),
+        ...group.differences
+            .filter((entry) => entry.absent && entry.expected)
+            .map((entry) => `${group.name}: "${entry.target}" has \`absent\`, which measures the values itself; drop \`expected\``),
+    ]),
 ]);
 export const PARITY_GROUPS = defineParityGroups([
     { name: "messengers", members: ["tg", "max"], covers: "tree", differences: [] },
@@ -66,7 +74,13 @@ export const PARITY_GROUPS = defineParityGroups([
         name: "all",
         members: ["tg", "max", "memo", "drive", "zm", "wa", "mail"],
         covers: ["commands", "doctor", "skill", "mcp", "upgrade", "search", "notes", "meetings"],
-        differences: [],
+        differences: ["mcp serve", "mcp revoke", "mcp server start", "mcp server status", "mcp server stop"].map((path) => ({
+            rule: "same-path-contract",
+            target: `${path} --profiles`,
+            absent: "memo",
+            reason: "memo has no profiles: it reads other CLIs' stores and selects their accounts with --source and --account " +
+                "(https://github.com/WireCatLabs/cli-base/issues/390)",
+        })),
     },
     // gcal is compared on what it already shares with every CLI; doctor, mcp, search and skill wait until the published
     // CLIs agree there (https://github.com/WireCatLabs/cli-base/issues/390), then gcal moves back into "all".

package/docs/standards/accounts.md

@@ -14,7 +14,9 @@ Rule ids on this page are `WC-ACCT-<n>`. How to read a rule, how ids work and wh
 ### Who follows these rules today
 
 cli-core resolves the profile for tg, max and wa. WC-ACCT-1 needs cli-core 0.319.0 or newer. memo has no messenger profile: its shared commands run without one, and they pick accounts with `--provider`
-and `--account` (WC-ACCT-7). zoom resolves its own profile word by the same rules (`zm <profile> …`, `ZM_PROFILE`,
+and `--account` (WC-ACCT-7). memo never creates profiles of its own: it reads the stores of other CLIs and selects
+their accounts with `--source email:<name>` or `--account telegram:1`, so it has no `--profiles` either
+([cli-base#390](https://github.com/WireCatLabs/cli-base/issues/390), owner decision 2026-10-31). zoom resolves its own profile word by the same rules (`zm <profile> …`, `ZM_PROFILE`,
 `ZM_PROFILE_LOCK`) from zoom-cli 0.35.0, with cli-core's `liftProfile` and `usableProfileName`. drive still has its own
 profile code: it registers its own profiles. That is a known gap, not an exception. gcal resolves the profile through
 cli-core's `run()`, like tg, max and wa. Which CLIs lack a sign-in command of WC-ACCT-12 is listed in that rule.
@@ -48,7 +50,8 @@ profile.
 - **Example:** `max work bot messages send …` uses the same first word as `max work chats list`. `tg --json chats list`
   still works, because `--json` is an option.
 - **Exceptions:** `mcp serve --profiles <names|all>` names the profiles one server serves ([WC-MCP-9](mcp.md#wc-mcp-9--a-server-serves-the-profiles-it-is-told-with-one-connection-for-each)). It is used in
-  place of the first word, never with it.
+  place of the first word, never with it. memo has no profiles of its own, so it has neither the first word nor
+  `--profiles`; it selects the accounts of other CLIs with `--source` and `--account`.
 - **Applies to:** all CLIs. **Since:** cli-base 0.41.0. **Rulings:** NEED-84, NEED-294, NEED-1881.
 
 ### WC-ACCT-3 · A missing profile is an error that lists the choices

package/docs/standards/mcp.md

@@ -155,7 +155,11 @@ and lists the profiles served. Each call follows its own profile's permissions.
 - **Example:** `max work mcp serve`, `max mcp serve --profiles work,personal` or `max mcp serve --profiles all`.
   Under the last two, a call reads `max_read { "profile": "work", "command": "inbox", "arguments": {} }`.
   `max mcp serve` alone is refused, and its message lists `personal` and `work`.
-- **Exceptions:** the bot server needs no held connection: each Bot API call is plain HTTPS.
+- **Exceptions:** the bot server needs no held connection: each Bot API call is plain HTTPS. memo has no profiles of
+  its own, so `--profiles` stays absent on its `mcp serve`, `mcp revoke` and `mcp server start`, `status` and `stop`;
+  it reads other CLIs' stores and selects their accounts with `--source email:<name>` or `--account telegram:1`
+  ([cli-base#390](https://github.com/WireCatLabs/cli-base/issues/390), owner decision 2026-10-31). The audit declares
+  this once, as a difference of memo, not of the other CLIs.
 - **Applies to:** messenger CLIs. **Since:** cli-base 0.41.0. **Rulings:** NEED-1881.
 
 ### WC-MCP-10 · A tool and its command give the same answer and the same error

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-base",
-  "version": "0.68.0",
+  "version": "0.68.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",