@wirecat/cli-base 0.63.0 → 0.65.0

package/dist/dev/bundle.js

@@ -0,0 +1,280 @@
+/**
+ * `cli-dev bundle`: the published bin starts from an esbuild bundle of `dist/`, so a command loads a few dozen files
+ * instead of about a thousand. Moved from tg-cli's `scripts/bundle.ts`, where it was proven first.
+ *
+ * - `dist/bundle/` holds the bundle. Its chunks keep every lazy `import()` lazy.
+ * - The bin becomes a loader: it answers `--version`, turns the compile cache on before any of the bundle compiles,
+ *   and for a server preloads every chunk so an in-place upgrade cannot pull one from under it.
+ * - A module moved into a chunk would look for files and packages from the chunk. In the CLI's own modules and in the
+ *   anchored packages (cli-core, cli-base), `import.meta.url` becomes the module's own place, and a package they load
+ *   at run time is resolved from there too: pnpm installs cli-core's dependencies beside cli-core, not beside the CLI.
+ * - The build fails when a bundled module would still look in the wrong place.
+ */
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { isBuiltin } from "node:module";
+import { basename, dirname, join, relative, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+/** Native modules, Bun's SQLite, and what cli-core loads only by name or starts as a worker from its own file. */
+export const DEFAULT_EXTERNAL = [
+    "bun:sqlite",
+    "*.node",
+    "better-sqlite3",
+    "@napi-rs/*",
+    "@resvg/*",
+    "@huggingface/*",
+    "sherpa-onnx*",
+    "onnxruntime-*",
+    "@wirecat/cli-core-onnx",
+    "@wirecat/cli-core-sqlite",
+    "ogg-opus-decoder",
+];
+export const DEFAULT_ANCHORED = ["@wirecat/cli-core", "@wirecat/cli-base"];
+// commander and @colors name these in comments and messages; liquidjs resolves partials with explicit `paths`, so the
+// requiring file does not matter.
+export const DEFAULT_HARMLESS = [
+    "/commander/lib/command.js",
+    "/@colors/colors/lib/colors.js",
+    "/liquidjs/dist/liquid.node.js",
+];
+export const LOADER_MARK = "// cli-dev bundle loader\n";
+const posix = (path) => path.split(sep).join("/");
+const matcher = (patterns) => {
+    const expressions = patterns.map((pattern) => new RegExp(`^${pattern.replaceAll(".", "\\.").replaceAll("*", ".*")}$`));
+    return (specifier) => expressions.some((expression) => expression.test(specifier));
+};
+// Node has no "resolve from this parent" call; a resolve hook for the one call gives Node's own answer. Bun has no
+// hooks but has `Bun.resolveSync(specifier, parent)`; when it finds nothing, the plain lookup keeps Bun's own error.
+const FROM = "cli-dev-bundle:from";
+const FROM_SOURCE = `import * as module from "node:module"
+import { dirname } from "node:path"
+import { fileURLToPath, pathToFileURL } from "node:url"
+export const resolveFrom = (parent, specifier) => {
+  if (globalThis.Bun) {
+    if (specifier.includes(":")) return import.meta.resolve(specifier)
+    try {
+      return pathToFileURL(globalThis.Bun.resolveSync(specifier, dirname(fileURLToPath(parent)))).href
+    } catch {
+      return import.meta.resolve(specifier)
+    }
+  }
+  if (!module.registerHooks) return import.meta.resolve(specifier)
+  const hooks = module.registerHooks({
+    resolve: (asked, context, next) => next(asked, asked === specifier ? { ...context, parentURL: parent } : context),
+  })
+  try {
+    return import.meta.resolve(specifier)
+  } finally {
+    hooks.deregister()
+  }
+}
+export const importFrom = async (parent, specifier) => import(resolveFrom(parent, specifier))
+`;
+const BY_NAME = /(?<![\w$.])import\(\s*(?!["'`.])/g;
+const LITERAL = /(?<![\w$.])import\(\s*(["'])([^"'.][^"']*)\1\s*\)/g;
+const ownPlaces = (dist, out, anchored, harmless, isExternal, problems) => {
+    const placeOf = (file) => {
+        if (file.startsWith(dist + sep))
+            return `new URL(${JSON.stringify(posix(relative(out, file)))}, import.meta.url).href`;
+        for (const name of anchored) {
+            const marker = `${sep}node_modules${sep}${name.replace("/", sep)}${sep}`;
+            const at = file.lastIndexOf(marker);
+            if (at < 0)
+                continue;
+            const packageRoot = file.slice(0, at + marker.length);
+            const manifest = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
+            const entry = manifest.exports?.["."]?.default;
+            if (typeof entry !== "string")
+                throw new Error(`${name}: package.json has no exports["."].default to anchor on`);
+            const path = posix(relative(dirname(join(packageRoot, entry)), file));
+            return `new URL(${JSON.stringify(path)}, import.meta.resolve(${JSON.stringify(name)})).href`;
+        }
+        return undefined;
+    };
+    return {
+        name: "own-places",
+        setup(context) {
+            context.onResolve({ filter: new RegExp(`^${FROM}$`) }, () => ({ path: FROM, namespace: FROM }));
+            context.onLoad({ filter: /.*/, namespace: FROM }, () => ({ contents: FROM_SOURCE, loader: "js" }));
+            context.onLoad({ filter: /\.[cm]?js$/ }, (args) => {
+                const source = readFileSync(args.path, "utf8");
+                const place = placeOf(args.path);
+                if (!place) {
+                    const known = harmless.some((path) => posix(args.path).endsWith(path));
+                    if (!known && /import\.meta|__dirname|__filename|require\.resolve/.test(source))
+                        problems.push(args.path);
+                    return undefined;
+                }
+                const loadsOutside = [...source.matchAll(LITERAL)].some(([, , specifier]) => specifier && isExternal(specifier));
+                if (!source.includes("import.meta") && source.search(BY_NAME) < 0 && !loadsOutside)
+                    return undefined;
+                const other = source.match(/import\.meta\.(?!url\b|resolve\b)\w+/);
+                if (other)
+                    problems.push(`${args.path}: ${other[0]}`);
+                // `place` holds `import.meta.url` or `import.meta.resolve`, so it goes in last.
+                const contents = source
+                    .replaceAll(/import\.meta\.resolve\(/g, "resolveFrom(PLACE, ")
+                    .replaceAll(BY_NAME, "importFrom(PLACE, ")
+                    .replaceAll(LITERAL, (call, quote, specifier) => isExternal(specifier) ? `importFrom(PLACE, ${quote}${specifier}${quote})` : call)
+                    .replaceAll(/import\.meta\.url\b/g, "PLACE")
+                    .replaceAll(/\bPLACE\b/g, place);
+                return { contents: `import { importFrom, resolveFrom } from "${FROM}";\n${contents}`, loader: "js" };
+            });
+        },
+    };
+};
+const isCommonJs = (file) => {
+    if (file.endsWith(".cjs"))
+        return true;
+    if (!file.endsWith(".js"))
+        return false;
+    for (let directory = dirname(file); directory !== dirname(directory); directory = dirname(directory)) {
+        const manifest = join(directory, "package.json");
+        if (existsSync(manifest))
+            return JSON.parse(readFileSync(manifest, "utf8")).type !== "module";
+    }
+    return true;
+};
+/**
+ * `await import("yaml")` gets CommonJS's named exports from Node, but only `default` from a bundled chunk. A dynamic
+ * import of CommonJS goes through a module that exports the names Node itself finds in it.
+ */
+const commonJsNames = {
+    name: "common-js-names",
+    setup(context) {
+        context.onResolve({ filter: /.*/ }, async (args) => {
+            if (args.kind !== "dynamic-import" || args.pluginData === "inner")
+                return undefined;
+            const resolved = await context.resolve(args.path, {
+                kind: "dynamic-import",
+                importer: args.importer,
+                resolveDir: args.resolveDir,
+                pluginData: "inner",
+            });
+            if (resolved.errors.length > 0 || resolved.external || !isCommonJs(resolved.path))
+                return undefined;
+            return { path: resolved.path, namespace: "common-js-names" };
+        });
+        context.onLoad({ filter: /.*/, namespace: "common-js-names" }, async (args) => {
+            const names = Object.keys(await import(pathToFileURL(args.path).href)).filter((name) => name !== "default");
+            const values = names.map((name, index) => `const n${index} = cjs[${JSON.stringify(name)}]`);
+            const exported = names.map((name, index) => `n${index} as ${JSON.stringify(name)}`);
+            return {
+                contents: `const cjs = require(${JSON.stringify(args.path)})\n${values.join("\n")}\nexport default cjs\nexport { ${exported.join(", ")} }\n`,
+                resolveDir: dirname(args.path),
+                loader: "js",
+            };
+        });
+    },
+};
+/**
+ * Whether the loader runs a server: `serve`, `watch` or `mcp serve`, or `mcp` alone as before cli-core 0.463. Flags
+ * are skipped, so `<cli> personal --read-only mcp serve` counts; four words leave room for one flag's value. It is
+ * written into the loader as source, so it uses nothing from outside.
+ */
+export const isServer = (words) => {
+    const plain = words.filter((word) => !word.startsWith("-"));
+    return plain
+        .slice(0, 4)
+        .some((word, at) => word === "serve" || word === "watch" || (word === "mcp" && plain[at + 1] === undefined));
+};
+/** The bin that replaces the compiled one: `name` is the bundle's entry, `chunks` what a server preloads. */
+export const loaderSource = (name, version, chunks) => `#!/usr/bin/env node
+${LOADER_MARK}import * as module from "node:module"
+
+const words = process.argv.slice(2)
+// As the CLI answers it, unless a test records the argv: then the CLI writes the record too.
+if (
+  words.length === 1 &&
+  (words[0] === "--version" || words[0] === "-V") &&
+  !Object.keys(process.env).some((key) => key.endsWith("_TEST_ARGV_LOG"))
+) {
+  process.stdout.write(${JSON.stringify(`${version}\n`)})
+} else {
+  // Before the bundle compiles: the bundle's own call comes after its chunks.
+  module.enableCompileCache()
+  const serves = (${isServer.toString()})(words)
+  if (serves && module.registerHooks) {
+    const bundle = new URL("../bundle/", import.meta.url).href
+    module.registerHooks({
+      resolve: (specifier, context, next) =>
+        specifier.startsWith("./") && context.parentURL?.startsWith(bundle)
+          ? { url: new URL(specifier, context.parentURL).href, format: "module", shortCircuit: true }
+          : next(specifier, context),
+    })
+  }
+  const running = import(${JSON.stringify(`../bundle/${name}.js`)})
+  const chunks = ${JSON.stringify(chunks)}
+  // After the server answers its first request, so it starts no later.
+  if (serves) setTimeout(() => void Promise.allSettled(chunks.map((chunk) => import(chunk))), 2000).unref()
+  await running
+}
+`;
+export const bundle = async (options) => {
+    const { build } = await import("esbuild");
+    const root = options.root;
+    const dist = join(root, "dist");
+    const out = join(dist, "bundle");
+    const bin = join(root, options.bin);
+    const name = basename(bin).replace(/\.[cm]?js$/, "");
+    const external = [...DEFAULT_EXTERNAL, ...(options.external ?? [])];
+    const isExternal = matcher(external);
+    const problems = [];
+    if (!bin.startsWith(dist + sep))
+        return { problems: [`${options.bin} is not under dist/`], chunks: [] };
+    if (readFileSync(bin, "utf8").includes(LOADER_MARK))
+        return { problems: [`${options.bin} is already the loader — compile it again (tsc) first`], chunks: [] };
+    const { version } = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+    rmSync(out, { recursive: true, force: true });
+    const { metafile } = await build({
+        absWorkingDir: root,
+        entryPoints: { [name]: bin },
+        outdir: out,
+        bundle: true,
+        splitting: true,
+        format: "esm",
+        platform: "node",
+        target: "node22",
+        chunkNames: "[name]-[hash]",
+        // Two modules with one name would otherwise become `name2`, and `name` reaches errors and `commands --json`.
+        keepNames: true,
+        external,
+        // Bundled CommonJS calls `require` for Node's own modules.
+        banner: {
+            js: 'import { createRequire as __bundleRequire } from "node:module";\nconst require = __bundleRequire(import.meta.url);',
+        },
+        plugins: [
+            commonJsNames,
+            ownPlaces(dist, out, [...DEFAULT_ANCHORED, ...(options.anchored ?? [])], [...DEFAULT_HARMLESS, ...(options.harmless ?? [])], isExternal, problems),
+        ],
+        metafile: true,
+        logLevel: "silent",
+    });
+    // Only the CLI's own modules may import a package that stays outside: it resolves from the bundle, the CLI's place.
+    const own = `${posix(relative(root, dist))}/`;
+    for (const [input, { imports }] of Object.entries(metafile.inputs)) {
+        if (input.startsWith(own))
+            continue;
+        for (const { path, external: outside } of imports) {
+            if (outside && !isBuiltin(path) && !["bun:sqlite", "<runtime>"].includes(path))
+                problems.push(`${input} imports ${path}, which would resolve from the bundle`);
+        }
+    }
+    if (problems.length > 0)
+        return { problems, chunks: [] };
+    // An upgrade replaces the chunks under a running server, and their names carry a hash: a server that had not yet
+    // loaded one would fail to find it. A server loads them all soon after it starts, and finds a chunk it holds without
+    // looking on disk, where Node's resolver would look again for each new importer.
+    const lazy = new Set();
+    for (const { imports } of Object.values(metafile.outputs)) {
+        for (const { path, kind, external: outside } of imports) {
+            if (kind === "dynamic-import" && !outside)
+                lazy.add(`../bundle/${basename(path)}`);
+        }
+    }
+    const chunks = [...lazy].sort();
+    const missing = chunks.filter((chunk) => !existsSync(join(out, basename(chunk))));
+    if (missing.length > 0)
+        return { problems: missing.map((chunk) => `the loader names ${chunk}, not built`), chunks };
+    writeFileSync(bin, loaderSource(name, version, chunks));
+    return { problems: [], chunks };
+};

package/dist/dev/main.js

@@ -66,7 +66,15 @@ const USAGE = `usage: cli-dev <command> [options]
                                        rules by its own lint/ folder; the rest by --baseline
                                        (audit/baseline). --groups replaces PARITY_GROUPS with the
                                        JSON list of parity groups in that file; --differences adds
-                                       to the groups in use`;
+                                       to the groups in use
+  bundle --bin <dist/bin/name.js> [--external <package>]... [--anchor <package>]... [--harmless <path>]...
+                                       bundles the compiled bin with esbuild (a devDependency) into
+                                       dist/bundle/ and turns the bin into its loader. --external keeps
+                                       a package outside (* matches anything); --anchor adds a package
+                                       whose modules keep their installed place, as cli-core's do;
+                                       --harmless names a third-party file whose import.meta or
+                                       __dirname was read and found harmless. Fails when a bundled
+                                       module would look for a file or package in the wrong place`;
 const load = async (cwd, path) => (await import(pathToFileURL(isAbsolute(path) ? path : join(cwd, path)).href));
 const report = (io, problems, ok) => {
     for (const problem of problems)
@@ -604,6 +612,43 @@ const auditRun = (args, io) => {
         io.err(problem);
     return problems.length > 0 ? 1 : 0;
 };
+const bundleCommand = async (args, io) => {
+    const { values } = parseArgs({
+        args,
+        options: {
+            bin: { type: "string" },
+            external: { type: "string", multiple: true },
+            anchor: { type: "string", multiple: true },
+            harmless: { type: "string", multiple: true },
+        },
+    });
+    if (!values.bin) {
+        io.err("bundle needs --bin <dist/bin/name.js>");
+        return 2;
+    }
+    // esbuild is an optional peer: the other commands, and a CLI that does not bundle, never load it.
+    try {
+        await import("esbuild");
+    }
+    catch {
+        io.err("cli-dev bundle needs esbuild: add it as a devDependency, in cli-base's peer range");
+        return 1;
+    }
+    const { bundle } = await import("./bundle.js");
+    const result = await bundle({
+        root: io.cwd,
+        bin: values.bin,
+        external: values.external ?? [],
+        anchored: values.anchor ?? [],
+        harmless: values.harmless ?? [],
+    });
+    if (result.problems.length > 0) {
+        io.err(`the bundle would look for these in the wrong place, or is incomplete:\n${result.problems.join("\n")}`);
+        return 1;
+    }
+    io.out(`bundle: ${values.bin} loads dist/bundle/; a server preloads ${result.chunks.length} chunks`);
+    return 0;
+};
 export const main = async (argv, io) => {
     const [command, ...args] = argv;
     if (args.includes("--help")) {
@@ -649,6 +694,8 @@ export const main = async (argv, io) => {
             return lint(args, io);
         case "audit":
             return audit(args, io);
+        case "bundle":
+            return bundleCommand(args, io);
         case "help":
         case "--help":
         case "-h":

package/dist/skill/index.d.ts

@@ -11,7 +11,7 @@ export interface SkillApp {
 }
 export declare const SKILL_TARGETS: readonly ["claude", "agents"];
 export type SkillTarget = (typeof SKILL_TARGETS)[number];
-/** `~/.claude/skills` is Claude Code's; `~/.agents/skills` is read by Codex and Gemini CLI. */
+/** `~/.claude/skills` is Claude Code's; `~/.agents/skills` is read by Codex, Gemini CLI and OpenClaw. */
 export declare const skillPath: (target: SkillTarget, appName: string, env: Env) => string;
 /**
  * `metadata.version` from the frontmatter — where the Agent Skills specification keeps fields of its

package/dist/skill/index.js

@@ -16,7 +16,7 @@ import { executableEnvironment, executableOnPath } from "../executable.js";
 import { CHECK_EVERY_MS, isNewer, readNoticeState, writeUpdateState } from "../update/index.js";
 export const SKILL_TARGETS = ["claude", "agents"];
 const homeOf = (env) => env.HOME || env.USERPROFILE || homedir();
-/** `~/.claude/skills` is Claude Code's; `~/.agents/skills` is read by Codex and Gemini CLI. */
+/** `~/.claude/skills` is Claude Code's; `~/.agents/skills` is read by Codex, Gemini CLI and OpenClaw. */
 export const skillPath = (target, appName, env) => join(homeOf(env), target === "claude" ? ".claude" : ".agents", "skills", appName, "SKILL.md");
 const FRONTMATTER = /^---(\r?\n)([\s\S]*?\r?\n)?---(\r?\n|$)/;
 const scalar = (key, indent) => new RegExp(`^${indent}${key}:[ \\t]*["']?([^"'\\r\\n]*?)["']?[ \\t]*\\r?\\n?$`);
@@ -234,7 +234,7 @@ export const skillCommand = (app, skill, environment, more = {}) => {
     const named = Object.keys(more);
     const show = annotate(command.command("show"), { effects: { remote: "none", local: "read" } })
         .summary("print the tool's instructions for AI agents")
-        .description(`print SKILL.md — \`${app.command} skill install\` puts it where Claude Code, Codex and Gemini CLI look for it; --for prints the copy already there`);
+        .description(`print SKILL.md — \`${app.command} skill install\` puts it where Claude Code, Codex, Gemini CLI and OpenClaw look for it, and where Hermes does on request; --for prints the copy already there`);
     if (named.length > 0)
         show.argument("[name]", `one of the skills shipped for a task: ${named.join(", ")}`);
     show.addOption(new Option("--for <agents>", "print the copy installed for these agents instead of this version's").choices(SKILL_TARGETS));

package/dist/standards/audit.js

@@ -68,6 +68,14 @@ export const PARITY_GROUPS = defineParityGroups([
         covers: ["commands", "doctor", "skill", "mcp", "upgrade", "search", "notes", "meetings"],
         differences: [],
     },
+    // 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".
+    {
+        name: "gcal-shared",
+        members: ["tg", "max", "memo", "drive", "zm", "wa", "gcal"],
+        covers: ["commands", "upgrade", "notes", "meetings"],
+        differences: [],
+    },
 ]);
 const requiredRootSchema = v.strictObject({ path: v.pipe(v.array(segment), v.minLength(1)), meaning: text });
 export const defineRequiredRoots = (input) => parseRegistry("required roots", v.array(requiredRootSchema), input, (roots) => duplicates(roots.map((root) => root.path.join(" "))).map((path) => `"${path}" is listed twice`));

package/dist/standards/flags-calendar.d.ts

@@ -0,0 +1,2 @@
+import type { VocabularyFlag } from "./vocabulary.js";
+export declare const CALENDAR_FLAGS: VocabularyFlag[];

package/dist/standards/flags-calendar.js

@@ -0,0 +1,72 @@
+export const CALENDAR_FLAGS = [
+    { name: "--end-time", value: "<time>", role: "value", type: "time", meaning: "when it ends" },
+    {
+        name: "--start-date",
+        value: "<date>",
+        role: "value",
+        type: "time",
+        meaning: "the first day of something that lasts whole days, such as an all-day event",
+    },
+    {
+        name: "--end-date",
+        value: "<date>",
+        role: "value",
+        type: "time",
+        meaning: "the last day of something that lasts whole days, such as an all-day event",
+    },
+    { name: "--location", value: "<text>", role: "value", type: "string", meaning: "where it takes place" },
+    {
+        name: "--attendee",
+        value: "<email>",
+        role: "value",
+        type: "string",
+        meaning: "a person invited to the event, by email address; repeat it for more",
+    },
+    {
+        name: "--id",
+        value: "<id>",
+        role: "value",
+        type: "id",
+        meaning: "the id to create it with, chosen beforehand, so a retry finds it instead of making a second one",
+    },
+    {
+        name: "--calendar",
+        value: "<id>",
+        role: "target",
+        type: "id",
+        meaning: "the calendar it acts on, when the thing is on more than one",
+    },
+    {
+        name: "--repeat",
+        value: "<rule>",
+        role: "value",
+        type: "string",
+        meaning: "how it repeats, as an RFC 5545 rule such as FREQ=WEEKLY;BYDAY=MO;COUNT=10",
+    },
+    {
+        name: "--hours",
+        value: "<from-to>",
+        role: "target",
+        type: "string",
+        meaning: "the working hours of each day to look in, such as 09:00-17:00, in the owner's time zone",
+    },
+    {
+        name: "--series",
+        role: "target",
+        type: "switch",
+        meaning: "act on the whole repeating event, not only this occurrence",
+    },
+    {
+        name: "--following",
+        role: "target",
+        type: "switch",
+        meaning: "act on this occurrence and every later one of the repeating event",
+    },
+    {
+        name: "--to-calendar",
+        value: "<id>",
+        role: "target",
+        type: "id",
+        meaning: "the calendar it moves to, of the same account",
+    },
+];

package/dist/standards/flags-how.js

@@ -308,7 +308,13 @@ export const HOW_FLAGS = [
         meaning: "do not keep this run, whatever the configuration says",
     },
     { name: "--no-registries", role: "mode", type: "switch", meaning: "do not ask the public ban lists" },
-    { name: "--notify", role: "mode", type: "switch", meaning: "tell the chat's members about it" },
+    {
+        name: "--notify",
+        role: "mode",
+        type: "switch",
+        meaning: "tell the people it concerns about it: the chat's members, or an event's attendees",
+    },
+    { name: "--no-notify", role: "mode", type: "switch", meaning: "tell nobody about it" },
     { name: "--offline", role: "mode", type: "switch", meaning: "answer from what was recorded and never connect" },
     {
         name: "--operation-id",

package/dist/standards/flags-what.js

@@ -187,6 +187,13 @@ export const WHAT_FLAGS = [
         type: "string",
         meaning: "the profile to use, instead of the first word",
     },
+    {
+        name: "--profiles",
+        value: "<names|all>",
+        role: "scope",
+        type: "list",
+        meaning: "the profiles an MCP server serves, comma-separated, or all of them",
+    },
     {
         name: "--history-since-time",
         value: "<time>",

package/dist/standards/vocabulary.js

@@ -1,4 +1,5 @@
 import * as v from "valibot";
+import { CALENDAR_FLAGS } from "./flags-calendar.js";
 import { HOW_FLAGS } from "./flags-how.js";
 import { WHAT_FLAGS } from "./flags-what.js";
 import { duplicates, parseRegistry, text, word } from "./registry.js";
@@ -114,7 +115,9 @@ const verbs = [
     ["start", "start a running process, or a login session"],
     ["stop", "stop a running process"],
     ["restart", "stop and start a running process"],
+    ["serve", "run a server in this process and answer its clients until stopped"],
     ["end", "end a login session"],
+    ["revoke", "take back what was granted, so it stops working: a login, an invite link, a consent"],
     ["install", "install a system unit"],
     ["uninstall", "remove a system unit"],
     ["cancel", "stop a job or a pending thing"],
@@ -123,6 +126,7 @@ const verbs = [
         "bring the local store up to date from the source: only what changed, or the whole list where the source cannot say; a mirror syncs both ways",
     ],
     ["fetch", "one bounded pull of one named thing into the store, not a catch-up"],
+    ["unsync", "stop syncing a thing; what the store already holds stays"],
     ["export", "write from the store to a file"],
     ["import", "bring a file or list the user gives into the store or the messenger, once"],
     ["download", "save a file from the source to this machine"],
@@ -153,6 +157,7 @@ const verbs = [
     ["unstar", "take the owner's star off a message"],
     ["vote", "answer a poll"],
     ["answer", "reply to a button someone pressed under a bot's message"],
+    ["respond", "answer an invitation: accept, tentatively accept or decline it"],
     ["press", "press a button under a bot's message; the bot sees who pressed it"],
     ["action", "show what a bot is doing in a chat, such as typing, for a few seconds"],
     ["watch", "follow new events as they come, and keep them"],
@@ -175,7 +180,9 @@ const verbs = [
     ["acknowledge", "record successful delivery using the exact receipt issued when the item was claimed"],
     ["confirm", "the owner accepts what an agent proposed"],
     ["reject", "the owner refuses what an agent proposed"],
-    ["move", "move a file in the source"],
+    ["review", "list what waits for the owner's decision"],
+    ["resolve", "settle one thing that waits for the owner's decision, with the owner's choice"],
+    ["move", "move a thing to another place in the source: a file to a folder, an event to a calendar"],
     ["copy", "copy a file in the source"],
     ["run", "run a saved job once, now, as its timer would"],
     ["claim", "take a thing for a while so no other agent works it at once; the claim lapses by itself"],
@@ -241,6 +248,9 @@ const collections = [
     ["files", "files in the source, such as Google Drive, read and changed there"],
     ["comments", "comments people left on a thing in the source: a channel post or a file"],
     ["meetings", "stored meetings, from Zoom or another provider"],
+    ["calendars", "calendars of an account, each synced or not"],
+    ["events", "calendar entries: meetings, appointments and other things on a calendar"],
+    ["people", "persons the owner deals with, such as the attendees of events"],
     ["recordings", "the files a provider recorded of a meeting"],
     ["jobs", "work this tool runs in the background or on a timer"],
     ["actions", "what an agent proposes to do; the owner confirms or rejects each"],
@@ -302,6 +312,7 @@ const views = [
     ["evidence", "the stored messages or lines a result or a reference rests on"],
     ["passage", "a cited transcript line with bounded surrounding lines from the same revision"],
     ["agenda", "what needs a look today"],
+    ["busy", "when calendars or people are taken, without what takes them"],
     ["categories", "the categories a thing takes, with what each means"],
     ["domains", "the internet domains links point to, most linked first"],
     ["places", "the street addresses confirmed as places, most mentioned first"],
@@ -348,5 +359,5 @@ export const VOCABULARY = defineVocabulary({
     ],
     views: views.map(([entry, meaning]) => ({ word: entry, meaning })),
     roots: roots.map(([entry, meaning]) => ({ word: entry, meaning })),
-    flags: [...HOW_FLAGS, ...WHAT_FLAGS],
+    flags: [...HOW_FLAGS, ...WHAT_FLAGS, ...CALENDAR_FLAGS],
 });

package/docs/standards/README.md

@@ -28,14 +28,14 @@ the four steps that need a person. A new CLI is ready for its first release when
 | Page | Area id | Rules | What it covers |
 |---|---|---:|---|
 | [Toolchain](toolchain.md) | `TOOL` | 20 | TypeScript, Biome, grit plugins, size caps, import cycles, spelling, Markdown, Go |
-| [Layout](layout.md) | `LAY` | 9 | Repository layout, entry points, exports, file size, one job per file, splitting a unit |
+| [Layout](layout.md) | `LAY` | 10 | Repository layout, entry points, exports, file size, one job per file, splitting a unit, the bundled bin |
 | [Commands](commands.md) | `CMD` | 28 | Paths, vocabulary, flags, arguments, effects, lifetime, query, help, external references |
 | [Output](output.md) | `OUT` | 23 | Data on stdout only, envelopes, errors, exit codes, partial answers, projection |
 | [MCP](mcp.md) | `MCP` | 13 | The MCP tools, how they come from commands, what each permission shows |
-| [Accounts](accounts.md) | `ACCT` | 11 | The explicit profile, reads across accounts, scope flags, linked identities |
-| [Permissions](permissions.md) | `PERM` | 21 | Levels, keys, defaults, hard limits, the write guard and its journal |
+| [Accounts](accounts.md) | `ACCT` | 12 | The explicit profile, reads across accounts, scope flags, linked identities, sign-in commands |
+| [Permissions](permissions.md) | `PERM` | 22 | Levels, keys, defaults, hard limits, the write guard and its journal |
 | [Architecture](architecture.md) | `ARCH` | 17 | Layers, dependency direction, vendor types, what goes in which package |
-| [Lifecycle](lifecycle.md) | `LIFE` | 14 | Opening late, who closes, one-shot exits, long-running commands, the `serve` relay, resumable syncs, the run log |
+| [Lifecycle](lifecycle.md) | `LIFE` | 15 | Opening late, who closes, deadlines, long-running commands, the `serve` relay, resumable syncs and their request budget, the run log |
 | [Store](store.md) | `STORE` | 14 | Store areas, account scope, migrations, test isolation |
 | [Data model](data-model.md) | `DATA` | 9 | Core entities, entities and source records, `external_id`, field names, links and duplicates, files, calendar entries |
 | [Testing](testing.md) | `TEST` | 17 | Sandbox, no network, no real waits, leak tests, coverage, contracts, test matrix, parity |
@@ -84,7 +84,7 @@ Every rule has the same shape. A rule may add a sentence or a short list under i
     CLI's `node_modules`;
   - a check in another repository, as `<repo>: <check>`, such as `cli-core: pnpm parity:check` or
     `cli-core: biome noRestrictedImports`. `<repo>` is the repository's name on GitHub: `cli-core`, `cli-testing`,
-    `cli-docs`, `community`, `tg-cli`, `max-cli`, `cli-memo`, `drive-cli`, `zoom-cli` or `whatsapp-cli`. `<app>`
+    `cli-docs`, `community`, `tg-cli`, `max-cli`, `cli-memo`, `drive-cli`, `zoom-cli`, `whatsapp-cli` or `gcal-cli`. `<app>`
     stands for each CLI the rule applies to, when every one of them runs that check in its own repository.
 - **Since** is the cli-base release whose handbook first carried the rule. A feature can be older than its rule.