@wirecat/mail-cli 0.0.0-stage → 0.1.0

package/dist/bundle/chunk-3KOA73LS.js

@@ -0,0 +1,3416 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  UNTRUSTED,
+  UNTRUSTED_NEUTRAL,
+  agentArguments,
+  agentJson,
+  commandAvailability
+} from "./chunk-K4FVKPDQ.js";
+import {
+  failureContext
+} from "./chunk-JVMVLITS.js";
+import {
+  callerOf
+} from "./chunk-VEIZZRQ5.js";
+import {
+  lentConnection,
+  onlineDeps,
+  refuseLacking,
+  servicesFor,
+  storeModeDeps
+} from "./chunk-T6464KYA.js";
+import {
+  MAX_BUFFERED_INPUT
+} from "./chunk-CH6RXYAX.js";
+import {
+  ENTITIES
+} from "./chunk-TVREDYX4.js";
+import {
+  DEFAULT_OUTPUT_BYTES,
+  LOCAL_WRITE,
+  REMOTE_WRITE,
+  answerSchema,
+  changesMessenger,
+  enclosingTraceId,
+  flatten,
+  inRun,
+  judgedAnswer,
+  judgedEffects,
+  listOf,
+  newRunId,
+  refuseStoreChange,
+  sealed,
+  startRecording,
+  traceOf
+} from "./chunk-GQQJOH7A.js";
+import {
+  authorityAllowed,
+  botApiAllowed,
+  keyForCommand,
+  levelFor,
+  readKeysForCommand
+} from "./chunk-QLEUNU6G.js";
+import {
+  currentCaller,
+  keepsSuccess,
+  runContextOf,
+  withCaller
+} from "./chunk-7SXGLT6T.js";
+import {
+  captureStreams,
+  traceIdOf
+} from "./chunk-J3QXTBD2.js";
+import {
+  SNAKE_CASE,
+  array,
+  boolean,
+  description,
+  duplicates,
+  errorObjectOf,
+  integer,
+  isoDate,
+  itemEnvelopeSchema,
+  listEnvelopeSchema,
+  literal,
+  looseObject,
+  maxLength,
+  maxValue,
+  mcpErrorResult,
+  minLength,
+  minValue,
+  number,
+  object,
+  optional,
+  parseRegistry,
+  picklist,
+  pipe,
+  record,
+  regex,
+  safeParse,
+  strictObject,
+  string,
+  summarize,
+  text,
+  toJsonSchema,
+  toStandardJsonSchema,
+  union,
+  unknown,
+  word,
+  writes
+} from "./chunk-LQ37ALDJ.js";
+import {
+  CliError,
+  errorCodes
+} from "./chunk-5BVIWP3S.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/mcp/agent.js
+import { Readable } from "node:stream";
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/standards/lint.js
+var LINT_SEVERITIES = ["high", "medium", "low"];
+var lintRuleSchema = strictObject({
+  id: word,
+  severity: picklist(LINT_SEVERITIES),
+  /** What the rule looks at; a violation's target names one of these. */
+  scope: picklist(["command", "group", "argument", "option", "flag", "key"]),
+  summary: text
+});
+var defineLintRules = /* @__PURE__ */ __name((input) => parseRegistry("lint rules", array(lintRuleSchema), input, (rules) => duplicates(rules.map((rule) => rule.id)).map((id) => `"${id}" is listed twice`)), "defineLintRules");
+var LINT_RULES = defineLintRules([
+  {
+    id: "unknown-verb",
+    severity: "high",
+    scope: "command",
+    summary: "a command's last word is a verb or view noun from the vocabulary; a top-level one may be a root word; under search, a resource or all"
+  },
+  {
+    id: "unknown-resource",
+    severity: "medium",
+    scope: "group",
+    summary: "a group is a resource from the vocabulary (plural, or a registered singular) or a root word"
+  },
+  {
+    id: "flag-two-meanings",
+    severity: "high",
+    scope: "flag",
+    summary: "a flag takes the same kind of value in every command, and the one the vocabulary gives it"
+  },
+  { id: "missing-command-help", severity: "high", scope: "command", summary: "every command has a summary" },
+  {
+    id: "missing-command-effects",
+    severity: "high",
+    scope: "command",
+    summary: "every command that runs declares its effects: each leaf, and a group with an action of its own"
+  },
+  {
+    id: "command-help-too-long",
+    severity: "low",
+    scope: "command",
+    summary: "a summary is at most 80 characters"
+  },
+  {
+    id: "command-example-count",
+    severity: "medium",
+    scope: "command",
+    summary: "a leaf command has one to three examples; generated commands are exempt"
+  },
+  {
+    id: "faulty-help-example-parameters",
+    severity: "high",
+    scope: "command",
+    summary: "an example starts with the tool, runs its own command, and gives only arguments and options it takes"
+  },
+  { id: "missing-argument-help", severity: "high", scope: "argument", summary: "every argument is described" },
+  { id: "missing-option-help", severity: "high", scope: "option", summary: "every option is described" },
+  {
+    id: "key-casing",
+    severity: "high",
+    scope: "key",
+    summary: "every key of a registered JSON Schema and of the commands document is snake_case"
+  },
+  {
+    id: "filter-flag",
+    severity: "high",
+    scope: "option",
+    summary: "a command that changes nothing filters with its query, not with a flag named after a field of its entity"
+  },
+  {
+    id: "option-role",
+    severity: "high",
+    scope: "option",
+    summary: "every option has a role in the vocabulary; a filter has none, it is a query field"
+  },
+  {
+    id: "list-without-query",
+    severity: "medium",
+    scope: "command",
+    summary: "a list that answers with an entity takes a query over that entity's fields"
+  },
+  {
+    id: "query-example",
+    severity: "high",
+    scope: "command",
+    summary: "every query field's example, and every default term, parses and validates"
+  },
+  {
+    id: "nullable-list",
+    severity: "medium",
+    scope: "key",
+    summary: "a list in a registered JSON Schema is never null: known empty is `[]`, not known is absent"
+  },
+  {
+    id: "flag-synonym",
+    severity: "medium",
+    scope: "option",
+    summary: "an option is not another name for a vocabulary flag: `--max` and `--take` are `--limit`"
+  },
+  {
+    id: "identifier-name",
+    severity: "high",
+    scope: "key",
+    summary: "an identifier key is one from the glossary: `run_id`, never `execution_id` or `log_id`"
+  },
+  {
+    id: "log-attribute-key",
+    severity: "high",
+    scope: "key",
+    summary: "no log attribute key on the allow-list names message text, a token or a phone number"
+  },
+  {
+    id: "missing-run-log",
+    severity: "high",
+    scope: "group",
+    summary: "the CLI keeps a failed run and reads it back: `runs list`, `runs show`, global `--record` and `--no-record`"
+  }
+]);
+var baselineSchema = array(text);
+var overridesSchema = array(strictObject({
+  rule: word,
+  target: text,
+  reason: pipe(text, minLength(10, "say why, in a sentence")),
+  /** A GitHub handle or a team, `@octocat`. */
+  owner: pipe(string(), regex(/^@[\w.-]+(\/[\w.-]+)?$/, "a GitHub handle or team, such as @octocat")),
+  review_after: pipe(string(), isoDate("a date, YYYY-MM-DD"))
+}));
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/standards/audit.js
+var auditRuleSchema = strictObject({ id: word, severity: picklist(LINT_SEVERITIES), summary: text });
+var defineAuditRules = /* @__PURE__ */ __name((input) => parseRegistry("audit rules", array(auditRuleSchema), input, (rules) => duplicates(rules.map((rule) => rule.id)).map((id) => `"${id}" is listed twice`)), "defineAuditRules");
+var 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",
+    summary: "every CLI has the required root commands"
+  },
+  {
+    id: "same-path-contract",
+    severity: "high",
+    summary: "a command path two CLIs of a parity group share has the same options, value names, output and summary; a group that covers the whole tree has the same paths"
+  },
+  {
+    id: "same-flag-meaning",
+    severity: "high",
+    summary: "a flag takes the same kind of value in every CLI"
+  },
+  {
+    id: "same-entity-schema",
+    severity: "high",
+    summary: "an output entity two CLIs print has one JSON Schema"
+  },
+  {
+    id: "same-error-reason",
+    severity: "medium",
+    summary: "an error reason is not a shared reason under another name, and one reason id has one code"
+  }
+]);
+var segment = pipe(string(), regex(/^[a-z][a-z0-9-]*$/, "a command word"));
+var parityGroupSchema = strictObject({
+  name: word,
+  /** CLI names as `commands --json` prints them in `cli`. */
+  members: pipe(array(word), minLength(2)),
+  /** `tree` compares every path; otherwise the root words whose paths are compared. */
+  covers: union([literal("tree"), pipe(array(segment), minLength(1))]),
+  /** Permanent differences, each with its reason; they count against the override budget of the group. */
+  differences: array(strictObject({
+    rule: word,
+    /** `<clis> <path> <flag>`; with `absent`, only `<path> <flag>`: the CLI list is whoever else has it. */
+    target: text,
+    expected: 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: optional(word),
+    reason: pipe(text, minLength(10, "say why, in a sentence"))
+  }))
+});
+var defineParityGroups = /* @__PURE__ */ __name((input) => parseRegistry("parity groups", 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`),
+    ...group.differences.filter((entry) => entry.absent && entry.expected).map((entry) => `${group.name}: "${entry.target}" has \`absent\`, which measures the values itself; drop \`expected\``)
+  ])
+]), "defineParityGroups");
+var PARITY_GROUPS = defineParityGroups([
+  { name: "messengers", members: ["tg", "max"], covers: "tree", differences: [] },
+  {
+    name: "all",
+    members: ["tg", "max", "memo", "drive", "zm", "wa", "mail"],
+    covers: ["commands", "doctor", "skill", "mcp", "upgrade", "search", "notes", "meetings"],
+    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".
+  {
+    name: "gcal-shared",
+    members: ["tg", "max", "memo", "drive", "zm", "wa", "gcal"],
+    covers: ["commands", "upgrade", "notes", "meetings"],
+    differences: []
+  }
+]);
+var requiredRootSchema = strictObject({ path: pipe(array(segment), minLength(1)), meaning: text });
+var defineRequiredRoots = /* @__PURE__ */ __name((input) => parseRegistry("required roots", array(requiredRootSchema), input, (roots2) => duplicates(roots2.map((root) => root.path.join(" "))).map((path) => `"${path}" is listed twice`)), "defineRequiredRoots");
+var REQUIRED_ROOTS = defineRequiredRoots([
+  { path: ["commands"], meaning: "the command tree as JSON, what agents and this audit read" },
+  { path: ["doctor"], meaning: "checks this machine and the profile, and says what to fix" },
+  { path: ["skill", "show"], meaning: "prints the agent skill" },
+  { path: ["skill", "install"], meaning: "installs the agent skill" },
+  { path: ["mcp"], meaning: "the MCP server" },
+  { path: ["upgrade"], meaning: "updates the CLI" }
+]);
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/standards/fields.js
+var fieldRuleSchema = strictObject({ id: word, rule: text });
+var defineFieldRules = /* @__PURE__ */ __name((input) => parseRegistry("output field rules", array(fieldRuleSchema), input, (rules) => duplicates(rules.map((rule) => rule.id)).map((id) => `"${id}" is listed twice`)), "defineFieldRules");
+var FIELD_RULES = defineFieldRules([
+  { id: "envelope", rule: "every JSON answer is one object: a list `{items, page, \u2026}`, one thing `{item, \u2026}`" },
+  { id: "time", rule: "a time is an ISO 8601 string in UTC, ending in `Z`, never epoch milliseconds" },
+  { id: "duration", rule: "a length of time is a number of milliseconds in a key ending in `_ms`" },
+  { id: "ref", rule: "a stored thing is named by `ref`; a message's `ref` value is its locator" },
+  { id: "snake-case", rule: "keys are snake_case words, no abbreviations a reader has to decode" },
+  { id: "one-meaning", rule: "a key has one meaning and one type in every answer of every CLI" },
+  {
+    id: "absent-null",
+    rule: "absent: not asked for or not known; `null`: known to have no value; `[]`: known to be empty, never `null`; `0`: measured, never a stand-in for unknown"
+  }
+]);
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/standards/identifiers.js
+var key = pipe(string(), regex(SNAKE_CASE, "a snake_case key"));
+var identifierSchema = strictObject({ key, meaning: text, replaces: optional(array(key)) });
+var defineIdentifiers = /* @__PURE__ */ __name((input) => parseRegistry("identifiers", array(identifierSchema), input, (identifiers) => {
+  const keys = identifiers.map((entry) => entry.key);
+  const replaced = identifiers.flatMap((entry) => entry.replaces ?? []);
+  return [
+    ...duplicates([...keys, ...replaced]).map((name) => `"${name}" is listed twice`),
+    ...replaced.filter((name) => keys.includes(name)).map((name) => `"${name}" is both a key and replaced`)
+  ];
+}), "defineIdentifiers");
+var IDENTIFIERS = defineIdentifiers([
+  {
+    key: "run_id",
+    meaning: "one invocation of a command, what `runs show` opens",
+    replaces: ["execution_id", "invocation_id", "log_id", "diagnostic_id"]
+  },
+  { key: "operation_id", meaning: "one logical write attempt; a retry of it reuses the id", replaces: ["send_id"] },
+  { key: "request_id", meaning: "the provider's own reference for one request, as it sent it" },
+  { key: "trace_id", meaning: "the distributed trace a run belongs to, from `traceparent`" }
+]);
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/standards/flags-calendar.js
+var 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"
+  }
+];
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/standards/flags-how.js
+var HOW_FLAGS = [
+  {
+    name: "--limit",
+    value: "<n>",
+    role: "paging",
+    type: "count",
+    meaning: "how many items",
+    unit: "items",
+    replaces: ["--max", "--count", "--take", "--max-results", "--lines", "--limit-groups"]
+  },
+  {
+    name: "--page",
+    value: "<n>",
+    role: "paging",
+    type: "count",
+    meaning: "which page, from 1, where the source has no cursor"
+  },
+  {
+    name: "--page-size",
+    value: "<n>",
+    role: "paging",
+    type: "count",
+    meaning: "how many items one request to the source asks for",
+    unit: "items"
+  },
+  { name: "--all", role: "paging", type: "switch", meaning: "every item at once, instead of one page or one target" },
+  {
+    name: "--cursor",
+    value: "<cursor>",
+    role: "paging",
+    type: "cursor",
+    meaning: "continue from where the previous page ended",
+    replaces: ["--offset"]
+  },
+  { name: "--before-id", value: "<id>", role: "paging", type: "id", meaning: "read what came before this message id" },
+  { name: "--after-id", value: "<id>", role: "paging", type: "id", meaning: "read what came after this message id" },
+  {
+    name: "--chunk-bytes",
+    value: "<n>",
+    role: "paging",
+    type: "count",
+    meaning: "how many bytes one chunk returns",
+    unit: "bytes"
+  },
+  {
+    name: "--offset-bytes",
+    value: "<n>",
+    role: "paging",
+    type: "count",
+    meaning: "where the chunk starts, in bytes from 0",
+    unit: "bytes"
+  },
+  {
+    name: "--before-n",
+    value: "<n>",
+    role: "output",
+    type: "count",
+    meaning: "how many messages or transcript lines before it",
+    unit: "items"
+  },
+  {
+    name: "--after-n",
+    value: "<n>",
+    role: "output",
+    type: "count",
+    meaning: "how many messages or transcript lines after it",
+    unit: "items"
+  },
+  {
+    name: "--debug",
+    role: "output",
+    type: "switch",
+    meaning: "on failure, show the full error record: cause and stack"
+  },
+  {
+    name: "--agent-json",
+    role: "output",
+    type: "switch",
+    meaning: "JSON with control and direction characters made visible in strings and keys"
+  },
+  {
+    name: "--brief",
+    role: "output",
+    type: "switch",
+    meaning: "each item as its reference, title, time and excerpt only"
+  },
+  {
+    name: "--chart-kind",
+    value: "<messages|active|membership>",
+    role: "output",
+    type: "choice",
+    meaning: "what a chart draws"
+  },
+  {
+    name: "--checkpoints",
+    value: "<durations>",
+    role: "output",
+    type: "list",
+    meaning: "the ages to report on, comma-separated: 1d,7d,30d"
+  },
+  {
+    name: "--fields",
+    value: "<paths>",
+    role: "output",
+    type: "list",
+    meaning: "only these comma-separated fields of each item; list metadata stays"
+  },
+  { name: "--format", value: "<format>", role: "output", type: "choice", meaning: "the format of the file written" },
+  { name: "--full", role: "output", type: "switch", meaning: "each item with its whole text and every field" },
+  {
+    name: "--json",
+    role: "output",
+    type: "switch",
+    meaning: "machine-readable output: one JSON value on stdout, nothing else"
+  },
+  { name: "--jsonl", role: "output", type: "switch", meaning: "machine-readable output: one JSON object per line" },
+  {
+    name: "--output",
+    value: "<file>",
+    role: "output",
+    type: "path",
+    meaning: "the file to write",
+    replaces: ["--out"]
+  },
+  {
+    name: "--output-dir",
+    value: "<dir>",
+    role: "output",
+    type: "path",
+    meaning: "the folder to write into, created if missing",
+    replaces: ["--destination"]
+  },
+  {
+    name: "--problems",
+    role: "output",
+    type: "switch",
+    meaning: "only what went wrong: failures, warnings and crashes"
+  },
+  { name: "--quiet", role: "output", type: "switch", meaning: "no diagnostics on stderr" },
+  { name: "--show-phone", role: "output", type: "switch", meaning: "print the whole phone number" },
+  {
+    name: "--thread-within",
+    value: "<duration>",
+    role: "output",
+    type: "duration",
+    meaning: "messages within this long either side of the hit"
+  },
+  {
+    name: "--trace",
+    role: "output",
+    type: "switch",
+    meaning: "one line per request on stderr: ids and timings, never content"
+  },
+  { name: "--verbose", role: "output", type: "switch", meaning: "more detail in what is shown; repeat for more" },
+  { name: "--version", role: "output", type: "switch", meaning: "print the version number" },
+  { name: "--with-notes", role: "output", type: "switch", meaning: "include the owner's private notes" },
+  {
+    name: "--by",
+    value: "<group>",
+    role: "output",
+    type: "choice",
+    meaning: "what the answer counts or groups by: a field or a calendar unit"
+  },
+  {
+    name: "--context",
+    value: "<n>",
+    role: "output",
+    type: "count",
+    meaning: "how many messages before and after each hit",
+    unit: "messages"
+  },
+  {
+    name: "--events",
+    role: "output",
+    type: "switch",
+    meaning: "also print edits, deletions and other changes; every line names its event"
+  },
+  { name: "--all-versions", role: "output", type: "switch", meaning: "also the earlier versions a newer one replaced" },
+  { name: "--measure", value: "<name>", role: "sort", type: "choice", meaning: "the metric a ranking is ordered by" },
+  { name: "--newest", role: "sort", type: "switch", meaning: "newest first instead of best first" },
+  {
+    name: "--plain-order",
+    role: "sort",
+    type: "switch",
+    meaning: "best first by the words alone, without moving mail from suspicious senders down"
+  },
+  {
+    name: "--order",
+    value: "<recent|name>",
+    role: "sort",
+    type: "choice",
+    meaning: "the order of a list: most recent first, or by name"
+  },
+  { name: "--score", value: "<preset>", role: "sort", type: "choice", meaning: "the named ranking score preset" },
+  {
+    name: "--weights",
+    value: "<json>",
+    role: "sort",
+    type: "string",
+    meaning: "the ranking component weights, all of them"
+  },
+  {
+    name: "--meeting-inventory",
+    role: "mode",
+    type: "switch",
+    meaning: "expose read-only discovery of candidate series in the selected meeting account"
+  },
+  {
+    name: "--meeting-project-candidates",
+    role: "mode",
+    type: "switch",
+    meaning: "expose read-only project suggestions from selected meeting evidence and the global project vocabulary"
+  },
+  {
+    name: "--meeting-preparation",
+    role: "mode",
+    type: "switch",
+    meaning: "expose meeting preparation tools, including their remote schedule reads"
+  },
+  { name: "--dry-run", role: "mode", type: "switch", meaning: "judge and plan; do nothing", replaces: ["--estimate"] },
+  { name: "--accept-terms", role: "mode", type: "switch", meaning: "accept the model's licence terms" },
+  {
+    name: "--as-owner",
+    role: "mode",
+    type: "switch",
+    meaning: "record the action as the owner's although an agent's terminal runs the tool"
+  },
+  {
+    name: "--allow-any-file",
+    role: "mode",
+    type: "switch",
+    meaning: "send a file even from a credential folder or the tool's own folders"
+  },
+  {
+    name: "--allow-dangerous",
+    role: "mode",
+    type: "switch",
+    meaning: "go ahead without the question an ask level puts before a deletion"
+  },
+  {
+    name: "--allow-writes",
+    role: "mode",
+    type: "switch",
+    meaning: "permit writing: offer the profile's writing tools, or let a generic call change the source",
+    replaces: ["--allow-write"]
+  },
+  { name: "--as-file", role: "mode", type: "switch", meaning: "send every file as a plain file to download" },
+  { name: "--background", role: "mode", type: "switch", meaning: "run as a job that outlives this command" },
+  {
+    name: "--base-url",
+    value: "<url>",
+    role: "mode",
+    type: "string",
+    meaning: "the address of an OpenAI-compatible model API"
+  },
+  { name: "--dims", value: "<n>", role: "mode", type: "count", meaning: "the embedding vector size" },
+  {
+    name: "--discover",
+    role: "mode",
+    type: "switch",
+    meaning: "also find partial matches; the results are evidence, not answers"
+  },
+  {
+    name: "--encrypt",
+    role: "mode",
+    type: "switch",
+    meaning: "compress and encrypt with a password that is never kept"
+  },
+  { name: "--exact", role: "mode", type: "switch", meaning: "bare words and quotes match their exact form only" },
+  {
+    name: "--fingerprint",
+    value: "<hash>",
+    role: "mode",
+    type: "string",
+    meaning: "refuse if what it names has changed since it was read",
+    replaces: ["--expected"]
+  },
+  {
+    name: "--for-everyone",
+    role: "mode",
+    type: "switch",
+    meaning: "delete for everyone in the chat, not only for the owner"
+  },
+  { name: "--http", role: "mode", type: "switch", meaning: "serve over HTTP on 127.0.0.1" },
+  { name: "--language", value: "<lucene|legacy>", role: "mode", type: "choice", meaning: "the query language" },
+  { name: "--local", role: "mode", type: "switch", meaning: "use the model on this machine, never the source" },
+  {
+    name: "--max-age",
+    value: "<duration>",
+    role: "mode",
+    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" },
+  { name: "--no-preview", role: "mode", type: "switch", meaning: "no preview card for a link in the text" },
+  {
+    name: "--no-record",
+    role: "mode",
+    type: "switch",
+    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 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",
+    value: "<id>",
+    role: "mode",
+    type: "id",
+    meaning: "the write attempt this repeats, from an unknown outcome; a retry with it cannot write twice",
+    replaces: ["--send-id"]
+  },
+  { name: "--port", value: "<port>", role: "mode", type: "number", meaning: "the local port for --http" },
+  {
+    name: "--public-url",
+    value: "<url>",
+    role: "mode",
+    type: "string",
+    meaning: "the public https address of the tunnel"
+  },
+  {
+    name: "--record",
+    role: "mode",
+    type: "switch",
+    meaning: "keep this run, with the command as typed and secrets hidden; record_input false leaves the typed words out"
+  },
+  { name: "--regex", role: "mode", type: "switch", meaning: "the words are one regular expression" },
+  { name: "--silent", role: "mode", type: "switch", meaning: "deliver without a notification" },
+  { name: "--thread", role: "mode", type: "switch", meaning: "the stored reply chain instead of time neighbours" },
+  {
+    name: "--timezone",
+    value: "<zone>",
+    role: "mode",
+    type: "string",
+    meaning: "the IANA timezone dates and times are read in"
+  },
+  {
+    name: "--yes",
+    role: "mode",
+    type: "switch",
+    meaning: "go ahead with the write without asking or previewing first"
+  },
+  { name: "--allow-delete", role: "mode", type: "switch", meaning: "permit a call that deletes for good" },
+  {
+    name: "--allow-remote",
+    role: "mode",
+    type: "switch",
+    meaning: "consent to sending the stored data to the configured remote model"
+  },
+  {
+    name: "--answerer",
+    value: "<person>",
+    role: "mode",
+    type: "string",
+    meaning: "a person whose reply counts as an answer; repeat it for more"
+  },
+  {
+    name: "--browser",
+    value: "<program>",
+    role: "mode",
+    type: "string",
+    meaning: "the browser program to open for sign-in"
+  },
+  {
+    name: "--credential-storage",
+    value: "<storage>",
+    role: "mode",
+    type: "choice",
+    meaning: "where a sign-in is kept: keyring, which falls back to a private file by itself, or file (WC-SECR-4)"
+  },
+  { name: "--checkpoint", value: "<file>", role: "mode", type: "path", meaning: "keep resume progress in this file" },
+  {
+    name: "--expected-event-id",
+    value: "<id>",
+    role: "mode",
+    type: "id",
+    meaning: "refuse unless the linked event is still this one, or none"
+  },
+  {
+    name: "--expected-person",
+    value: "<uid>",
+    role: "mode",
+    type: "id",
+    meaning: "refuse unless the linked person is still this one, or none"
+  },
+  { name: "--html", role: "mode", type: "switch", meaning: "the text is HTML" },
+  {
+    name: "--idle",
+    value: "<duration>",
+    role: "mode",
+    type: "duration",
+    meaning: "stop after this long with nobody using it"
+  },
+  {
+    name: "--interactive",
+    role: "mode",
+    type: "switch",
+    meaning: "allow approving in a browser from an interactive terminal"
+  },
+  {
+    name: "--meeting-context",
+    role: "mode",
+    type: "switch",
+    meaning: "expose meeting evidence, person context and task proposal tools"
+  },
+  {
+    name: "--method",
+    value: "<method>",
+    role: "mode",
+    type: "choice",
+    meaning: "how to log in when there is no session"
+  },
+  {
+    name: "--model",
+    value: "<model>",
+    role: "mode",
+    type: "string",
+    meaning: "the model that does the work: a local model's id or the provider's model name"
+  },
+  {
+    name: "--models-dir",
+    value: "<dir>",
+    role: "mode",
+    type: "path",
+    meaning: "the folder installed models are read from"
+  },
+  {
+    name: "--no-browser",
+    role: "mode",
+    type: "switch",
+    meaning: "print the sign-in address instead of opening a browser"
+  },
+  { name: "--no-resume", role: "mode", type: "switch", meaning: "start over, keeping no resume state" },
+  {
+    name: "--no-serve",
+    role: "mode",
+    type: "switch",
+    meaning: "do not start the long-running process; use this command's own connection"
+  },
+  {
+    name: "--pause",
+    value: "<duration>",
+    role: "mode",
+    type: "duration",
+    meaning: "wait this long between requests to the source, to stay under its limits",
+    replaces: ["--interval"]
+  },
+  {
+    name: "--permission",
+    value: "<key=level>",
+    role: "mode",
+    type: "string",
+    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",
+    role: "mode",
+    type: "switch",
+    meaning: "list everything again, not only what changed since the last run"
+  },
+  { name: "--resume", role: "mode", type: "switch", meaning: "continue verified partial work from the last run" },
+  {
+    name: "--revision",
+    value: "<n>",
+    role: "mode",
+    type: "count",
+    meaning: "the revision read before this edit; a change made meanwhile refuses it"
+  },
+  {
+    name: "--secret-stdin",
+    role: "mode",
+    type: "switch",
+    meaning: "read a secret from a pipe, or ask for it; never from the command line"
+  },
+  {
+    name: "--semantic",
+    role: "mode",
+    type: "switch",
+    meaning: "expose read-only search by meaning, with an explicit query model"
+  },
+  {
+    name: "--serve",
+    role: "mode",
+    type: "switch",
+    meaning: "start the long-running process in the background when it is not running"
+  },
+  {
+    name: "--size",
+    value: "<n>",
+    role: "mode",
+    type: "count",
+    meaning: "how many messages in one batch",
+    unit: "messages"
+  },
+  {
+    name: "--unified-search",
+    role: "mode",
+    type: "switch",
+    meaning: "expose search across resources for the selected profile"
+  },
+  {
+    name: "--within",
+    value: "<duration>",
+    role: "mode",
+    type: "duration",
+    meaning: "the window after an event that counts"
+  },
+  {
+    name: "--grant",
+    value: "<scopes>",
+    role: "mode",
+    type: "list",
+    meaning: "also ask for these permissions at sign-in, comma-separated; the command lists them"
+  },
+  {
+    name: "--min-similarity",
+    value: "<n>",
+    role: "mode",
+    type: "number",
+    meaning: "how alike two names must be to count as a match, from 0 to 1"
+  },
+  { name: "--analyze", role: "action", type: "switch", meaning: "also analyze with the configured provider" },
+  {
+    name: "--agent",
+    value: "<agent>",
+    role: "action",
+    type: "choice",
+    meaning: "also install the agent skill for this agent after logging in"
+  },
+  {
+    name: "--catch-up",
+    role: "action",
+    type: "switch",
+    meaning: "prepare local search: after this run, or before a search reads it"
+  },
+  { name: "--extract", role: "action", type: "switch", meaning: "also read the text inside the files written" },
+  {
+    name: "--mark-read",
+    role: "action",
+    type: "switch",
+    meaning: "also mark the chat read up to the newest message shown; the other person sees it"
+  },
+  { name: "--no-catch-up", role: "action", type: "switch", meaning: "skip local preparation after this run" },
+  { name: "--retract", role: "action", type: "switch", meaning: "take the owner's vote back" },
+  { name: "--revoke", role: "action", type: "switch", meaning: "forget every login given to a browser app" },
+  { name: "--track", role: "action", type: "switch", meaning: "also do it daily while serve runs" },
+  {
+    name: "--transcribe",
+    role: "action",
+    type: "switch",
+    meaning: "also transcribe voice messages not transcribed yet, on this machine"
+  },
+  { name: "--block", role: "action", type: "switch", meaning: "also keep them from coming back by the chat's link" },
+  {
+    name: "--check",
+    role: "action",
+    type: "switch",
+    meaning: "also ask the source and say what it answers: a newer version, who a bot is, whether a login works"
+  },
+  { name: "--download", role: "action", type: "switch", meaning: "first download the files not downloaded yet" },
+  { name: "--embed", role: "action", type: "switch", meaning: "also embed what is pending, for search by meaning" },
+  {
+    name: "--export",
+    value: "<dir>",
+    role: "action",
+    type: "path",
+    meaning: "also write it as a file, to this folder or the configured one"
+  },
+  { name: "--no-block", role: "action", type: "switch", meaning: "remove without keeping them from coming back" },
+  { name: "--no-embed", role: "action", type: "switch", meaning: "skip embedding for search by meaning this run" },
+  {
+    name: "--no-mark-read",
+    role: "action",
+    type: "switch",
+    meaning: "do not mark read, whatever the configuration says"
+  },
+  {
+    name: "--ocr",
+    role: "action",
+    type: "switch",
+    meaning: "also read the text in images and scanned PDFs with the configured OCR model"
+  },
+  {
+    name: "--online",
+    role: "action",
+    type: "switch",
+    meaning: "also connect once and read the account; sends nothing"
+  },
+  {
+    name: "--sync-first",
+    role: "action",
+    type: "switch",
+    meaning: "first bring what it reads up to date from the source",
+    replaces: ["--refresh", "--refresh-metadata"]
+  },
+  {
+    name: "--domain-age",
+    role: "action",
+    type: "switch",
+    meaning: "also ask each domain's registry when it was registered; the registry learns the domain"
+  },
+  {
+    name: "--retry-attachments",
+    role: "action",
+    type: "switch",
+    meaning: "also reread the stored attachments whose text was not read before"
+  },
+  {
+    name: "--meetings",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many stored meeting occurrences in context",
+    unit: "meetings"
+  },
+  {
+    name: "--cues",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many transcript cues per selected occurrence",
+    unit: "cues"
+  },
+  {
+    name: "--context-limit",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many entries per context category",
+    unit: "items"
+  },
+  {
+    name: "--scan-limit",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many stored candidates inspected for one bounded read",
+    unit: "items"
+  },
+  {
+    name: "--bytes",
+    value: "<bytes>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many bytes of included evidence content",
+    unit: "bytes"
+  },
+  {
+    name: "--max-read-bytes",
+    value: "<bytes>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many stored text bytes read for one bounded evidence window",
+    unit: "bytes"
+  },
+  {
+    name: "--depth",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "maximum descendant depth in a hierarchy",
+    unit: "levels"
+  },
+  { name: "--timeout", value: "<duration>", role: "budget", type: "duration", meaning: "give up after this long" },
+  {
+    name: "--catch-up-chunks",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many chunks prepared after the run",
+    unit: "chunks"
+  },
+  {
+    name: "--catch-up-messages",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "skip the graph rebuild above this many messages",
+    unit: "messages"
+  },
+  {
+    name: "--concurrency",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "requests to the source at once",
+    unit: "requests"
+  },
+  {
+    name: "--deep",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "also check the top n in full, one a second",
+    unit: "people"
+  },
+  {
+    name: "--max-actions",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many actions in one run",
+    unit: "actions"
+  },
+  {
+    name: "--max-chats",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many chats in one run",
+    unit: "chats"
+  },
+  {
+    name: "--max-chunks",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many chunks in one run",
+    unit: "chunks"
+  },
+  {
+    name: "--max-gaps",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many gaps repaired in one run",
+    unit: "gaps"
+  },
+  {
+    name: "--max-input-bytes",
+    value: "<bytes>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many bytes of buffered stdin",
+    unit: "bytes"
+  },
+  {
+    name: "--max-messages",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many messages in one run",
+    unit: "messages"
+  },
+  {
+    name: "--max-replies",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many replies read",
+    unit: "replies"
+  },
+  {
+    name: "--max-tokens",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many model tokens in one run",
+    unit: "tokens"
+  },
+  {
+    name: "--thread-bytes",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many bytes in each thread context",
+    unit: "bytes"
+  },
+  {
+    name: "--thread-hops",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many links from the hit",
+    unit: "links"
+  },
+  {
+    name: "--thread-messages",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many messages in each thread context",
+    unit: "messages"
+  },
+  {
+    name: "--catch-up-time",
+    value: "<duration>",
+    role: "budget",
+    type: "duration",
+    meaning: "how long local preparation after the run may take"
+  },
+  {
+    name: "--max-bytes",
+    value: "<bytes>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many bytes of one file read or downloaded",
+    unit: "bytes"
+  },
+  {
+    name: "--max-comparisons",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many name comparisons",
+    unit: "comparisons"
+  },
+  {
+    name: "--max-cost",
+    value: "<usd>",
+    role: "budget",
+    type: "number",
+    meaning: "stop a run that costs more than this",
+    unit: "US dollars"
+  },
+  {
+    name: "--max-duration",
+    value: "<duration>",
+    role: "budget",
+    type: "duration",
+    meaning: "the longest audio it takes on"
+  },
+  {
+    name: "--max-entries",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many entries read",
+    unit: "entries"
+  },
+  {
+    name: "--max-meetings",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many meetings looked through, newest first",
+    unit: "meetings"
+  },
+  {
+    name: "--max-output-bytes",
+    value: "<bytes>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many bytes of machine output; 0 means no limit",
+    unit: "bytes"
+  },
+  {
+    name: "--max-pages",
+    value: "<pages>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many pages read from the source",
+    unit: "pages",
+    replaces: ["--budget"]
+  },
+  {
+    name: "--max-rows",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many transcript lines read",
+    unit: "lines"
+  },
+  {
+    name: "--max-segments",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many recognized segments",
+    unit: "segments"
+  },
+  {
+    name: "--max-subscriber-buffer-bytes",
+    value: "<bytes>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many bytes buffered for one watcher before it is cut off; 0 means no limit",
+    unit: "bytes"
+  },
+  {
+    name: "--max-subscriber-total-buffer-bytes",
+    value: "<bytes>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many bytes buffered for all watchers together; 0 means no limit",
+    unit: "bytes"
+  },
+  {
+    name: "--max-text-bytes",
+    value: "<bytes>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many bytes of transcript text read",
+    unit: "bytes"
+  },
+  {
+    name: "--max-total-bytes",
+    value: "<bytes>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many bytes in all, checked before any write",
+    unit: "bytes"
+  },
+  {
+    name: "--max-transcript-pages",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "at most this many transcript pages read",
+    unit: "pages"
+  },
+  {
+    name: "--repair-time",
+    value: "<duration>",
+    role: "budget",
+    type: "duration",
+    meaning: "how long a repair may take"
+  },
+  {
+    name: "--server-time",
+    value: "<duration>",
+    role: "budget",
+    type: "duration",
+    meaning: "stop waiting for the server's answer after this long"
+  },
+  {
+    name: "--sync-time",
+    value: "<duration>",
+    role: "budget",
+    type: "duration",
+    meaning: "stop fetching from the source after this long"
+  },
+  {
+    name: "--threads",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "threads on this machine, in all",
+    unit: "threads"
+  },
+  {
+    name: "--workers",
+    value: "<n>",
+    role: "budget",
+    type: "count",
+    meaning: "sessions in parallel on this machine, each with its own copy of the model",
+    unit: "sessions"
+  },
+  {
+    name: "--input",
+    value: "<mode>",
+    role: "mode",
+    type: "choice",
+    meaning: "how supplied cell values are parsed: literal values or provider-interpreted formulas and locale formats"
+  },
+  {
+    name: "--render",
+    value: "<mode>",
+    role: "output",
+    type: "choice",
+    meaning: "how returned cell values are represented: formatted display values, unformatted values or formulas"
+  }
+];
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/standards/flags-what.js
+var WHAT_FLAGS = [
+  {
+    name: "--analysis-provider",
+    value: "<provider>",
+    role: "mode",
+    type: "choice",
+    meaning: "who analyses the selected text: the calling agent or a configured model service"
+  },
+  {
+    name: "--embedding-provider",
+    value: "<provider>",
+    role: "mode",
+    type: "choice",
+    meaning: "who computes embeddings: a local model or a configured remote model service"
+  },
+  {
+    name: "--consent-provider",
+    value: "<identity>",
+    role: "target",
+    type: "string",
+    meaning: "the exact model-service identity whose recorded consent is being removed"
+  },
+  {
+    name: "--claim",
+    value: "<claim>",
+    role: "target",
+    type: "choice",
+    meaning: "the ownership claim to remove from a tag: manual or auto"
+  },
+  {
+    name: "--answer-model",
+    value: "<model>",
+    role: "target",
+    type: "string",
+    meaning: "remove only stored analysis answers made by this model; does not run a model"
+  },
+  {
+    name: "--template-mode",
+    value: "<mode>",
+    role: "value",
+    type: "choice",
+    meaning: "the saved reply template's policy: fill-only or may-reword"
+  },
+  {
+    name: "--disappear-after",
+    value: "<duration|off>",
+    role: "value",
+    type: "duration",
+    meaning: "how long a new chat message is kept after sending; off keeps messages"
+  },
+  {
+    name: "--only-admins-edit-info",
+    value: "<on|off>",
+    role: "value",
+    type: "choice",
+    meaning: "only admins may change the chat's name, photo and description"
+  },
+  {
+    name: "--only-admins-send",
+    value: "<on|off>",
+    role: "value",
+    type: "choice",
+    meaning: "only admins may send messages to the chat"
+  },
+  {
+    name: "--remove-photo",
+    role: "value",
+    type: "switch",
+    meaning: "remove the chat's photo; not with a replacement photo"
+  },
+  {
+    name: "--sticker-file",
+    value: "<file>",
+    role: "value",
+    type: "path",
+    meaning: "a local sticker file to send as a message"
+  },
+  {
+    name: "--target-store",
+    value: "<file>",
+    role: "target",
+    type: "path",
+    meaning: "explicit destination store file for checking or restoring selected annotations"
+  },
+  {
+    name: "--bindings",
+    value: "<file>",
+    role: "target",
+    type: "path",
+    meaning: "JSON file mapping source typed references to explicitly selected destination references"
+  },
+  {
+    name: "--context-source",
+    value: "<id=cursor>",
+    role: "scope",
+    type: "string",
+    meaning: "explicitly selected communications source, optionally with its scoped continuation cursor; repeat for more sources"
+  },
+  {
+    name: "--context-query",
+    value: "<words>",
+    role: "query",
+    type: "string",
+    meaning: "literal words to find within the communications selected for preparation"
+  },
+  {
+    name: "--alias",
+    value: "<name>",
+    role: "query",
+    type: "string",
+    meaning: "another name of the thing, searched as its own alternative beside its name; repeat for more"
+  },
+  {
+    name: "--context-since-time",
+    value: "<time>",
+    role: "target",
+    type: "time",
+    meaning: "inclusive start of the selected communications window used for preparation"
+  },
+  {
+    name: "--context-before-time",
+    value: "<time>",
+    role: "target",
+    type: "time",
+    meaning: "exclusive end of the selected communications window used for preparation"
+  },
+  {
+    name: "--account",
+    value: "<account>",
+    role: "scope",
+    type: "string",
+    meaning: "the account to use; never assumed"
+  },
+  {
+    name: "--provider",
+    value: "<provider>",
+    role: "scope",
+    type: "choice",
+    meaning: "read every account of this provider"
+  },
+  {
+    name: "--source",
+    value: "<accounts>",
+    role: "scope",
+    type: "list",
+    meaning: "what to read: provider:account, a provider, a kind or group:<name>; comma-separated",
+    replaces: ["--target-accounts"]
+  },
+  {
+    name: "--all-bots",
+    role: "scope",
+    type: "switch",
+    meaning: "also read every other bot's copy on this machine that the configuration allows"
+  },
+  {
+    name: "--archive",
+    value: "<dir>",
+    role: "scope",
+    type: "path",
+    meaning: "also read the transcripts in this archive folder"
+  },
+  {
+    name: "--backend",
+    value: "<archive|server|both>",
+    role: "scope",
+    type: "choice",
+    meaning: "where to search: the local archive, the source's server, or both"
+  },
+  {
+    name: "--bots",
+    value: "<profiles>",
+    role: "scope",
+    type: "list",
+    meaning: "also read these bots' copies, comma-separated, each allowed by the configuration"
+  },
+  {
+    name: "--only",
+    value: "<resources>",
+    role: "scope",
+    type: "list",
+    meaning: "only these resources, comma-separated"
+  },
+  {
+    name: "--profile",
+    value: "<name>",
+    role: "scope",
+    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>",
+    role: "target",
+    type: "time",
+    meaning: "inclusive start of the stored history window used for preparation"
+  },
+  {
+    name: "--expected-fingerprint",
+    value: "<hash>",
+    role: "target",
+    type: "string",
+    meaning: "require what it reads to match this fingerprint from an earlier read",
+    replaces: ["--if-sha256"]
+  },
+  { name: "--before-time", value: "<time>", role: "target", type: "time", meaning: "read what came before this time" },
+  { name: "--after-time", value: "<time>", role: "target", type: "time", meaning: "read what came after this time" },
+  { name: "--since-time", value: "<time>", role: "target", type: "time", meaning: "only what came since this time" },
+  {
+    name: "--until-time",
+    value: "<time>",
+    role: "target",
+    type: "time",
+    meaning: "only what came up to and including this time"
+  },
+  {
+    name: "--batch",
+    value: "<id>",
+    role: "target",
+    type: "id",
+    meaning: "the batch to act on, by the id that listed it"
+  },
+  {
+    name: "--component",
+    value: "<name>",
+    role: "target",
+    type: "string",
+    meaning: "the ranking component to read the evidence of"
+  },
+  {
+    name: "--counters",
+    value: "<names>",
+    role: "target",
+    type: "list",
+    meaning: "the counters to read: views, reactions, comments"
+  },
+  { name: "--failed", role: "target", type: "switch", meaning: "every chat whose newest job failed or died" },
+  { name: "--left", role: "target", type: "switch", meaning: "only the chats this account has left" },
+  { name: "--others", role: "target", type: "switch", meaning: "every session but this one" },
+  {
+    name: "--saved",
+    value: "<name|id>",
+    role: "target",
+    type: "string",
+    meaning: "run a saved search, or an earlier run by its id"
+  },
+  {
+    name: "--selection",
+    value: "<json>",
+    role: "target",
+    type: "string",
+    meaning: "the resolved ranking selection a drilldown returned"
+  },
+  {
+    name: "--attachment",
+    value: "<n>",
+    role: "target",
+    type: "count",
+    meaning: "which file of the message, from 1; needed when it has more than one"
+  },
+  {
+    name: "--bot",
+    role: "target",
+    type: "switch",
+    meaning: "the bot section of the configuration, not the personal account's"
+  },
+  {
+    name: "--chat",
+    value: "<chat>",
+    role: "target",
+    type: "id",
+    meaning: "the chat it acts on: its id or name; repeat it where several are taken"
+  },
+  {
+    name: "--contact",
+    value: "<person>",
+    role: "target",
+    type: "id",
+    meaning: "a contact: their id, @username or name, as the store knows them"
+  },
+  { name: "--defaults", role: "target", type: "switch", meaning: "what every profile gets, not only this profile" },
+  {
+    name: "--file-ids",
+    value: "<ids>",
+    role: "target",
+    type: "list",
+    meaning: "only these files, by comma-separated ids"
+  },
+  {
+    name: "--folder",
+    value: "<folder>",
+    role: "target",
+    type: "string",
+    meaning: "a notes folder, by its id or path; repeat it for more"
+  },
+  {
+    name: "--for",
+    value: "<agents>",
+    role: "target",
+    type: "list",
+    meaning: "the agents to install for, comma-separated"
+  },
+  {
+    name: "--from-dir",
+    value: "<dir>",
+    role: "target",
+    type: "path",
+    meaning: "match files in this folder, not its subfolders"
+  },
+  {
+    name: "--last",
+    value: "<n>",
+    role: "target",
+    type: "count",
+    meaning: "stop once the newest n messages are held",
+    unit: "messages"
+  },
+  { name: "--link", value: "<link>", role: "target", type: "string", meaning: "an invite link" },
+  {
+    name: "--lookback-days",
+    value: "<days>",
+    role: "target",
+    type: "count",
+    meaning: "look again at this many recent days, for what arrived late",
+    unit: "days"
+  },
+  {
+    name: "--meeting-id",
+    value: "<id>",
+    role: "target",
+    type: "id",
+    meaning: "one stored meeting selected for transcript search"
+  },
+  {
+    name: "--identity-id",
+    value: "<id>",
+    role: "target",
+    type: "id",
+    meaning: "a stored participant identity whose meetings are selected; does not identify the speaker of a hit"
+  },
+  {
+    name: "--person-id",
+    value: "<id>",
+    role: "target",
+    type: "id",
+    meaning: "a stored person whose linked participant identities select meetings"
+  },
+  {
+    name: "--series-id",
+    value: "<id>",
+    role: "target",
+    type: "id",
+    meaning: "one stored recurring series selected for meeting search"
+  },
+  { name: "--meeting", value: "<id>", role: "target", type: "id", meaning: "a meeting, by its store id" },
+  {
+    name: "--message",
+    value: "<message>",
+    role: "target",
+    type: "id",
+    meaning: "a message: its id in --chat, or a msg: locator alone"
+  },
+  {
+    name: "--new",
+    role: "target",
+    type: "switch",
+    meaning: "only what is new since this command last ran, each once; for scheduled runs"
+  },
+  {
+    name: "--note",
+    value: "<reference>",
+    role: "target",
+    type: "string",
+    meaning: "a note: note:<id>, or a file in a notes folder: document:<id>"
+  },
+  {
+    name: "--occurrence-id",
+    value: "<id>",
+    role: "target",
+    type: "id",
+    meaning: "one occurrence of a recurring meeting"
+  },
+  { name: "--old-parent", value: "<id>", role: "target", type: "id", meaning: "the folder to take it out of, by id" },
+  { name: "--only-missing", role: "target", type: "switch", meaning: "only what has none yet" },
+  {
+    name: "--organization",
+    value: "<organization>",
+    role: "target",
+    type: "string",
+    meaning: "an organization: its id or organization:<id>"
+  },
+  { name: "--parent", value: "<id>", role: "target", type: "id", meaning: "the folder or task it sits under, by id" },
+  {
+    name: "--participant-id",
+    value: "<id>",
+    role: "target",
+    type: "id",
+    meaning: "a participant of the meeting, by id"
+  },
+  { name: "--person", value: "<uid>", role: "target", type: "id", meaning: "a person, by their stored UID" },
+  { name: "--personal", role: "target", type: "switch", meaning: "the personal-account section of the configuration" },
+  {
+    name: "--project",
+    value: "<project>",
+    role: "target",
+    type: "string",
+    meaning: "a project: its key or project:<id>"
+  },
+  {
+    name: "--recheck-since-time",
+    value: "<time>",
+    role: "target",
+    type: "time",
+    meaning: "look again from this day, for what arrived late"
+  },
+  { name: "--run", value: "<id>", role: "target", type: "id", meaning: "the run it is about" },
+  {
+    name: "--target",
+    value: "<ref>",
+    role: "target",
+    type: "string",
+    meaning: "what it acts on, as a reference: msg:, chat:, person:, task:, \u2026"
+  },
+  {
+    name: "--secret",
+    value: "<name>",
+    role: "target",
+    type: "choice",
+    meaning: "which secret beside a bot's token to keep, typed at a hidden prompt; never the secret itself"
+  },
+  {
+    name: "--store-token",
+    value: "<profile>",
+    role: "action",
+    type: "string",
+    meaning: "keep a token an operation returns only in this bot profile's keyring; never print it"
+  },
+  { 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" },
+  { name: "--uuid", value: "<uuid>", role: "target", type: "string", meaning: "one meeting occurrence, by its UUID" },
+  {
+    name: "--ignore",
+    value: "<path>",
+    role: "target",
+    type: "path",
+    meaning: "also skip this file or folder, a path or a glob; repeat it for more"
+  },
+  { name: "--subfolder", value: "<path>", role: "target", type: "path", meaning: "a subfolder inside --folder" },
+  {
+    name: "--into",
+    value: "<id>",
+    role: "target",
+    type: "id",
+    meaning: "the existing thing it goes into, instead of standing alone"
+  },
+  {
+    name: "--all-in-chat",
+    role: "target",
+    type: "switch",
+    meaning: "also every undecided place of the same value in its chat"
+  },
+  {
+    name: "--due-within",
+    value: "<duration>",
+    role: "target",
+    type: "duration",
+    meaning: "what falls due within this long from now"
+  },
+  {
+    name: "--unanswered",
+    value: "<duration>",
+    role: "target",
+    type: "duration",
+    meaning: "chats where someone else wrote last at least this long ago"
+  },
+  {
+    name: "--waiting",
+    value: "<duration>",
+    role: "target",
+    type: "duration",
+    meaning: "chats where the owner wrote last and nobody answered for at least this long"
+  },
+  {
+    name: "--at-time",
+    value: "<time>",
+    role: "value",
+    type: "time",
+    meaning: "do it at this time",
+    replaces: ["--once"]
+  },
+  {
+    name: "--add",
+    value: "<chat>",
+    role: "value",
+    type: "id",
+    meaning: "put this chat into the set being changed; repeat it for more"
+  },
+  { name: "--all-can-pin", value: "<on|off>", role: "value", type: "choice", meaning: "every member may pin messages" },
+  { name: "--anonymous", role: "value", type: "switch", meaning: "nobody sees who voted for what" },
+  {
+    name: "--approval",
+    role: "value",
+    type: "switch",
+    meaning: "who joins by the link asks first, and an admin lets them in"
+  },
+  { name: "--can", value: "<rights>", role: "value", type: "list", meaning: "what an admin may do, comma-separated" },
+  { name: "--channel", role: "value", type: "switch", meaning: "a channel instead of a group" },
+  {
+    name: "--certainty",
+    value: "<n>",
+    role: "value",
+    type: "number",
+    meaning: "how sure the agent is, from 0 to 1; kept with what it wrote"
+  },
+  {
+    name: "--closed",
+    value: "<on|off>",
+    role: "value",
+    type: "choice",
+    meaning: "close it to new messages, or reopen it"
+  },
+  { name: "--comment-to", value: "<post>", role: "value", type: "id", meaning: "comment on this channel post" },
+  { name: "--description", value: "<text>", role: "value", type: "string", meaning: "the new description" },
+  { name: "--expire-time", value: "<time>", role: "value", type: "time", meaning: "it stops working at this time" },
+  { name: "--first-name", value: "<name>", role: "value", type: "string", meaning: "the account's first name" },
+  { name: "--hidden", value: "<on|off>", role: "value", type: "choice", meaning: "hide it from the list, or show it" },
+  { name: "--last-name", value: "<name>", role: "value", type: "string", meaning: "the account's last name" },
+  {
+    name: "--max-uses",
+    value: "<n>",
+    role: "value",
+    type: "count",
+    meaning: "at most this many people join by it",
+    unit: "people"
+  },
+  {
+    name: "--members-see-link",
+    value: "<on|off>",
+    role: "value",
+    type: "choice",
+    meaning: "members may see the invite link"
+  },
+  { name: "--multiple", role: "value", type: "switch", meaning: "people may pick several answers" },
+  {
+    name: "--only-admins-add",
+    value: "<on|off>",
+    role: "value",
+    type: "choice",
+    meaning: "only admins may add members"
+  },
+  {
+    name: "--only-admins-call",
+    value: "<on|off>",
+    role: "value",
+    type: "choice",
+    meaning: "only admins may start a call"
+  },
+  {
+    name: "--only-owner-edits-info",
+    value: "<on|off>",
+    role: "value",
+    type: "choice",
+    meaning: "only the owner may change the name and photo"
+  },
+  {
+    name: "--photo",
+    value: "<file>",
+    role: "value",
+    type: "path",
+    meaning: "an image file: a profile or chat photo, or a photo to send"
+  },
+  {
+    name: "--pinned",
+    value: "<on|off>",
+    role: "value",
+    type: "choice",
+    meaning: "pin it at the top of the list, or unpin it"
+  },
+  {
+    name: "--remove",
+    value: "<chat>",
+    role: "value",
+    type: "id",
+    meaning: "take this chat out of the set being changed; repeat it for more"
+  },
+  {
+    name: "--reply-to",
+    value: "<message>",
+    role: "value",
+    type: "id",
+    meaning: "answer this message in the same chat"
+  },
+  { name: "--revote", role: "value", type: "switch", meaning: "people may change their vote" },
+  { name: "--send-as", value: "<id>", role: "value", type: "id", meaning: "send as this identity of the chat" },
+  {
+    name: "--voice",
+    value: "<file>",
+    role: "value",
+    type: "path",
+    meaning: "an Ogg Opus file sent as a voice message"
+  },
+  {
+    name: "--about-text",
+    value: "<who>",
+    role: "value",
+    type: "choice",
+    meaning: "who sees the about text: everyone, contacts or nobody"
+  },
+  {
+    name: "--calls",
+    value: "<who>",
+    role: "value",
+    type: "choice",
+    meaning: "whose calls ring: everyone, contacts or nobody"
+  },
+  {
+    name: "--chat-invites",
+    value: "<who>",
+    role: "value",
+    type: "choice",
+    meaning: "who may add the account to groups and channels: everyone, contacts or nobody"
+  },
+  {
+    name: "--find-by-phone",
+    value: "<who>",
+    role: "value",
+    type: "choice",
+    meaning: "who finds the account by its number: everyone, contacts or nobody"
+  },
+  {
+    name: "--hide-online",
+    value: "<on|off>",
+    role: "value",
+    type: "choice",
+    meaning: "hide online status and last seen"
+  },
+  {
+    name: "--last-seen",
+    value: "<who>",
+    role: "value",
+    type: "choice",
+    meaning: "who sees when the account was last online: everyone, contacts or nobody"
+  },
+  {
+    name: "--phone-number",
+    value: "<who>",
+    role: "value",
+    type: "choice",
+    meaning: "who sees the number: everyone, contacts or nobody"
+  },
+  {
+    name: "--profile-photo",
+    value: "<who>",
+    role: "value",
+    type: "choice",
+    meaning: "who sees the profile photo: everyone, contacts or nobody"
+  },
+  { name: "--read-receipts", value: "<on|off>", role: "value", type: "choice", meaning: "send read receipts" },
+  {
+    name: "--until",
+    value: "<time>",
+    role: "value",
+    type: "time",
+    meaning: "only until then: a local time, or a duration from now"
+  },
+  { name: "--agenda", value: "<text>", role: "value", type: "string", meaning: "the meeting's agenda" },
+  {
+    name: "--allow-chats",
+    value: "<ids>",
+    role: "value",
+    type: "list",
+    meaning: "the chats allowed, by comma-separated ids; empty clears",
+    replaces: ["--chats"]
+  },
+  {
+    name: "--allow-people",
+    value: "<ids>",
+    role: "value",
+    type: "list",
+    meaning: "the senders allowed, by comma-separated ids; empty clears",
+    replaces: ["--people"]
+  },
+  {
+    name: "--as",
+    value: "<state>",
+    role: "value",
+    type: "choice",
+    meaning: "how it is closed: done, or dismissed when it needs no answer"
+  },
+  { name: "--assignee", value: "<person...>", role: "value", type: "list", meaning: "who does it, by UID" },
+  { name: "--at", value: "<hh:mm>", role: "value", type: "string", meaning: "every day at this local time" },
+  { name: "--body", value: "<json>", role: "value", type: "string", meaning: "the request body, as JSON" },
+  {
+    name: "--caption-above",
+    role: "value",
+    type: "switch",
+    meaning: "show the text above the photo or file, not below it"
+  },
+  {
+    name: "--close-time",
+    value: "<delay>",
+    role: "value",
+    type: "duration",
+    meaning: "it closes by itself this long after sending"
+  },
+  {
+    name: "--correct",
+    value: "<n>",
+    role: "value",
+    type: "count",
+    meaning: "with --quiz, the right answer's position, from 1"
+  },
+  {
+    name: "--deny-chats",
+    value: "<ids>",
+    role: "value",
+    type: "list",
+    meaning: "the chats left out, by comma-separated ids; empty clears; deny wins",
+    replaces: ["--not-chats"]
+  },
+  {
+    name: "--deny-people",
+    value: "<ids>",
+    role: "value",
+    type: "list",
+    meaning: "the senders left out, by comma-separated ids; empty clears; deny wins",
+    replaces: ["--not-people"]
+  },
+  { name: "--due", value: "<time>", role: "value", type: "time", meaning: "when it must be done" },
+  {
+    name: "--duration-minutes",
+    value: "<minutes>",
+    role: "value",
+    type: "count",
+    meaning: "how long the meeting lasts, in minutes",
+    unit: "minutes"
+  },
+  { name: "--emoji", value: "<emoji>", role: "value", type: "string", meaning: "the icon" },
+  {
+    name: "--event-id",
+    value: "<id>",
+    role: "value",
+    type: "id",
+    meaning: "the stored calendar event it is linked to, or none to unlink"
+  },
+  { name: "--every", value: "<duration>", role: "value", type: "duration", meaning: "repeat this often" },
+  {
+    name: "--evidence",
+    value: "<ref...>",
+    role: "value",
+    type: "list",
+    meaning: "what shows it: msg:, note:, meeting:, person: or another reference"
+  },
+  {
+    name: "--exclude-chat",
+    value: "<chat>",
+    role: "value",
+    type: "id",
+    meaning: "never show this chat in it; repeat it for more"
+  },
+  {
+    name: "--file",
+    value: "<file>",
+    role: "value",
+    type: "path",
+    meaning: "a file to send with the message; the text becomes its caption"
+  },
+  {
+    name: "--filename",
+    value: "<name>",
+    role: "value",
+    type: "string",
+    meaning: "the name others see for the file, instead of its name on disk"
+  },
+  {
+    name: "--history",
+    role: "value",
+    type: "switch",
+    meaning: "the people added also see the messages from before they came"
+  },
+  {
+    name: "--include",
+    value: "<kinds>",
+    role: "value",
+    type: "list",
+    meaning: "every chat of these kinds, comma-separated"
+  },
+  {
+    name: "--join-approval",
+    value: "<on|off>",
+    role: "value",
+    type: "choice",
+    meaning: "people ask to join the chat, and an admin lets them in"
+  },
+  {
+    name: "--key",
+    value: "<key>",
+    role: "value",
+    type: "string",
+    meaning: "the short key, 3\u20134 letters and digits; made from the name when left out"
+  },
+  {
+    name: "--kind",
+    value: "<kind>",
+    role: "value",
+    type: "choice",
+    meaning: "what kind of thing it is; the command lists the kinds"
+  },
+  { name: "--name", value: "<name>", role: "value", type: "string", meaning: "the name to give it" },
+  { name: "--no-approval", role: "value", type: "switch", meaning: "anyone with the link joins at once" },
+  {
+    name: "--notification",
+    value: "<text>",
+    role: "value",
+    type: "string",
+    meaning: "a note only the person who pressed sees"
+  },
+  {
+    name: "--params",
+    value: "<json>",
+    role: "value",
+    type: "string",
+    meaning: "the request's query and path parameters, as JSON"
+  },
+  { name: "--payload", value: "<json>", role: "value", type: "string", meaning: "the data of what to do, as JSON" },
+  {
+    name: "--pin",
+    value: "<chat>",
+    role: "value",
+    type: "id",
+    meaning: "pin this chat at the top of it; repeat it for more"
+  },
+  { name: "--priority", value: "<n>", role: "value", type: "count", meaning: "0 urgent \u2026 4 low" },
+  { name: "--quiz", role: "value", type: "switch", meaning: "a quiz: one answer is right, and a vote is final" },
+  {
+    name: "--reason",
+    value: "<text>",
+    role: "value",
+    type: "string",
+    meaning: "why, in a few words; kept with it",
+    replaces: ["--provenance"]
+  },
+  { name: "--remind-time", value: "<time>", role: "value", type: "time", meaning: "when to look at it again" },
+  { name: "--role", value: "<role>", role: "value", type: "string", meaning: "the part it plays, in a word or two" },
+  {
+    name: "--scope",
+    value: "<scope>",
+    role: "value",
+    type: "choice",
+    meaning: "personal or work: which side of the owner's life it belongs to"
+  },
+  {
+    name: "--solution",
+    value: "<text>",
+    role: "value",
+    type: "string",
+    meaning: "with --quiz, what people see once they answered"
+  },
+  {
+    name: "--spoiler",
+    role: "value",
+    type: "switch",
+    meaning: "hide the photo or video behind a spoiler until tapped"
+  },
+  {
+    name: "--start",
+    value: "<param>",
+    role: "value",
+    type: "string",
+    meaning: "the start parameter the bot or app reads"
+  },
+  { name: "--start-time", value: "<time>", role: "value", type: "time", meaning: "when it starts" },
+  { name: "--sticker", value: "<id>", role: "value", type: "id", meaning: "send this sticker, alone" },
+  {
+    name: "--subject",
+    value: "<ref>",
+    role: "value",
+    type: "string",
+    meaning: "what it is about, as a reference",
+    replaces: ["--about"]
+  },
+  {
+    name: "--supersedes",
+    value: "<ref>",
+    role: "value",
+    type: "string",
+    meaning: "the earlier one this replaces, as a reference"
+  },
+  { name: "--text", value: "<text>", role: "value", type: "string", meaning: "the text" },
+  {
+    name: "--text-file",
+    value: "<path>",
+    role: "value",
+    type: "path",
+    meaning: "read the text from this file; - reads stdin"
+  },
+  { name: "--title", value: "<title>", role: "value", type: "string", meaning: "the title or name to give it" },
+  {
+    name: "--type",
+    value: "<type>",
+    role: "value",
+    type: "choice",
+    meaning: "what type of thing it is; the command lists the types"
+  },
+  {
+    name: "--types",
+    value: "<types>",
+    role: "value",
+    type: "list",
+    meaning: "the update types, comma-separated, in the messenger's words"
+  },
+  {
+    name: "--occurred-time",
+    value: "<time>",
+    role: "value",
+    type: "time",
+    meaning: "when it happened",
+    replaces: ["--occurred"]
+  },
+  { name: "--clear", role: "value", type: "switch", meaning: "unset it, instead of setting a new value" },
+  {
+    name: "--do",
+    value: "<actions>",
+    role: "value",
+    type: "list",
+    meaning: "what a rule does when it matches, comma-separated; the command lists the actions"
+  },
+  { name: "--sender", value: "<address>", role: "value", type: "string", meaning: "a sender, by email address" },
+  {
+    name: "--domain",
+    value: "<domain>",
+    role: "value",
+    type: "string",
+    meaning: "an internet domain, such as example.com"
+  },
+  { name: "--list-id", value: "<id>", role: "value", type: "id", meaning: "a mailing list, by its List-Id header" },
+  {
+    name: "--category",
+    value: "<name>",
+    role: "value",
+    type: "choice",
+    meaning: "what it is about; the command lists the categories"
+  },
+  {
+    name: "--holder",
+    value: "<name>",
+    role: "value",
+    type: "string",
+    meaning: "who takes or holds a claim: a session or chat id; the command says its default"
+  },
+  {
+    name: "--lease",
+    value: "<duration>",
+    role: "value",
+    type: "duration",
+    meaning: "how long a claim lasts before it lapses by itself; claiming again extends it"
+  },
+  {
+    name: "--filter",
+    value: "<query>",
+    role: "query",
+    type: "string",
+    meaning: "a query every result must also match, beside the search's own words"
+  },
+  {
+    name: "--values",
+    value: "<json>",
+    role: "value",
+    type: "string",
+    meaning: "cell values as JSON rows for an explicit range update or row append; not a list filter"
+  }
+];
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/standards/vocabulary.js
+var FLAG_TYPES = [
+  "switch",
+  "count",
+  "number",
+  "string",
+  "id",
+  "time",
+  "duration",
+  "choice",
+  "list",
+  "path",
+  "cursor"
+];
+var FLAG_ROLES = {
+  paging: "which part of a long answer: how many, which page, where to continue",
+  output: "how the answer is shaped or shown",
+  sort: "the order of the answer",
+  mode: "how the command runs, not what it reads",
+  action: "does something extra besides the answer",
+  budget: "how much time or work the command may spend",
+  scope: "which accounts, providers or sources are read; never picked for you, so a flag and not a query field",
+  target: "which thing or time window the command acts on, when that is not a list's filter",
+  value: "sets a field on a write",
+  query: "a query in the query language, beside a search's own words"
+};
+var verbSchema = strictObject({ word, meaning: text, replaces: optional(array(word)) });
+var nounSchema = strictObject({
+  word,
+  meaning: text,
+  // A collection is named in the plural; a singular is what a profile has exactly one of.
+  kind: picklist(["collection", "singular"]),
+  replaces: optional(array(word))
+});
+var viewSchema = strictObject({ word, meaning: text });
+var rootSchema = strictObject({ word, meaning: text });
+var flagSchema = strictObject({
+  name: pipe(string(), regex(/^--[a-z][a-z0-9]*(-[a-z0-9]+)*$/, "a long flag: --lower-case-words")),
+  value: optional(pipe(string(), regex(/^<[a-z][a-z0-9-|=:]*(\.\.\.)?>$/, "a value name such as <n>"))),
+  type: picklist(FLAG_TYPES),
+  role: picklist(Object.keys(FLAG_ROLES)),
+  meaning: text,
+  unit: optional(text),
+  /** Other names for the same flag, which `flag-synonym` refuses. */
+  replaces: optional(array(pipe(string(), regex(/^--[a-z][a-z0-9]*(-[a-z0-9]+)*$/, "a long flag"))))
+});
+var vocabularySchema = strictObject({
+  verbs: array(verbSchema),
+  nouns: array(nounSchema),
+  views: array(viewSchema),
+  roots: array(rootSchema),
+  flags: array(flagSchema)
+});
+var defineVocabulary = /* @__PURE__ */ __name((input) => parseRegistry("vocabulary", vocabularySchema, input, (vocabulary) => {
+  const problems = [];
+  const kinds = {
+    verbs: vocabulary.verbs.map((entry) => entry.word),
+    nouns: vocabulary.nouns.map((entry) => entry.word),
+    views: vocabulary.views.map((entry) => entry.word),
+    roots: vocabulary.roots.map((entry) => entry.word),
+    flags: vocabulary.flags.map((entry) => entry.name)
+  };
+  for (const [kind, words] of Object.entries(kinds))
+    for (const repeated of duplicates(words))
+      problems.push(`${kind}: "${repeated}" is listed twice`);
+  for (const flag of vocabulary.flags)
+    if (flag.type === "switch" !== (flag.value === void 0))
+      problems.push(`flags: ${flag.name} \u2014 a switch has no value name; every other type has one`);
+  const verbs2 = new Set(kinds.verbs);
+  for (const verb of vocabulary.verbs)
+    for (const old of verb.replaces ?? [])
+      if (verbs2.has(old))
+        problems.push(`verbs: "${verb.word}" replaces "${old}", which is itself a verb`);
+  const flags = new Set(kinds.flags);
+  for (const flag of vocabulary.flags)
+    for (const old of flag.replaces ?? [])
+      if (flags.has(old))
+        problems.push(`flags: ${flag.name} replaces ${old}, which is itself a flag`);
+  return problems;
+}), "defineVocabulary");
+var verbs = [
+  ["list", "show many"],
+  ["show", "show one"],
+  ["search", "find by text; the description says where it looks"],
+  ["prepare", "assemble bounded cited context for a selected upcoming activity without applying findings"],
+  ["related", "what is nearest in meaning to one thing, without a query"],
+  ["info", "facts about a singular thing itself: where it is, its size, its version, its schema"],
+  ["status", "how a thing stands right now"],
+  ["check", "verify, and change nothing; the answer says what is wrong and how to fix it"],
+  ["test", "run rules over what is already stored and say what they would have done, doing none of it"],
+  ["apply", "run the owner's saved rules over what is already stored and change what they match; dry run unless --yes"],
+  ["scan", "read stored messages for what a rule finds, such as tasks, and list it; records it only with --yes"],
+  ["pause", "stop what a running process does for a profile, without stopping the process"],
+  ["resume", "restart what pause stopped"],
+  ["create", "make a thing"],
+  ["delete", "destroy a thing"],
+  ["add", "put an existing thing into a set"],
+  ["remove", "take a thing out of a set"],
+  ["clear", "empty a set"],
+  ["update", "change a thing's fields"],
+  ["set", "set one named key"],
+  ["unset", "remove one named key"],
+  ["insert", "put bounded rows, columns or cells before an explicit position, shifting later entries"],
+  ["format", "change how selected cells are displayed without replacing their values"],
+  ["rename", "change a thing's name only"],
+  ["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"],
+  [
+    "sync",
+    "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"],
+  ["transcribe", "turn speech into text"],
+  ["extract", "read the text inside files already on this machine into the store"],
+  ["migrate", "bring a file up to this build's schema"],
+  ["backup", "copy a file somewhere safe"],
+  ["restore", "put a backup back in its place"],
+  ["repair", "bring a file's tables to this build's shape without deleting anything"],
+  [
+    "rebuild",
+    "compute again, from what the store already holds, what the tool derives from it, keeping the owner's decisions"
+  ],
+  // Only when someone asks, never from a matching name: WC-ACCT-11 in docs/standards/accounts.md.
+  ["link", "record that two identities are one person"],
+  ["unlink", "undo a link"],
+  ["lookup", "ask the messenger who is behind a phone number"],
+  [
+    "inspect",
+    "look at a source before taking anything from it: a chat link without joining, a mailbox without importing"
+  ],
+  ["send", "send a message"],
+  ["edit", "change a sent message"],
+  ["forward", "send an existing message on to another chat"],
+  ["pin", "pin a message or chat"],
+  ["unpin", "unpin a message or chat"],
+  ["star", "mark a message so the owner finds it again; only the owner sees the star"],
+  ["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"],
+  ["close", "close a thing that stays: a poll, a task"],
+  ["join", "join a chat"],
+  ["leave", "leave a chat"],
+  ["mute", "stop notifications from a chat for the owner; nobody in it is told"],
+  ["unmute", "undo a mute"],
+  ["block", "block a person"],
+  ["unblock", "unblock a person"],
+  ["mark-read", "mark a chat read; the other person sees it"],
+  ["mark-unread", "mark a chat unread on the owner's own devices; nobody in it is told"],
+  ["archive", "move a chat into the messenger's archive, out of the main chat list; nobody in it is told"],
+  ["unarchive", "bring an archived chat back to the main chat list"],
+  ["reset", "replace a thing; the old one stops working"],
+  ["moderate", "apply a chat's rules: delete what breaks them, act on who broke them"],
+  ["assign", "name the person responsible for work, with their task role"],
+  ["reverse", "record that an accepted decision no longer holds, without replacing it"],
+  ["invalidate", "mark a derived record whose supporting evidence no longer holds"],
+  ["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"],
+  ["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"],
+  ["release", "give back what claim took, before it lapses"],
+  ["merge", "fold a duplicate into the thing that stays; nothing is deleted"],
+  ["unmerge", "undo a merge"],
+  ["defer", "leave a decision undecided, for the owner"],
+  ["embed", "compute the vectors a meaning search reads, for what is stored and has none"],
+  ["decrypt", "write an unencrypted copy of a file sealed by the tool, using the supplied password"],
+  ["retry", "start a fresh attempt at partial or failed work, retaining the previous attempt"]
+];
+var replaces = {
+  list: ["ls"],
+  show: ["get", "view"],
+  search: ["find", "query"],
+  delete: ["rm", "trash"],
+  create: ["mkdir"],
+  update: ["plan"],
+  set: ["configure"],
+  sync: ["refresh"],
+  check: ["audit", "preflight"],
+  status: ["readiness"],
+  confirm: ["accept", "approve"],
+  reject: ["decline", "deny"]
+};
+var collections = [
+  ["chats", "conversations in a messenger"],
+  ["contacts", "identities in a messenger's contact list"],
+  ["messages", "posts in a messenger chat, or emails"],
+  ["polls", "polls in a chat"],
+  ["reactions", "reactions to a message"],
+  ["recipients", "who a message goes to"],
+  ["replies", "the automatic replies of a profile"],
+  ["sends", "messages waiting to be sent, or sent by this tool"],
+  ["runs", "past runs of this tool"],
+  ["topics", "forum topics in a group"],
+  ["models", "local or remote models"],
+  ["tags", "labels the owner puts on things"],
+  ["searches", "the owner's saved searches"],
+  ["copies", "tables kept aside by a repair"],
+  ["tables", "the tables of the local store, with their kind, row count and size"],
+  ["attachments", "files of stored messages"],
+  ["tasks", "what waits on the owner"],
+  ["members", "people in a chat"],
+  ["admins", "administrators of a chat"],
+  ["tracking", "the chats whose member lists are fetched daily"],
+  ["documents", "files imported from Google Drive or Docs, or linked in a chat"],
+  ["notes", "text the owner writes, or files from a notes folder"],
+  ["projects", "the owner's work units with a task key"],
+  [
+    "annotations",
+    "derived records attached to a selected entity, with explicit coverage of included and omitted facets"
+  ],
+  ["organizations", "companies, teams, families or communities"],
+  [
+    "identities",
+    "ways to reach a person or an organization: an account in one messenger or mailbox, an e-mail address, a phone"
+  ],
+  ["facts", "what happened, with evidence"],
+  ["memories", "what an agent concluded, with evidence and scope"],
+  ["relationships", "confirmed or suggested links between people, organizations and projects"],
+  ["sheets", "remote spreadsheets and their cell ranges, read or changed through a provider"],
+  ["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"],
+  ["agents", "the agents whose actions are recorded in the shared store"],
+  ["reminders", "scheduled notices about stored work, claimed and acknowledged with delivery receipts"],
+  ["key-documents", "selected source documents that a project keeps as its starting references"],
+  ["answers", "evidence-grounded answers assembled from selected stored sources"],
+  ["aliases", "other names of one thing"],
+  ["mentions", "phones, e-mail addresses, links and documents found in stored text, each where it was written"],
+  ["images", "pictures in stored messages, searched by what they show"],
+  ["duplicates", "pairs of things that may be one, each waiting for a decision"],
+  ["sessions", "devices and applications signed in to an account"],
+  ["folders", "named groupings of chats or source files"],
+  ["links", "stored or source-provided connections between selected things"],
+  ["requests", "requests waiting for an explicit decision"],
+  ["rules", "saved rules the owner applies to selected things"],
+  ["conversations", "derived stretches of chat messages grouped by topic"],
+  ["batches", "bounded work packets submitted or waiting for processing"],
+  ["consents", "recorded permission to process selected data with a specified service"],
+  ["embeddings", "vectors computed from stored content for similarity search"],
+  ["reports", "saved reports about selected data or a tool's state"],
+  ["keys", "credentials for a selected external service"],
+  ["counters", "stored observations of source counts, with their freshness"],
+  ["gaps", "ranges a source could contain that the local store does not hold"],
+  ["callbacks", "button presses a bot received and may answer"],
+  ["webhooks", "addresses a messenger pushes a bot's updates to"],
+  ["templates", "messages a business has approved in advance, the only kind some messengers deliver late"],
+  ["media", "files people sent, held by the messenger under an id"]
+];
+var singulars = [
+  ["session", "this tool's login"],
+  ["account", "the messenger or mail account behind a profile"],
+  ["mail", "the local email archive and its mailbox import, rules and cleanup operations"],
+  ["config", "a profile's settings"],
+  ["server", "the long-running process of a profile"],
+  ["store", "the local SQLite database the tools share"],
+  ["catalog", "stored source file and folder metadata and parent relationships"],
+  ["skill", "the agent skill file of this tool"],
+  ["cache", "max's per-profile cache"],
+  ["flood", "what the messenger told this profile to hold off on"],
+  ["vocabulary", "the owner's catalogue of canonical names, with their aliases"],
+  ["api", "the source's own API, one command per operation"],
+  ["privacy", "who may find, see, call or add the account"],
+  ["metadata", "a profile's cached source attributes"],
+  ["auth", "the credentials a bot profile uses: its token and the secrets beside it"]
+];
+var views = [
+  ["tree", "the parent and child hierarchy of stored sources"],
+  ["logs", "the log of a running process"],
+  ["events", "what happened in a thing over time"],
+  ["scheduled", "what is scheduled to happen"],
+  ["context", "what surrounds one thing"],
+  ["path", "where a thing is on this machine"],
+  ["config", "the configuration a thing needs"],
+  ["history", "past uses of a thing"],
+  ["top", "a ranked view under stats"],
+  ["official", "the view the messenger itself computed, under stats"],
+  ["transcript", "the text of speech: a voice message or a meeting recording"],
+  ["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"],
+  ["comments", "replies attached to a selected source item"],
+  ["links", "links held for a selected thing"],
+  ["voters", "people whose recorded votes are visible for a selected poll"],
+  ["charts", "time series drawn from selected statistics, optionally rendered to a file"],
+  ["newcomers", "members observed joining during the selected time window"],
+  ["retention", "whether members of a selected cohort remain or return over time"],
+  ["responses", "observed replies between participants and the time taken to answer"],
+  ["discussion", "source posts compared by known views and observed discussion replies"],
+  ["unanswered", "questions without an observed qualifying answer"],
+  ["me", "the account a profile's token belongs to"],
+  ["between", "the messages between two given messages of one chat"],
+  ["app", "a bot's mini app: the address that opens it, signed in as the owner"]
+];
+var roots = [
+  ["batch", "run bounded explicitly registered reads with independent correlated answers"],
+  ["inbox", "what waits across every chat"],
+  ["review", "go through what needs the owner"],
+  ["watch", "follow new events as they come"],
+  ["serve", "the long-running process"],
+  ["setup", "the guided first run: log in or link the account, then install the agent skill"],
+  ["doctor", "check this machine's setup"],
+  ["upgrade", "install a newer version of this tool"],
+  ["commands", "the command tree as data"],
+  ["guide", "scenarios: the commands for a common task, in order, and why each"],
+  ["complete", "shell completion"],
+  ["mcp", "the MCP server and its setup"],
+  ["bot", "the profile's bot account"],
+  ["stats", "statistics"],
+  ["search", "searches across resources"]
+];
+var VOCABULARY = defineVocabulary({
+  verbs: verbs.map(([entry, meaning]) => ({
+    word: entry,
+    meaning,
+    ...replaces[entry] ? { replaces: replaces[entry] } : {}
+  })),
+  nouns: [
+    ...collections.map(([entry, meaning]) => ({ word: entry, meaning, kind: "collection" })),
+    ...singulars.map(([entry, meaning]) => ({ word: entry, meaning, kind: "singular" }))
+  ],
+  views: views.map(([entry, meaning]) => ({ word: entry, meaning })),
+  roots: roots.map(([entry, meaning]) => ({ word: entry, meaning })),
+  flags: [...HOW_FLAGS, ...WHAT_FLAGS, ...CALENDAR_FLAGS]
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/mcp/agent.js
+var TYPES = new Map(VOCABULARY.flags.map((flag) => [flag.name, flag.type]));
+var snake = /* @__PURE__ */ __name((name) => name.replaceAll("|", "_or_").replace(/[^a-z0-9]+/gi, "_"), "snake");
+var longOf = /* @__PURE__ */ __name((option) => option.flags.match(/--[a-z0-9][a-z0-9-]*/)?.[0], "longOf");
+var text2 = /* @__PURE__ */ __name((description2) => pipe(
+  string(),
+  minLength(1),
+  // `-` alone reads stdin, which is the MCP transport.
+  regex(/^(?!-$)[\s\S]+$/, "a value, and not only -"),
+  description(description2)
+), "text");
+var optionKind = /* @__PURE__ */ __name((option, long) => {
+  if (!option.takes_value)
+    return "switch";
+  if (option.choices)
+    return "text";
+  const type = TYPES.get(long);
+  if (type === "count" || type === "number" || type === "list")
+    return type;
+  if (/<json>/.test(option.flags))
+    return "json";
+  if (Array.isArray(option.default))
+    return "repeat";
+  return /\.\.\.[>\]]/.test(option.flags) ? "variadic" : "text";
+}, "optionKind");
+var CLEARS = /\bempty clears\b/;
+var optionField = /* @__PURE__ */ __name((option, long, negated) => {
+  const kind = optionKind(option, long);
+  const about = negated ? `${option.description}; false: ${negated.description}` : option.description;
+  const schema = kind === "switch" ? pipe(boolean(), description(about)) : option.choices ? pipe(picklist(option.choices), description(about)) : kind === "count" ? (
+    // The command judges the range: `--thread-hops 0` is one, `--limit 0` is not.
+    pipe(number(), integer(), minValue(0), description(about))
+  ) : kind === "number" ? pipe(number(), description(about)) : kind === "list" || kind === "repeat" ? (
+    // The command line takes `a,b` or the flag repeated; an agent may write one value, or a list.
+    pipe(union([pipe(array(text2("one value")), minLength(1)), text2(about)]), description(about))
+  ) : kind === "variadic" ? pipe(array(text2("one value")), minLength(1), description(about)) : kind === "json" ? (
+    // A next step hands back the object an answer gave; the command takes it as JSON text.
+    pipe(union([string(), record(string(), unknown())]), description(about))
+  ) : CLEARS.test(about) ? pipe(string(), regex(/^(?!-$)/, "not only -"), description(about)) : text2(about);
+  return {
+    name: snake(long.slice(2)),
+    required: option.mandatory,
+    schema,
+    positional: false,
+    argv: /* @__PURE__ */ __name((value) => {
+      if (kind === "switch")
+        return value === true ? [long] : negated ? [`--no-${long.slice(2)}`] : [];
+      if (kind === "variadic")
+        return value.map((one) => `${long}=${String(one)}`);
+      if (kind === "repeat")
+        return (Array.isArray(value) ? value : [value]).map((one) => `${long}=${String(one)}`);
+      if (kind === "list")
+        return [`${long}=${Array.isArray(value) ? value.map(String).join(",") : String(value)}`];
+      if (kind === "json")
+        return [`${long}=${typeof value === "string" ? value : JSON.stringify(value)}`];
+      return [`${long}=${String(value)}`];
+    }, "argv")
+  };
+}, "optionField");
+var argumentField = /* @__PURE__ */ __name((argument) => {
+  const one = argument.choices ? pipe(picklist(argument.choices), description(argument.description)) : text2(argument.description || argument.name);
+  return {
+    name: snake(argument.name),
+    required: argument.required,
+    // A query is several words on the command line; an agent writes it as one string, which is one of them.
+    schema: argument.variadic ? union([pipe(array(one), minLength(argument.required ? 1 : 0)), one]) : one,
+    positional: true,
+    argv: /* @__PURE__ */ __name((value) => Array.isArray(value) ? value.map(String) : [String(value)], "argv")
+  };
+}, "argumentField");
+var OFFLINE = {
+  name: "offline",
+  required: false,
+  schema: pipe(boolean(), description("answer from the copy on this machine only")),
+  positional: false,
+  argv: /* @__PURE__ */ __name((value) => value === true ? ["--offline"] : [], "argv")
+};
+var stdinField = /* @__PURE__ */ __name(({ name, description: description2, json }) => ({
+  name,
+  required: true,
+  schema: json ? pipe(union([string(), record(string(), unknown())]), description(description2)) : pipe(string(), minLength(1), description(description2)),
+  positional: false,
+  stdin: true,
+  argv: /* @__PURE__ */ __name(() => [], "argv")
+}), "stdinField");
+var fieldsOf = /* @__PURE__ */ __name((info, { omit = [], offline = false, stdin }) => {
+  const fields = info.arguments.map(argumentField);
+  const read = stdin?.(info.path);
+  if (read)
+    fields.push(stdinField(read));
+  const switches = new Map(info.options.filter((one) => !one.takes_value).map((one) => [longOf(one), one]));
+  for (const option of info.options) {
+    const long = longOf(option);
+    if (!long || option.mcp === false)
+      continue;
+    const positive = long.startsWith("--no-") ? switches.get(`--${long.slice(5)}`) : void 0;
+    if (positive && positive.mcp !== false)
+      continue;
+    const field = optionField(option, long, option.takes_value ? void 0 : switches.get(`--no-${long.slice(2)}`));
+    if (!fields.some((existing) => existing.name === field.name))
+      fields.push(field);
+  }
+  if (offline && info.effects?.remote === "read" && info.offline !== false)
+    fields.push(OFFLINE);
+  return fields.filter((field) => !omit.includes(field.name));
+}, "fieldsOf");
+var schemaOf = /* @__PURE__ */ __name((fields) => object(Object.fromEntries(fields.map((field) => [field.name, field.required ? field.schema : optional(field.schema)]))), "schemaOf");
+var startsWith = /* @__PURE__ */ __name((path, prefix) => prefix.every((word2, at) => path[at] === word2), "startsWith");
+var toolsFromCommands = /* @__PURE__ */ __name((commands, options = {}) => {
+  const { root = [], exclude = [], levels, keyOf, authority, readOnly = false, permissions } = options;
+  return flatten(commands).filter((info) => (
+    // A group is offered only when it runs on its own; without an action it only prints its help.
+    (info.commands.length === 0 || info.runnable === true) && info.path.length > root.length && startsWith(info.path, root) && !exclude.some((skipped) => startsWith(info.path.slice(root.length), skipped)) && info.mcp !== false && info.lifetime === void 0 && (options.includeUnavailable === true || !(readOnly && (changesMessenger(info) || authority?.(info.path))) && (levels === void 0 && !(readOnly && permissions) ? true : commandAvailability(info, levels ?? {}, keyOf, authority, readOnly, true, permissions).available))
+  )).map((info) => ({
+    availability: /* @__PURE__ */ __name(() => commandAvailability(info, options.currentLevels?.() ?? levels ?? {}, keyOf, authority, readOnly, true, permissions), "availability"),
+    command: info.path.slice(root.length).join(" "),
+    path: info.path,
+    title: info.summary ?? info.description,
+    description: info.description,
+    writes: writes(info.effects) && options.fetchOnly?.(info.path) !== true,
+    input: schemaOf(fieldsOf(info, options)),
+    ...info.output ? { output: info.output } : {}
+  }));
+}, "toolsFromCommands");
+var argvOf = /* @__PURE__ */ __name((info, input, profile, stdin) => {
+  const fields = fieldsOf(info, { offline: true, ...stdin ? { stdin } : {} });
+  const known = new Map(fields.map((field) => [field.name, field]));
+  for (const name of Object.keys(input))
+    if (!known.has(name))
+      throw new CliError("validation_error", `${info.path.join(" ")}: no argument "${name}"`);
+  const options = [];
+  const positionals = [];
+  let given;
+  for (const field of fields) {
+    const value = input[field.name];
+    if (value === void 0) {
+      if (field.required)
+        throw new CliError("validation_error", `${info.path.join(" ")}: "${field.name}" is required`);
+      continue;
+    }
+    if (field.stdin)
+      given = typeof value === "string" ? value : JSON.stringify(value);
+    for (const token of field.argv(value))
+      (field.positional ? positionals : options).push(token);
+  }
+  const argv = [profile, ...info.path, ...options, "--json", ...positionals.length > 0 ? ["--", ...positionals] : []];
+  return given === void 0 ? { argv } : { argv, stdin: given };
+}, "argvOf");
+var runCommandForAgent = /* @__PURE__ */ __name(async (program, path, input, ctx) => {
+  try {
+    const info = flatten(program.commands).find((one) => one.path.length === path.length && startsWith(one.path, path));
+    if (!info || info.commands.length > 0 && info.runnable !== true)
+      throw new CliError("validation_error", `no command "${path.join(" ")}" to run`);
+    if (info.lifetime)
+      throw new CliError("validation_error", `"${path.join(" ")}" runs until it is stopped; an agent call must return`);
+    const levels = ctx.levels?.();
+    const availability = (levels || ctx.readOnly || ctx.permissions) && commandAvailability(info, levels ?? {}, ctx.keyOf, ctx.authority, ctx.readOnly, true, ctx.permissions);
+    if (availability && !availability.available)
+      throw new CliError("permission_error", `${path.join(" ")}: ${availability.reason}`, {
+        sent: false,
+        ...availability.permission ? { permission: availability.permission } : {}
+      });
+    const { argv, stdin } = argvOf(info, input, ctx.profile, ctx.stdin);
+    const lend = ctx.connection;
+    let borrowed;
+    let answered2 = false;
+    let result;
+    let failure;
+    const streams = captureStreams();
+    const command = `mcp ${path.join(" ")}`;
+    const traceId = enclosingTraceId() ?? traceOf(ctx.env ?? {}).traceId;
+    const scope = {
+      runId: newRunId(/* @__PURE__ */ new Date(), command),
+      command,
+      startedAt: Date.now(),
+      profile: ctx.profile,
+      ...traceId === void 0 ? {} : { traceId }
+    };
+    const code = await inRun(scope, () => program.run(argv, {
+      ...ctx.environment,
+      streams,
+      tty: false,
+      ...ctx.env ? { env: ctx.env } : {},
+      stdin: Readable.from(stdin === void 0 ? [] : [stdin]),
+      answer: /* @__PURE__ */ __name(() => null, "answer"),
+      agent: {
+        result: /* @__PURE__ */ __name((value) => {
+          answered2 = true;
+          result = value;
+        }, "result"),
+        failure: /* @__PURE__ */ __name((object2) => {
+          failure = object2;
+        }, "failure"),
+        ...ctx.overrides?.length ? { overrides: ctx.overrides } : {},
+        authority: levels !== void 0 && authorityAllowed(levels),
+        botApi: levels !== void 0 && botApiAllowed(levels),
+        ...ctx.caller ?? currentCaller() ? { caller: ctx.caller ?? currentCaller() } : {}
+      },
+      // Opened only when the command asks: a read the store answers never connects.
+      ...lend ? {
+        relayed: {
+          profile: ctx.profile,
+          cwd: process.cwd(),
+          connection: /* @__PURE__ */ __name(() => borrowed ??= lend().then((adapter) => lentConnection(adapter)), "connection")
+        }
+      } : {}
+    }));
+    if (failure)
+      return { error: failure };
+    if (answered2)
+      return { result };
+    if (code !== 0)
+      throw new CliError("invalid_response", `the command exited with ${code} and said nothing`);
+    if (streams.stdout.length > 0)
+      throw new CliError("invalid_response", "the command printed its answer instead of handing it over \u2014 the CLI's run must pass its whole environment on");
+    return { result: null };
+  } catch (error) {
+    return { error: errorObjectOf(error) };
+  }
+}, "runCommandForAgent");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/mcp/tool.js
+var limit = optional(pipe(number(), integer(), minValue(1), maxValue(100), description("how many")));
+var page = optional(pipe(number(), integer(), minValue(1), description("which page, from 1")));
+var message = pipe(
+  string(),
+  maxLength(256),
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: refusing them is the point
+  regex(/^[^\s\x00-\x1F\x7F-\x9F]+$/, "a message id has no spaces or control characters"),
+  description("message id")
+);
+var READ = { readOnlyHint: true, destructiveHint: false, openWorldHint: true };
+var WRITE = {
+  readOnlyHint: false,
+  destructiveHint: true,
+  idempotentHint: false,
+  openWorldHint: true
+};
+var tool = /* @__PURE__ */ __name((definition) => definition, "tool");
+var chatOf = /* @__PURE__ */ __name((messenger) => pipe(string(), minLength(1), description(messenger.chatArgument)), "chatOf");
+var tierOf = /* @__PURE__ */ __name((key2, definition, messenger) => {
+  if (definition.annotations.readOnlyHint === true)
+    return "read";
+  if (/^admin|_admin/.test(key2))
+    return "admin";
+  if (/delete|ban|kick|remove|purge|block/.test(key2))
+    return "destructive";
+  if (/draft/.test(key2))
+    return "draft";
+  if (key2 === "messages_pin" && messenger?.quietPins === false)
+    return "write-public";
+  if (/mark_read|mark_unread|read_mark|archive|mute|pin|tag|note|label|folder|alias|save|_(un)?star$/.test(key2))
+    return "write-private";
+  return "write-public";
+}, "tierOf");
+var effectsOf = /* @__PURE__ */ __name((definition) => {
+  if (definition.effects)
+    return definition.effects;
+  const { readOnlyHint, openWorldHint } = definition.annotations;
+  if (readOnlyHint === true)
+    return { remote: openWorldHint === false ? "none" : "read", local: "read" };
+  return openWorldHint === false ? LOCAL_WRITE : REMOTE_WRITE;
+}, "effectsOf");
+var outcomeOf = /* @__PURE__ */ __name((result) => {
+  if (!result.isError)
+    return { status: "ok" };
+  const code = result.structuredContent?.error?.code;
+  const error = typeof code === "string" ? code : "generic_failure";
+  return { status: error === "permission_error" ? "refused" : "failed", error };
+}, "outcomeOf");
+var commandOf = /* @__PURE__ */ __name((name, definition) => definition.command ?? name.replaceAll("_", " "), "commandOf");
+var toolKey = /* @__PURE__ */ __name((name, definition) => definition.key !== void 0 ? definition.key : keyForCommand(commandOf(name, definition).split(" ")), "toolKey");
+var inputOf = /* @__PURE__ */ __name((definition, syncAllowed) => strictObject(syncAllowed || !("sync_first" in definition.input.entries) ? definition.input.entries : Object.fromEntries(Object.entries(definition.input.entries).filter(([name]) => !["sync_first", "sync_time", "max_chats", "max_messages"].includes(name)))), "inputOf");
+var syncAllowedFor = /* @__PURE__ */ __name((key2, defaults) => {
+  const permissions = defaults.settings.permissions ?? {};
+  const shared = defaults.syncAllowed ?? levelFor(permissions, "messages.sync-first").level === "allow";
+  return shared && (!key2.startsWith("stats_") || levelFor(permissions, `${key2.replaceAll("_", ".")}.sync-first`).level === "allow");
+}, "syncAllowedFor");
+var entryRunner = /* @__PURE__ */ __name((registration) => {
+  const run = callRunner(registration);
+  const { log } = registration;
+  return async (key2, definition, args, ctx) => {
+    const startedAt = Date.now();
+    const command = `mcp ${commandOf(key2, definition)}`;
+    const traceId = traceIdOf(ctx?.mcpReq?._meta?.traceparent);
+    const app = registration.messenger?.app;
+    const caller = registration.callers ? callerOf(ctx, key2, registration.callers) : currentCaller();
+    const env = registration.defaults.env ?? process.env;
+    const settings = registration.defaults.settings;
+    const recording = key2 !== "runs_search" && settings.keepFailedRuns !== false && app?.appName ? startRecording({
+      app,
+      command,
+      ...settings.profile === void 0 ? {} : { profile: settings.profile },
+      env,
+      record: keepsSuccess({ record: settings.record ?? true, fromFlag: false, env, caller }),
+      keepFailed: true,
+      trace: false,
+      format: "json",
+      context: runContextOf({ bin: app.command, command, env, caller }),
+      ...settings.keepRunsForDays === void 0 ? {} : { keepDays: settings.keepRunsForDays },
+      ...settings.keepSuccessfulRunsForDays === void 0 ? {} : { keepSuccessDays: settings.keepSuccessfulRunsForDays },
+      ...settings.runsSizeLimitMb === void 0 ? {} : { maxBytes: settings.runsSizeLimitMb * 1024 * 1024 },
+      ...traceId === void 0 ? {} : { traceId }
+    }) : void 0;
+    const profile = registration.defaults.settings.profile;
+    const scope = {
+      runId: recording?.runId ?? newRunId(new Date(startedAt), command),
+      command,
+      startedAt,
+      ...profile === void 0 ? {} : { profile },
+      ...traceId === void 0 ? {} : { traceId },
+      ...recording ? { events: recording.events } : {}
+    };
+    const work = /* @__PURE__ */ __name(() => inRun(scope, () => {
+      const input = inputOf(definition, syncAllowedFor(key2, registration.defaults));
+      const parsed = safeParse(input, args);
+      return parsed.success ? run(key2, definition, parsed.output, ctx) : failed(new CliError("validation_error", `${commandOf(key2, definition)}: ${summarize(parsed.issues)}`, {
+        arguments: toJsonSchema(input)
+      }), app?.errors);
+    }), "work");
+    const result = await (caller ? withCaller(caller, work) : work());
+    if (recording) {
+      if (result.isError) {
+        const error = result.structuredContent?.error;
+        const code = error?.code && errorCodes.includes(error.code) ? error.code : void 0;
+        await recording.fail(code ? new CliError(code, "MCP operation failed") : new Error("MCP operation failed")).catch(() => void 0);
+      } else
+        await recording.succeed(result.structuredContent).catch(() => void 0);
+    }
+    await log?.({
+      tool: key2,
+      tier: tierOf(key2, definition, registration.messenger),
+      ...outcomeOf(result),
+      startedAt,
+      finishedAt: Date.now()
+    })?.catch(() => void 0);
+    return result;
+  };
+}, "entryRunner");
+var callRunner = /* @__PURE__ */ __name(({ messenger, session, withStore, withServices, defaults, around, targets }) => {
+  const where = {
+    profile: defaults.settings.profile,
+    env: defaults.env,
+    pictures: defaults.settings.pictureSearch,
+    reranker: defaults.settings.searchReranker
+  };
+  return async (key2, definition, args, ctx) => {
+    const path = commandOf(key2, definition).split(" ");
+    const run = `mcp ${path.join(" ")}`;
+    try {
+      const execute = /* @__PURE__ */ __name(async () => {
+        const syncAllowed = syncAllowedFor(key2, defaults);
+        if (Buffer.byteLength(JSON.stringify(args)) > MAX_BUFFERED_INPUT)
+          throw new CliError("validation_error", "tool arguments exceed the buffered input limit", {
+            reason: "input.too-large",
+            max_bytes: MAX_BUFFERED_INPUT,
+            retryable: false
+          });
+        definition.check?.(args);
+        if (definition.changesStore)
+          refuseStoreChange(messenger.app, defaults.env);
+        refuseLacking(messenger, path);
+        for (const permission of readKeysForCommand(path)) {
+          if (levelFor(defaults.settings.permissions ?? {}, permission).level === "deny")
+            throw new CliError("permission_error", `profile denies ${permission}`, { permission });
+        }
+        if (args.sync_first && !syncAllowed)
+          throw new CliError("permission_error", "messages.sync-first is not allowed by this profile");
+        if (definition.custom) {
+          const result2 = await definition.custom(args, { ...defaults, signal: ctx.mcpReq.signal }, ctx);
+          return answered(result2, definition.outputLimit?.(args, defaults), targets);
+        }
+        if (definition.local)
+          return answered(await definition.local(args, defaults), definition.outputLimit?.(args, defaults), targets);
+        const { online, stored: local, served } = definition;
+        const stored = local && (!definition.storedWhen || definition.storedWhen(args)) ? local : void 0;
+        const result = stored ? await withStore((store, account) => stored(store, account, args, { ...defaults, signal: ctx.mcpReq.signal }, (work) => session.use(run, work)), {
+          name: run
+        }) : served && withServices ? await withServices((services, connect) => served(services, args, defaults, connect), { name: run }) : served && messenger.history === "store" ? await withStore((store, account) => served(servicesFor({
+          ...storeModeDeps(messenger, store, account, defaults.guard),
+          ...where,
+          embedders: defaults.embedders
+        }), args, defaults, (work) => session.use(run, async (adapter, release) => {
+          try {
+            return await work(adapter);
+          } finally {
+            await release();
+          }
+        })), { name: run }) : served ? await session.use(run, (adapter, release) => served(servicesFor(onlineDeps(messenger, adapter, defaults.guard, where)), args, defaults, (work) => (async () => {
+          try {
+            return await work(adapter);
+          } finally {
+            await release();
+          }
+        })())) : await session.use(run, (adapter, release) => online(adapter, args, { ...defaults, release }));
+        return answered(result, definition.outputLimit?.(args, defaults), targets);
+      }, "execute");
+      return around ? await around(key2, definition, execute) : await execute();
+    } catch (error) {
+      return failed(error, messenger?.app?.errors, effectsOf(definition));
+    }
+  };
+}, "callRunner");
+var outputSchemaOf = /* @__PURE__ */ __name((definition) => {
+  if (!definition.output)
+    return looseObject({});
+  const entity = ENTITIES[definition.output.entity];
+  return definition.output.list ? listEnvelopeSchema(entity) : itemEnvelopeSchema(entity);
+}, "outputSchemaOf");
+var Picture = class {
+  static {
+    __name(this, "Picture");
+  }
+  bytes;
+  mimeType;
+  about;
+  constructor(bytes, mimeType, about) {
+    this.bytes = bytes;
+    this.mimeType = mimeType;
+    this.about = about;
+  }
+};
+var BinaryResource = class {
+  static {
+    __name(this, "BinaryResource");
+  }
+  base64;
+  mimeType;
+  uri;
+  about;
+  constructor(base64, mimeType, uri, about) {
+    this.base64 = base64;
+    this.mimeType = mimeType;
+    this.uri = uri;
+    this.about = about;
+  }
+};
+var answered = /* @__PURE__ */ __name((answer, maxBytes = DEFAULT_OUTPUT_BYTES, targets) => {
+  const bounded = /* @__PURE__ */ __name((result) => {
+    if (maxBytes !== 0 && Buffer.byteLength(JSON.stringify(result)) > maxBytes)
+      throw new CliError("invalid_response", "tool output exceeds its byte limit \u2014 reduce limit or use a narrower request", { reason: "output.too-large", max_bytes: maxBytes, retryable: false });
+    return result;
+  }, "bounded");
+  if (answer === null || Array.isArray(answer) || typeof answer !== "object")
+    throw new CliError("invalid_response", "tool result must be an object", { retryable: false });
+  const objectBody = /* @__PURE__ */ __name((value) => {
+    const serialized = JSON.parse(agentJson(value));
+    if (serialized === null || Array.isArray(serialized) || typeof serialized !== "object")
+      throw new CliError("invalid_response", "serialized tool result must be an object", { retryable: false });
+    return serialized;
+  }, "objectBody");
+  if (answer instanceof BinaryResource) {
+    const about = sealed(answer.about);
+    return bounded({
+      structuredContent: objectBody(about),
+      content: [
+        { type: "resource", resource: { uri: answer.uri, mimeType: answer.mimeType, blob: answer.base64 } },
+        { type: "text", text: agentJson(about) }
+      ]
+    });
+  }
+  if (answer instanceof Picture) {
+    const about = sealed(answer.about);
+    return bounded({
+      structuredContent: objectBody(about),
+      content: [
+        { type: "image", data: Buffer.from(answer.bytes).toString("base64"), mimeType: answer.mimeType },
+        { type: "text", text: agentJson(about) }
+      ]
+    });
+  }
+  const body = objectBody(sealed(targets ? judgedAnswer(answer, targets) : answer));
+  return bounded({ content: [{ type: "text", text: JSON.stringify(body) }], structuredContent: body });
+}, "answered");
+var failed = /* @__PURE__ */ __name((error, errors, effects) => {
+  const judged = judgedEffects(effects);
+  const context = { ...failureContext(errors), ...judged ? { effects: judged } : {} };
+  return mcpErrorResult(JSON.parse(agentJson(errorObjectOf(error, context))));
+}, "failed");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/mcp/surface.js
+import { randomUUID } from "node:crypto";
+var MATCHES = 8;
+var ANSWER = answerSchema();
+var normal = /* @__PURE__ */ __name((command) => command.trim().toLowerCase().split(/[\s_-]+/).join(" "), "normal");
+var haystack = /* @__PURE__ */ __name((command, one) => [command, one.title, one.description, ...Object.keys(one.input.entries)].join(" ").toLowerCase(), "haystack");
+var search = /* @__PURE__ */ __name((commands, query) => {
+  const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+  return Object.entries(commands).filter(([command, one]) => words.every((word2) => haystack(command, one).includes(word2))).map((entry) => {
+    const parts = entry[0].split(/[\s-]/);
+    const exact = entry[0] === words.join(" ") ? 100 : 0;
+    const whole = words.filter((word2) => parts.includes(word2)).length * 10;
+    return { entry, rank: exact + whole + words.filter((word2) => entry[0].includes(word2)).length };
+  }).sort((a, b) => b.rank - a.rank || a.entry[0].localeCompare(b.entry[0])).map(({ entry }) => entry);
+}, "search");
+var nearest = /* @__PURE__ */ __name((commands, asked) => {
+  const words = normal(asked).split(" ");
+  return Object.keys(commands).map((one) => ({ one, shared: words.filter((word2) => normal(one).split(" ").includes(word2)).length })).filter(({ shared }) => shared > 0).sort((a, b) => b.shared - a.shared).slice(0, 3).map(({ one }) => one);
+}, "nearest");
+var runnableOnly = /* @__PURE__ */ __name((result, offered) => {
+  const body = result.structuredContent;
+  if (result.isError || !Array.isArray(body?.next))
+    return result;
+  const next = body.next.filter((step) => offered(step.command));
+  const { next: _, ...rest } = body;
+  const kept = next.length > 0 ? { ...rest, next } : rest;
+  return {
+    ...result,
+    structuredContent: kept,
+    content: result.content.map((part) => part.type === "text" ? { ...part, text: JSON.stringify(kept) } : part)
+  };
+}, "runnableOnly");
+var takesNothing = /* @__PURE__ */ __name((one) => Object.values(one.input.entries).every((entry) => entry.type === "optional"), "takesNothing");
+var sampleOf = /* @__PURE__ */ __name((commands) => {
+  const reading = Object.entries(commands).filter(([, one]) => !one.writes);
+  const bare = reading.filter(([, one]) => takesNothing(one));
+  return bare.find(([command]) => command.endsWith(" list"))?.[0] ?? bare[0]?.[0] ?? reading[0]?.[0] ?? Object.keys(commands)[0] ?? "";
+}, "sampleOf");
+var registerCommands = /* @__PURE__ */ __name((server, prefix, commands, errors, withheld, isMessenger) => {
+  const byNormal = new Map(Object.keys(commands).map((command) => [normal(command), command]));
+  const messenger = isMessenger ?? Object.keys(commands).some((command) => command.split(" ")[0] === "messages");
+  const tasks = messenger ? '"unread", "send message", "chat members"' : '"list", "show", "change a setting"';
+  const sample = messenger ? "messages list" : sampleOf(commands);
+  const untrusted = messenger ? UNTRUSTED : UNTRUSTED_NEUTRAL;
+  server.registerTool(`${prefix}_tools_search`, {
+    outputSchema: toStandardJsonSchema(looseObject({})),
+    title: "Find a command",
+    description: `Find the command for a task \u2014 ${tasks} \u2014 before calling ${prefix}_read or ${prefix}_write with it. Each match gives its command, whether it writes, its arguments and the shape of its answer. With no words, lists every command and title, without arguments.`,
+    inputSchema: toStandardJsonSchema(strictObject({ query: optional(pipe(string(), description("words that describe the task"))) })),
+    annotations: { ...READ, openWorldHint: false, idempotentHint: true }
+  }, async ({ query }) => {
+    const found = search(commands, query ?? "");
+    const items = query?.trim() ? found.slice(0, MATCHES).map(([command, one]) => ({
+      command,
+      title: one.title,
+      description: one.description,
+      writes: one.writes,
+      availability: one.availability?.() ?? { available: true },
+      arguments: toJsonSchema(one.input),
+      output: toJsonSchema(one.output ?? ANSWER)
+    })) : found.map(([command, one]) => ({
+      command,
+      title: one.title,
+      writes: one.writes,
+      availability: one.availability?.() ?? { available: true }
+    }));
+    const { next: _paging, ...list } = listOf(`${prefix}_tools_search`, {
+      items,
+      limit: Math.max(items.length, query?.trim() ? MATCHES : 1),
+      has_more: found.length > items.length
+    });
+    return answered(list);
+  });
+  const callers = {
+    env: process.env,
+    client: /* @__PURE__ */ __name(() => server.server.getClientVersion(), "client"),
+    connectionId: randomUUID()
+  };
+  const runner = /* @__PURE__ */ __name((writing) => async ({ command: asked, arguments: given }, ctx) => {
+    try {
+      const command = byNormal.get(normal(asked));
+      const one = command === void 0 ? void 0 : commands[command];
+      if (command === void 0 || !one) {
+        withheld?.(normal(asked));
+        const near = nearest(commands, asked);
+        throw new CliError("validation_error", `no command "${asked}" here${near.length ? ` \u2014 did you mean ${near.map((name) => `"${name}"`).join(", ")}?` : ""}; ${prefix}_tools_search finds one`);
+      }
+      if (one.writes !== writing)
+        throw new CliError("validation_error", `"${command}" ${writing ? "only reads" : "writes"}: call it with ${prefix}_${writing ? "read" : "write"}`);
+      const args = writing ? agentArguments(given ?? {}) : given ?? {};
+      const caller = currentCaller() ?? callerOf(ctx, command.replace(/[ -]/g, "_"), callers);
+      if (one.checked)
+        return runnableOnly(await withCaller(caller, () => one.run(args, ctx)), (named) => byNormal.has(normal(named)));
+      const parsed = safeParse(strictObject(one.input.entries), args);
+      if (!parsed.success)
+        throw new CliError("validation_error", `${command}: ${summarize(parsed.issues)}`, {
+          arguments: toJsonSchema(one.input)
+        });
+      return runnableOnly(await withCaller(caller, () => one.run(parsed.output, ctx)), (named) => byNormal.has(normal(named)));
+    } catch (error) {
+      return failed(error, errors);
+    }
+  }, "runner");
+  const call = strictObject({
+    command: pipe(string(), minLength(1), description(`a command ${prefix}_tools_search returned: "${sample}"`)),
+    arguments: optional(pipe(record(string(), unknown()), description("that command's arguments")))
+  });
+  server.registerTool(`${prefix}_read`, {
+    outputSchema: toStandardJsonSchema(ANSWER),
+    title: "Run a reading command",
+    description: `Run one command that only reads, with the arguments ${prefix}_tools_search showed. ${untrusted}`,
+    inputSchema: toStandardJsonSchema(call),
+    annotations: READ
+  }, runner(false));
+  if (Object.values(commands).some((one) => one.writes))
+    server.registerTool(`${prefix}_write`, {
+      outputSchema: toStandardJsonSchema(ANSWER),
+      title: "Run a writing command",
+      description: `Run one command that changes something \u2014 ${messenger ? "sends, edits, deletes, joins" : "creates, edits, deletes"} \u2014 with the arguments ${prefix}_tools_search showed. ${untrusted}`,
+      inputSchema: toStandardJsonSchema(call),
+      annotations: WRITE
+    }, runner(true));
+}, "registerCommands");
+var surfaceCommands = /* @__PURE__ */ __name((tools, registration) => {
+  const run = entryRunner(registration);
+  return Object.fromEntries(Object.entries(tools).map(([key2, definition]) => [
+    commandOf(key2, definition),
+    {
+      title: definition.title,
+      description: definition.description,
+      writes: definition.annotations.readOnlyHint !== true,
+      input: inputOf(definition, syncAllowedFor(key2, registration.defaults)),
+      ...definition.output ? { output: outputSchemaOf(definition) } : {},
+      checked: true,
+      run: /* @__PURE__ */ __name((args, ctx) => run(key2, definition, args, ctx), "run")
+    }
+  ]));
+}, "surfaceCommands");
+var outputOf = /* @__PURE__ */ __name(({ entity, view }) => answerSchema(ENTITIES[view ? `${entity}.${view}` : entity] ?? unknown()), "outputOf");
+
+export {
+  toolsFromCommands,
+  runCommandForAgent,
+  message,
+  READ,
+  WRITE,
+  tool,
+  chatOf,
+  tierOf,
+  outcomeOf,
+  commandOf,
+  toolKey,
+  Picture,
+  BinaryResource,
+  answered,
+  failed,
+  normal,
+  registerCommands,
+  surfaceCommands,
+  outputOf
+};