@wirecat/zoom-cli 0.55.0 → 0.57.0

package/dist/bundle/chunk-G4R4ZIGD.js

@@ -0,0 +1,3569 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  recordLogFor,
+  storeTable
+} from "./chunk-MAEFLDHG.js";
+import {
+  envName
+} from "./chunk-OCGPZHXW.js";
+import {
+  carries
+} from "./chunk-PIN5RZ3D.js";
+import {
+  WEIGHTS,
+  agenda,
+  attachment,
+  childTrace,
+  closeSuggestion,
+  conversation,
+  tagging,
+  task
+} from "./chunk-EOQFWJJD.js";
+import {
+  author,
+  count,
+  id,
+  note,
+  organization,
+  project,
+  providerMetadata,
+  reminder,
+  text,
+  time,
+  untrusted
+} from "./chunk-YB4DMKYX.js";
+import {
+  FACT_STATUSES,
+  FACT_TYPES,
+  LINK_KINDS,
+  LINK_SOURCES,
+  MEMORY_KINDS,
+  MEMORY_SCOPES,
+  MEMORY_STATUSES,
+  RELATION_KINDS,
+  TASK_KINDS,
+  TASK_ORIGINS,
+  TASK_STATES,
+  TASK_TYPES,
+  TASK_VERDICTS,
+  WORK_TASK_TYPES
+} from "./chunk-6M6FJV5D.js";
+import {
+  MEETING_RESULT_ENTITIES,
+  event,
+  meeting,
+  meetingDetails,
+  meetingHit,
+  meetingLink,
+  meetingParticipants,
+  meetingPassage,
+  meetingProjectEvidence,
+  meetingReview,
+  meetingSpeaker,
+  meetingStats,
+  meetingSummary,
+  meetingTranscript
+} from "./chunk-LXB6ONWC.js";
+import {
+  CliError,
+  array,
+  boolean,
+  integer,
+  isoDate,
+  isoTime,
+  jsonSchemaOf,
+  literal,
+  maxLength,
+  minLength,
+  minValue,
+  null_,
+  nullable,
+  number,
+  objectWithRest,
+  omit,
+  optional,
+  pageSchema,
+  partial,
+  pick,
+  picklist,
+  pipe,
+  record,
+  reference,
+  regex,
+  resolvePaths,
+  safeInteger,
+  strictObject,
+  string,
+  union,
+  unknown,
+  unwrap,
+  variant,
+  writeSecurely
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/member.js
+var member = strictObject({
+  id,
+  name: nullable(text),
+  username: nullable(text),
+  role: optional(picklist(["owner", "admin", "member"])),
+  /** `null` when their privacy hides it. */
+  last_seen_at: optional(nullable(time)),
+  registered_at: optional(nullable(time)),
+  joined_at: optional(nullable(time)),
+  /** Who added them or whose invite they used. */
+  invited_by: optional(nullable(id)),
+  is_bot: optional(boolean()),
+  deleted: optional(boolean()),
+  flagged: optional(picklist(["scam", "fake"])),
+  has_photo: optional(boolean()),
+  /** `chats members check`: how much they look like a bot — a hint, never a verdict. */
+  score: optional(count),
+  reasons: optional(array(text)),
+  /** `chats members check --deep`: the whole person check, as `contacts check` answers it. */
+  check: optional(record(string(), unknown()))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/chat.js
+var setting = optional(nullable(boolean()));
+var chat = strictObject({
+  ref: reference,
+  id,
+  provider: optional(text),
+  account: optional(text),
+  title: nullable(text),
+  kind: picklist(["dialog", "group", "channel", "saved", "unknown"]),
+  unread_count: nullable(count),
+  unread_mentions: optional(count),
+  last_message_at: nullable(time),
+  participants_count: nullable(count),
+  muted: optional(boolean()),
+  /** When the mute ends; absent with `muted` true is for good. */
+  muted_until: optional(time),
+  archived: optional(boolean()),
+  /** The owner marked it unread, whatever `unread_count` says. */
+  marked_unread: optional(boolean()),
+  membership_state: optional(picklist(["joined", "left", "public", "imported", "archived", "external"])),
+  parent_chat_id: optional(id),
+  scope: optional(picklist(["personal", "work"])),
+  provider_metadata: providerMetadata,
+  /** `chats show`, a group or channel: what it says about itself. */
+  description: optional(nullable(text)),
+  invite_link: optional(nullable(text)),
+  settings: optional(strictObject({
+    all_can_pin: setting,
+    only_admins_add: setting,
+    only_admins_call: setting,
+    only_owner_edits_info: setting,
+    members_see_link: setting,
+    join_approval: setting,
+    only_admins_send: setting,
+    only_admins_edit_info: setting,
+    disappearing_seconds: optional(nullable(count))
+  })),
+  /** `chats show`: absent when no roster is known; an empty list is a known empty roster. */
+  members: optional(array(member))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/list-results.js
+var botProfile = strictObject({
+  name: text,
+  token: text,
+  bot: optional(text),
+  id: optional(id),
+  problem: optional(text)
+});
+var botSeenChat = strictObject({
+  ...partial(omit(chat, ["ref", "provider", "account", "description", "invite_link", "settings", "members"])).entries,
+  id,
+  parent_chat_id: optional(nullable(id)),
+  muted_until: optional(nullable(time)),
+  first_seen_at: optional(time),
+  last_seen_at: optional(time)
+});
+var botAdmin = strictObject({
+  id,
+  name: nullable(text),
+  username: nullable(text),
+  role: picklist(["owner", "admin"]),
+  rights: array(picklist(["read", "members", "admins", "info", "pin", "link", "post", "edit", "delete"])),
+  title: nullable(text)
+});
+var botMenuEntry = strictObject({ name: text, description: nullable(text) });
+var botWebhook = strictObject({ url: text, types: optional(array(text)) });
+var scheduledJob = strictObject({
+  name: text,
+  kind: picklist(["command", "agent"]),
+  when: text,
+  last: nullable(strictObject({
+    at: time,
+    exit_code: number(),
+    output: text,
+    trace_id: optional(text),
+    reason: optional(text),
+    error_code: optional(text),
+    failing_since: optional(time),
+    failures: optional(number())
+  }))
+});
+var botTemplate = strictObject({
+  name: nullable(text),
+  status: nullable(text),
+  language: nullable(text),
+  category: nullable(text)
+});
+var callRecord = strictObject({
+  id,
+  chat_id: nullable(id),
+  caller_id: nullable(id),
+  direction: picklist(["incoming", "outgoing"]),
+  outcome: picklist(["answered", "missed", "declined"]),
+  kind: picklist(["audio", "video"]),
+  at: time,
+  duration_seconds: nullable(number())
+});
+var stickerInventory = strictObject({
+  id,
+  title: optional(text),
+  count: optional(number()),
+  link: optional(nullable(text)),
+  set_id: optional(nullable(id)),
+  emoji: optional(array(text)),
+  url: optional(nullable(text))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/batch-result.js
+var actionableError = objectWithRest({
+  code: text,
+  message: text,
+  retryable: boolean(),
+  retry_after_ms: optional(number())
+}, unknown());
+var batchResult = strictObject({
+  attempted: count,
+  succeeded: count,
+  failed: count,
+  error_rate: number(),
+  failures: array(strictObject({ id, stage: text, error: actionableError, attachment: optional(count) })),
+  stop_reason: optional(picklist(["rate_limited", "authentication", "error_rate", "cancelled"])),
+  max_error_percent: count
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/conversation-preparation.js
+var conversationBuild = strictObject({
+  chat: id,
+  messages: count,
+  links: count,
+  conversations: count,
+  built_at: time,
+  rules_version: count
+});
+var chatEmbedding = strictObject({ chat: id, model: text, embedded: count, skipped: count });
+var conversationPreparation = strictObject({
+  model: text,
+  model_available: boolean(),
+  built: array(conversationBuild),
+  embedded: array(chatEmbedding),
+  left: array(strictObject({ chat: id, needs: picklist(["build", "embed"]) })),
+  /** Messages given their own vector, which `search messages --discover` reads, and how many still lack one. */
+  messages: optional(strictObject({ embedded: count, left: count }))
+});
+var catchUpPreparation = strictObject({
+  complete: boolean(),
+  reason: optional(picklist(["message_bound", "time_or_abort_bound", "preparation_failed", "pending"])),
+  prepared: optional(conversationPreparation)
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/services/backfill-jobs.js
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { closeSync, existsSync as existsSync2, mkdirSync, openSync, readdirSync, readFileSync as readFileSync2, realpathSync, rmSync as rmSync2 } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/background/checkpoints.js
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+var PART = /^[\w@+-][\w.@+-]{0,99}$/;
+var checkpointPath = /* @__PURE__ */ __name((state, profile, job2) => {
+  for (const part of [profile, job2]) {
+    if (!PART.test(part) || part.includes("..")) {
+      throw new CliError("validation_error", `a checkpoint is named by letters, digits, ".", "@" and "-" \u2014 not "${part}"`);
+    }
+  }
+  return join(state, "checkpoints", profile, `${job2}.json`);
+}, "checkpointPath");
+var readCheckpoint = /* @__PURE__ */ __name((path) => {
+  try {
+    return existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : void 0;
+  } catch {
+    return void 0;
+  }
+}, "readCheckpoint");
+var saveCheckpoint = /* @__PURE__ */ __name((path, point, now = /* @__PURE__ */ new Date()) => {
+  const saved = { ...point, updated_at: now.toISOString() };
+  writeSecurely(path, `${JSON.stringify(saved, null, 2)}
+`, 384);
+  return saved;
+}, "saveCheckpoint");
+var progressOf = /* @__PURE__ */ __name((input) => {
+  const total = input.total ?? null;
+  const updated = input.updatedAt ?? null;
+  return {
+    job: input.job,
+    profile: input.profile,
+    done: input.done,
+    total,
+    remaining: total === null ? null : Math.max(0, total - input.done),
+    state: input.complete ?? (total !== null && input.done >= total) ? "complete" : "partial",
+    updated_at: updated,
+    cursor_age_ms: updated === null ? null : Math.max(0, (input.now ?? /* @__PURE__ */ new Date()).getTime() - Date.parse(updated))
+  };
+}, "progressOf");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/services/backfill-jobs.js
+var JOB_STATES = ["running", "done", "partial", "failed", "cancelled", "died"];
+var spawnDetached = /* @__PURE__ */ __name((argv, env, log) => {
+  const out = openSync(log, "a", 384);
+  try {
+    const child = spawn(process.execPath, [realpathSync(process.argv[1] ?? ""), ...argv], {
+      detached: true,
+      stdio: ["ignore", out, out],
+      env
+    });
+    child.unref();
+    return child.pid ?? 0;
+  } finally {
+    closeSync(out);
+  }
+}, "spawnDetached");
+var jobsDir = /* @__PURE__ */ __name((app, env) => join2(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "backfill"), "jobsDir");
+var jobPath = /* @__PURE__ */ __name((dir, id6) => join2(dir, `${id6}.json`), "jobPath");
+var saveJob = /* @__PURE__ */ __name((dir, job2) => {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  writeSecurely(jobPath(dir, job2.id), `${JSON.stringify(job2, null, 2)}
+`, 384);
+}, "saveJob");
+var readJob = /* @__PURE__ */ __name((dir, id6) => {
+  if (!/^[\w-]+$/.test(id6) || !existsSync2(jobPath(dir, id6)))
+    return void 0;
+  try {
+    return JSON.parse(readFileSync2(jobPath(dir, id6), "utf8"));
+  } catch {
+    return void 0;
+  }
+}, "readJob");
+var recordsPath = /* @__PURE__ */ __name((dir, id6) => join2(dir, `${id6}.jsonl`), "recordsPath");
+var tracedJob = /* @__PURE__ */ __name((env) => {
+  const trace = childTrace();
+  return { env: { ...env, TRACEPARENT: trace.traceparent }, traceId: trace.traceId };
+}, "tracedJob");
+var jobStarted = /* @__PURE__ */ __name((app, dir, job2) => {
+  saveJob(dir, job2);
+  recordLogFor(recordsPath(dir, job2.id), app, job2.traceId ? { traceId: job2.traceId } : {}).info({
+    event: "job.start",
+    job: job2.id,
+    pid: job2.pid
+  });
+}, "jobStarted");
+var finishJob = /* @__PURE__ */ __name((app, dir, id6, change) => {
+  updateJob(dir, id6, change);
+  const job2 = readJob(dir, id6);
+  if (!job2)
+    return;
+  const outcome2 = stateOf(job2);
+  recordLogFor(recordsPath(dir, id6), app, job2.traceId ? { traceId: job2.traceId } : {})[job2.error ? "error" : "info"]({
+    event: "job.exit",
+    job: id6,
+    outcome: outcome2,
+    ...job2.error ? { errorCode: job2.error.code } : {}
+  });
+}, "finishJob");
+var updateJob = /* @__PURE__ */ __name((dir, id6, change) => {
+  const job2 = readJob(dir, id6);
+  if (job2)
+    saveJob(dir, { ...job2, ...change });
+}, "updateJob");
+var removeJob = /* @__PURE__ */ __name((dir, job2) => {
+  rmSync2(jobPath(dir, job2.id), { force: true });
+  rmSync2(recordsPath(dir, job2.id), { force: true });
+  if (dirname(job2.log) === dir)
+    rmSync2(job2.log, { force: true });
+}, "removeJob");
+var listJobs = /* @__PURE__ */ __name((dir) => existsSync2(dir) ? readdirSync(dir).filter((name) => name.endsWith(".json")).flatMap((name) => readJob(dir, name.slice(0, -".json".length)) ?? []).sort((a, b) => b.startedAt.localeCompare(a.startedAt)) : [], "listJobs");
+var jobDetails = /* @__PURE__ */ __name((job2) => ({
+  job: job2.id,
+  profile: job2.profile,
+  chat: job2.chat,
+  state: stateOf(job2),
+  pid: job2.pid,
+  startedAt: job2.startedAt,
+  ...job2.finishedAt ? { finishedAt: job2.finishedAt } : {},
+  fetched: Number(job2.result?.fetched ?? job2.progress?.fetched ?? 0),
+  ...job2.limit === void 0 ? {} : { messageLimit: job2.limit },
+  ...job2.pageSize === void 0 ? {} : { pageSize: job2.pageSize },
+  ...job2.last === void 0 ? {} : { last: job2.last },
+  ...job2.result ? {
+    complete: job2.result.complete === true,
+    ...job2.result.issue ? { issue: job2.result.issue } : {},
+    ...job2.result.batch ? { batch: job2.result.batch } : {},
+    ...job2.result.resume ? { resume: job2.result.resume } : {}
+  } : {},
+  ...job2.error ? { error: job2.error } : {},
+  progress: progressOf({
+    job: job2.id,
+    profile: job2.profile,
+    done: Number(job2.result?.fetched ?? job2.progress?.fetched ?? 0),
+    ...job2.limit === void 0 ? {} : { total: job2.limit },
+    complete: job2.result?.complete === true,
+    ...job2.progress?.at ?? job2.finishedAt ? { updatedAt: job2.progress?.at ?? job2.finishedAt } : {}
+  })
+}), "jobDetails");
+var jobItem = /* @__PURE__ */ __name((job2) => {
+  const issue = job2.result?.issue;
+  return {
+    id: job2.id,
+    chat: job2.chat,
+    state: stateOf(job2),
+    pid: job2.pid,
+    started_at: job2.startedAt,
+    ...job2.finishedAt ? { finished_at: job2.finishedAt } : {},
+    fetched: Number(job2.result?.fetched ?? job2.progress?.fetched ?? 0),
+    ...job2.limit === void 0 ? {} : { message_limit: job2.limit },
+    ...job2.pageSize === void 0 ? {} : { page_size: job2.pageSize },
+    ...job2.last === void 0 ? {} : { last: job2.last },
+    ...job2.result ? { complete: job2.result.complete === true } : {},
+    ...issue ? { issue: { code: String(issue.code), message: String(issue.message) } } : {},
+    ...job2.error ? { error: { code: job2.error.code, message: job2.error.message } } : {}
+  };
+}, "jobItem");
+var stateOf = /* @__PURE__ */ __name((job2) => {
+  if (job2.finishedAt !== void 0) {
+    if (job2.cancelRequestedAt)
+      return "cancelled";
+    return job2.error ? "failed" : job2.result?.batch || job2.result?.issue ? "partial" : "done";
+  }
+  if (isJob(job2))
+    return "running";
+  return job2.cancelRequestedAt ? "cancelled" : "died";
+}, "stateOf");
+var isJob = /* @__PURE__ */ __name((job2) => carries(job2.pid, `_BACKFILL_JOB=${job2.id}`), "isJob");
+var startArchiveJob = /* @__PURE__ */ __name((app, env, profile, input, spawnJob = spawnDetached) => {
+  const dir = jobsDir(app, env);
+  const running = listJobs(dir).find((job3) => job3.profile === profile && job3.chat === input.chat && stateOf(job3) === "running");
+  if (running)
+    throw new CliError("validation_error", `job ${running.id} already works on this chat; inspect store jobs show first`);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const id6 = `${startedAt.replace(/[-:]/g, "").slice(0, 15)}-${randomBytes(3).toString("hex")}`;
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const log = join2(dir, `${id6}.log`);
+  const job2 = {
+    id: id6,
+    chat: input.chat,
+    profile,
+    pid: 0,
+    startedAt,
+    limit: input.limit,
+    pageSize: input.pageSize,
+    argv: input.argv,
+    log
+  };
+  saveJob(dir, job2);
+  const { [envName(app, "TIMEOUT")]: _timeout, ...inherited } = env;
+  const traced = tracedJob({ ...inherited, [envName(app, "PROFILE")]: profile, [envName(app, "BACKFILL_JOB")]: id6 });
+  const pid = spawnJob(input.argv, traced.env, log);
+  jobStarted(app, dir, { ...job2, pid, traceId: traced.traceId });
+  return { job: id6, pid, chat: input.chat, log };
+}, "startArchiveJob");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/job.js
+var problem = strictObject({ code: text, message: text });
+var job = strictObject({
+  id,
+  /** The chat as the sync was given it. */
+  chat: text,
+  state: picklist(JOB_STATES),
+  pid: count,
+  started_at: time,
+  finished_at: optional(time),
+  /** Messages fetched so far, or in all once it finished. */
+  fetched: count,
+  /** The `--limit` the sync was started with: how many messages it may fetch. */
+  message_limit: optional(count),
+  page_size: optional(count),
+  last: optional(count),
+  /** Whether the sync reached its window; set once it finished. */
+  complete: optional(boolean()),
+  /** Why a partial job stopped short; `store jobs retry` resumes it. */
+  issue: optional(problem),
+  error: optional(problem)
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/message.js
+var quoted = strictObject({
+  id,
+  sender_id: nullable(id),
+  sender_name: nullable(text),
+  timestamp: nullable(time),
+  text,
+  attachments: array(attachment),
+  outgoing: nullable(boolean())
+});
+var mailPerson = strictObject({ name: nullable(text), address: text, ref: nullable(reference) });
+var message = strictObject({
+  /** The message's locator. */
+  ref: reference,
+  id,
+  provider: optional(text),
+  account: optional(text),
+  chat_id: id,
+  chat_title: optional(nullable(text)),
+  sender_id: nullable(id),
+  sender_name: nullable(text),
+  sender_username: optional(text),
+  sender_is_chat: optional(boolean()),
+  mentions: optional(array(id)),
+  /** When it was sent. */
+  timestamp: time,
+  edited_at: nullable(time),
+  text,
+  /** What a voice message says, once heard. */
+  transcript: optional(text),
+  /** In a window of messages around one, the one asked for. */
+  anchor: optional(boolean()),
+  /** A stretch of the text, transcript, file name or file text around what a search matched. */
+  excerpt: optional(text),
+  /** `picture`: the picture search lane found it by what the picture shows; it follows the text hits. */
+  matched_in: optional(picklist(["text", "transcript", "filename", "file", "context", "picture"])),
+  score: optional(number()),
+  /**
+   * `corrected`: a query word matched only a spelling speech recognition garbled in a voice note's transcript,
+   * listed in `corrections`. `words` and `beginnings`: what a discovery search matched.
+   */
+  match: optional(picklist(["words", "beginnings", "corrected"])),
+  corrections: optional(array(strictObject({ from: text, to: array(text) }))),
+  /** Where a search found it: the local archive, the messenger's server, or both. */
+  found_in: optional(picklist(["archive", "server", "both"])),
+  /** A discovery search's partial match: how much of the question it covers, and which words it lacks. */
+  discovery: optional(strictObject({
+    coverage: number(),
+    matched_terms: array(text),
+    missing_terms: array(text),
+    parent: optional(reference),
+    /** Present when meaning was searched too: which of the two lists found it. */
+    found_by: optional(array(picklist(["words", "meaning"]))),
+    /** Present when the reranker read it: its own score, higher is better. It ordered the first hits with `score`. */
+    reranker_score: optional(number())
+  })),
+  /** The messages around a search hit, or its thread, oldest first; the hit itself is among them. */
+  context: optional(array(strictObject({ ref: reference, timestamp: time, sender_name: nullable(text), text }))),
+  outgoing: nullable(boolean()),
+  attachments: array(attachment),
+  reply_to: nullable(quoted),
+  /** The id a reply answers, also when the provider sent no copy of that message. */
+  reply_to_id: optional(id),
+  forwarded_from: nullable(quoted),
+  thread_id: optional(id),
+  thread_root_id: optional(id),
+  reactions: optional(nullable(strictObject({
+    counts: array(strictObject({ reaction: text, count })),
+    mine: nullable(text),
+    total: count
+  }))),
+  scheduled_for: optional(time),
+  /** The owner starred it; only where the messenger has stars, and only when set. */
+  starred: optional(literal(true)),
+  /** The owner's own message in a one-to-one chat: `delivered`, or `read` once opened; absent when no receipt came. */
+  delivery: optional(picklist(["delivered", "read"])),
+  email: optional(strictObject({
+    subject: nullable(text),
+    from: nullable(mailPerson),
+    to: array(mailPerson),
+    cc: array(mailPerson),
+    bcc: array(mailPerson),
+    /** The mail header Reply-To; `reply_to` is the quoted message a chat reply answers. */
+    reply_addresses: array(mailPerson),
+    labels: array(text),
+    /** The thread as a `chat:` reference. */
+    thread: reference,
+    read: nullable(boolean()),
+    flagged: nullable(boolean()),
+    /** How much the sender's mail looks like spam, a scam or a robot (memo's score), and why; absent when unscored. */
+    sender_score: optional(strictObject({ score: number(), signals: array(text), demoted: optional(literal(true)) }))
+  })),
+  provider_metadata: providerMetadata
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/extraction-report.js
+var extractionItem = strictObject({
+  ref: reference,
+  attachment: count,
+  kind: text,
+  name: nullable(text),
+  status: picklist(["extracted", "needs-agent", "unreadable", "engine-missing", "too-large", "missing"]),
+  extractor: optional(text),
+  chars: optional(count),
+  local_path: optional(text),
+  pages: optional(count),
+  ocr_pages: optional(count),
+  error: optional(text),
+  issue: optional(actionableError)
+});
+var extractionSummary = strictObject({
+  extracted: count,
+  failed: count,
+  needs_agent: count,
+  complete: boolean(),
+  batch: optional(batchResult)
+});
+var extractionReport = strictObject({
+  ...extractionSummary.entries,
+  items: array(extractionItem),
+  unchanged: count,
+  not_downloaded: count,
+  unsupported: count,
+  /** Reader package names, such as unpdf or @napi-rs/canvas. */
+  engines_missing: array(text),
+  cursor: optional(text)
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/message-transfer.js
+var savedMessageFile = strictObject({
+  kind: text,
+  path: text,
+  bytes: count,
+  existing: optional(literal(true))
+});
+var files = array(savedMessageFile);
+var messageDownload = union([
+  strictObject({
+    files,
+    extraction: optional(extractionReport),
+    complete: optional(literal(false)),
+    batch: optional(batchResult)
+  }),
+  strictObject({
+    files,
+    chat: nullable(id),
+    saved: count,
+    existing: count,
+    complete: boolean(),
+    batch: optional(batchResult),
+    stopped: optional(literal(true)),
+    extraction: optional(extractionSummary)
+  })
+]);
+var historyRange = strictObject({ from: number(), to: number() });
+var messageSyncEstimate = strictObject({
+  chat: id,
+  held: count,
+  ranges: array(historyRange),
+  missing: nullable(count),
+  requests: nullable(count),
+  runs: nullable(count),
+  seconds: nullable(count)
+});
+var tasks = optional(strictObject({
+  added: count,
+  closed: count,
+  review: count,
+  held: optional(count),
+  held_chats: optional(count)
+}));
+var messageSyncChat = strictObject({
+  issue: optional(actionableError),
+  resume: optional(strictObject({ before: optional(text) })),
+  prepared: optional(catchUpPreparation),
+  window_complete: optional(boolean()),
+  requests: optional(count),
+  chat: nullable(id),
+  fetched: count,
+  complete: boolean(),
+  ranges: array(historyRange),
+  reached_since: optional(literal(true)),
+  reached_last: optional(literal(true)),
+  stopped: optional(literal(true)),
+  tasks
+});
+var messageSyncAll = strictObject({
+  batch: optional(batchResult),
+  chats: count,
+  fetched: count,
+  complete: boolean(),
+  stopped: optional(literal(true)),
+  items: array(strictObject({
+    chat: id,
+    title: nullable(text),
+    fetched: count,
+    complete: boolean(),
+    current: optional(literal(true)),
+    stopped: optional(literal(true)),
+    error: optional(text),
+    issue: optional(actionableError)
+  })),
+  tasks
+});
+var messageSyncStarted = strictObject({ job: id, pid: count, chat: text, log: text });
+var messageSync = union([messageSyncEstimate, messageSyncChat, messageSyncAll, messageSyncStarted]);
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/store-records.js
+var range = strictObject({ from: number(), to: number() });
+var storeChatStatus = strictObject({
+  chat_id: id,
+  title: nullable(text),
+  kind: chat.entries.kind,
+  messages: count,
+  oldest_at: nullable(time),
+  newest_at: nullable(time),
+  last_stored_at: nullable(time),
+  held: array(range)
+});
+var storeClear = strictObject({
+  cleared: boolean(),
+  dry_run: optional(literal(true)),
+  chats: count,
+  messages: count,
+  left: array(strictObject({ id, title: nullable(text), messages: count }))
+});
+var storeExport = union([
+  message,
+  strictObject({
+    path: text,
+    format: picklist(["jsonl", "markdown"]),
+    count,
+    encrypted: optional(literal(true))
+  }),
+  strictObject({
+    path: text,
+    encrypted: optional(literal(true)),
+    chats: array(strictObject({ id, title: nullable(text), file: nullable(text), messages: count, deleted: count }))
+  })
+]);
+var storeGapPlan = strictObject({
+  version: literal(1),
+  scope: literal("interior"),
+  account: strictObject({ provider: text, account: id }),
+  chat: id,
+  ordering: picklist(["id", "time"]),
+  held: array(range),
+  gaps: array(range),
+  unknown: strictObject({ older: boolean(), newer: literal(true) }),
+  fingerprint: text,
+  limits: strictObject({ max_gaps: count, limit: count, time_ms: count, page_size: count })
+});
+var storeGapRepair = union([
+  messageSyncStarted,
+  strictObject({
+    version: literal(1),
+    scope: literal("interior"),
+    chat: id,
+    before: storeGapPlan,
+    after: storeGapPlan,
+    repaired: array(range),
+    fetched: count,
+    requests: count,
+    complete: boolean(),
+    prepared: optional(catchUpPreparation),
+    stopped: optional(picklist(["bound", "partial_or_inaccessible", "fetch_failed"]))
+  })
+]);
+var problem2 = objectWithRest({ code: text, message: text, retryable: optional(boolean()), retry_after_ms: optional(number()) }, unknown());
+var progress = strictObject({
+  job: id,
+  profile: text,
+  done: count,
+  total: nullable(count),
+  remaining: nullable(count),
+  state: picklist(["partial", "complete"]),
+  updated_at: nullable(time),
+  cursor_age_ms: nullable(count)
+});
+var storeJobDetails = strictObject({
+  ...omit(job, ["id", "issue", "error"]).entries,
+  job: id,
+  profile: text,
+  issue: optional(problem2),
+  error: optional(problem2),
+  batch: optional(batchResult),
+  resume: optional(strictObject({ before: optional(text) })),
+  progress,
+  held: optional(array(range)),
+  log: text
+});
+var storeJobCancel = strictObject({ job: id, cancelled: literal(true) });
+var storeJobRetry = union([
+  strictObject({ ...messageSyncStarted.entries, retried: id }),
+  strictObject({ retried: id, chat: text, error: strictObject({ code: text, message: text }) })
+]);
+var storeJobClear = strictObject({ cleared: array(id) });
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/meeting-preparation-parts.js
+var preparationId = pipe(string(), minLength(1));
+var preparationCount = pipe(number(), integer(), minValue(0));
+var preparationTime = nullable(isoTime);
+var text2 = nullable(string());
+var id2 = preparationId;
+var count2 = preparationCount;
+var page = /* @__PURE__ */ __name((item) => strictObject({ items: array(item), has_more: boolean() }), "page");
+var preparationUpcoming = strictObject({
+  scope: strictObject({ provider: id2, account: id2 }),
+  meeting_id: id2,
+  kind: picklist(["single", "recurring", "unscheduled", "unknown"]),
+  after: isoTime,
+  until: isoTime,
+  timezone: text2,
+  verified_next: boolean(),
+  candidate: nullable(strictObject({
+    id: text2,
+    start_at: preparationTime,
+    end_at: preparationTime,
+    status: picklist(["scheduled", "cancelled"]),
+    verified: boolean()
+  })),
+  coverage: strictObject({
+    schedule_complete: boolean(),
+    inspected: count2,
+    undated: count2,
+    unverified: count2,
+    cancelled: count2,
+    simultaneous: count2,
+    missing: array(picklist(["schedule-details", "occurrence-details"]))
+  })
+});
+var preparationCue = strictObject({
+  ref: reference,
+  fingerprint: id2,
+  transcript_id: id2,
+  content_hash: text2,
+  position: count2,
+  offset_ms: count2,
+  end_ms: count2,
+  speaker_participant_id: nullable(id2),
+  speaker_name: text2,
+  text: string(),
+  revision: picklist(["current", "superseded"])
+});
+var preparationEvidence = strictObject({
+  schema_version: literal(1),
+  kind: literal("meeting"),
+  source: reference,
+  fingerprint: id2,
+  limits: strictObject({ cues: count2, bytes: count2, max_read_bytes: count2, max_transcript_pages: count2 }),
+  content_bytes: count2,
+  coverage: strictObject({
+    provided: count2,
+    included: count2,
+    omitted: nullable(count2),
+    provided_exact: boolean(),
+    next_transcript_id: nullable(id2),
+    next_reference: nullable(reference),
+    transcript_pages: count2,
+    skipped_unavailable: count2,
+    has_more: boolean(),
+    truncated_by: nullable(picklist(["cues", "bytes", "transcripts"])),
+    input: literal("bounded-meeting-pages"),
+    archive_completeness: literal("unknown")
+  }),
+  items: array(preparationCue)
+});
+var preparationContext = strictObject({
+  participants: page(strictObject({ id: id2, identity_id: id2, display_name: text2, person_uid: nullable(id2) })),
+  projects: page(strictObject({ ref: reference, key: id2, name: string(), link_id: id2 })),
+  facts: page(strictObject({ ref: reference, type: id2, statement: string(), updated_at: isoTime })),
+  tasks: page(strictObject({
+    ref: reference,
+    key: id2,
+    title: string(),
+    status: id2,
+    priority: nullable(count2),
+    source: nullable(reference)
+  }))
+});
+var preparationMeeting = strictObject({
+  id: id2,
+  external_id: id2,
+  title: text2,
+  event_id: nullable(id2),
+  started_at: preparationTime,
+  ended_at: preparationTime,
+  updated_at: isoTime
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/meeting-communications.js
+var communicationCoverage = strictObject({
+  read_usage: strictObject({ reads: preparationCount, charged_bytes: preparationCount, reserved_bytes: preparationCount, remaining_bytes: preparationCount }),
+  query: string(),
+  window: strictObject({ after: isoTime, before: isoTime }),
+  selection: literal("explicit-host-grants/literal-words"),
+  sources: array(strictObject({
+    selection_id: preparationId,
+    source: strictObject({
+      kind: picklist(["message", "mail", "document"]),
+      account_id: preparationId,
+      provider: preparationId,
+      account: preparationId
+    }),
+    state: picklist(["searched", "unavailable", "read-limited"]),
+    index: picklist(["ready", "pending", "missing", "unknown"]),
+    has_more: boolean(),
+    has_undated: boolean(),
+    completeness: literal("unknown"),
+    consistency: literal("snapshot-per-page"),
+    next_cursor: nullable(string()),
+    restart_required: boolean(),
+    output_limited: boolean(),
+    read_bytes: nullable(preparationCount),
+    issue: nullable(picklist(["not_found", "validation_error", "configuration_error"]))
+  }))
+});
+var preparationCommunications = strictObject({
+  coverage: communicationCoverage,
+  items: array(strictObject({
+    selection_id: preparationId,
+    ref: reference,
+    provider: preparationId,
+    account: preparationId,
+    title: nullable(string()),
+    url: nullable(string()),
+    text: string(),
+    at: isoTime,
+    updated_at: isoTime,
+    revision: nullable(pipe(number(), safeInteger(), minValue(1))),
+    time_kind: picklist(["sent", "source-modified", "stored-update"]),
+    text_truncated: boolean()
+  }))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/meeting-preparation.js
+var meetingPreparation = strictObject({
+  communications: optional(preparationCommunications),
+  schema_version: literal(1),
+  kind: literal("meeting_preparation"),
+  account_id: preparationId,
+  upcoming: preparationUpcoming,
+  series: nullable(strictObject({
+    id: preparationId,
+    external_id: preparationId,
+    title: nullable(string()),
+    event_series_id: nullable(preparationId),
+    updated_at: isoTime
+  })),
+  history_window: strictObject({ after: isoTime, before: isoTime }),
+  meetings: array(strictObject({
+    ref: reference,
+    meeting: preparationMeeting,
+    evidence: preparationEvidence,
+    context: preparationContext
+  })),
+  related: strictObject({
+    anchors: array(reference),
+    items: array(strictObject({
+      ref: reference,
+      meeting: preparationMeeting,
+      evidence: preparationEvidence,
+      shared_person: boolean(),
+      shared_project: boolean()
+    })),
+    has_more: boolean(),
+    output_limited: boolean(),
+    selection: literal("explicit-person-links/confirmed-project-links")
+  }),
+  knowledge: optional(strictObject({
+    anchors: array(reference),
+    items: array(strictObject({
+      ref: reference,
+      type: picklist(["fact", "statement", "question", "decision", "promise"]),
+      statement: string(),
+      subject: nullable(reference),
+      project: nullable(reference),
+      updated_at: isoTime,
+      shared_person: boolean(),
+      shared_project: boolean()
+    })),
+    selection: literal("accepted-global-person/project-facts"),
+    coverage: strictObject({
+      has_more: boolean(),
+      output_limited: boolean(),
+      fact_evidence: literal("not-revalidated"),
+      other_sources: picklist(["not-queried", "see-communications"])
+    })
+  })),
+  notes: optional(strictObject({
+    anchors: array(reference),
+    items: array(strictObject({
+      ref: reference,
+      title: nullable(string()),
+      text: string(),
+      revision: pipe(number(), safeInteger(), minValue(1)),
+      updated_at: isoTime,
+      person: nullable(reference),
+      project: nullable(reference),
+      meeting: optional(nullable(reference))
+    })),
+    selection: picklist([
+      "owner-written-global-person/project-notes",
+      "owner-written-meeting/person/project-notes"
+    ]),
+    coverage: strictObject({
+      has_more: boolean(),
+      output_limited: boolean(),
+      source_evidence: literal("not-revalidated"),
+      other_sources: picklist(["not-queried", "see-communications"])
+    })
+  })),
+  project_evidence: optional(strictObject({
+    project: string(),
+    query: string(),
+    pages: array(meetingProjectEvidence),
+    continuation: nullable(strictObject({
+      command: literal("meetings projects evidence"),
+      project: string(),
+      query: string(),
+      cursor: nullable(string()),
+      limit: preparationCount,
+      max_read_bytes: preparationCount
+    })),
+    coverage: strictObject({ page_limit: preparationCount, has_more: boolean(), output_limited: boolean() })
+  })),
+  limits: strictObject({ meetings: preparationCount, cues: preparationCount, context_limit: preparationCount, max_read_bytes: preparationCount, bytes: preparationCount }),
+  coverage: strictObject({
+    archive_completeness: literal("unknown"),
+    consistency: literal("live-reads"),
+    history_has_more: boolean(),
+    has_undated: boolean(),
+    skipped_unavailable: array(reference),
+    output_limited: boolean(),
+    context: literal("observed-participants/confirmed-projects/accepted-meeting-subject-facts/direct-source-tasks"),
+    fact_evidence: literal("not-revalidated"),
+    unqueried: array(picklist([
+      "person-history",
+      "project-wide-context",
+      "person-nonmeeting-context",
+      "project-nonmeeting-context",
+      "project-alias-candidates",
+      "other-person-nonmeeting-context",
+      "other-project-nonmeeting-context"
+    ]))
+  })
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/meeting-project-candidates.js
+var count3 = pipe(number(), integer(), minValue(0));
+var id3 = pipe(string(), minLength(1));
+var text3 = string();
+var meetingProjectCandidates = strictObject({
+  schema_version: literal(1),
+  kind: literal("meeting_project_candidates"),
+  source: strictObject({ provider: text3, account: text3, account_id: id3, ref: reference }),
+  input_fingerprint: id3,
+  vocabulary_fingerprint: id3,
+  association: literal("unconfirmed-literal-evidence"),
+  items: array(strictObject({
+    project: strictObject({ ref: reference, id: id3, name: text3, key: nullable(text3) }),
+    matches: array(strictObject({
+      term: strictObject({
+        name: text3,
+        kind: picklist(["canonical", "key", "alias"]),
+        alias_id: optional(id3)
+      }),
+      ambiguous: boolean(),
+      source: strictObject({
+        kind: picklist(["metadata-title", "transcript"]),
+        ref: reference,
+        fingerprint: nullable(id3),
+        revision: nullable(picklist(["current", "superseded"]))
+      })
+    })),
+    omitted_matches: count3
+  })),
+  limits: strictObject({ limit: count3, max_projects: count3, max_vocabulary_read_bytes: count3, bytes: count3 }),
+  coverage: strictObject({
+    selection: literal("explicit-host-evidence/global-project-vocabulary"),
+    source_evidence: literal("not-revalidated"),
+    association: literal("unconfirmed-literal-evidence"),
+    archive_completeness: literal("unknown"),
+    omitted_matches: count3,
+    candidates_total: count3,
+    has_more: boolean(),
+    output_limited: boolean(),
+    matching: literal("unicode-normalized-literal-word-boundaries")
+  }),
+  evidence: strictObject({
+    fingerprint: id3,
+    limits: strictObject({ cues: count3, bytes: count3, max_read_bytes: count3, max_transcript_pages: count3 }),
+    coverage: strictObject({
+      provided: count3,
+      included: count3,
+      omitted: nullable(count3),
+      provided_exact: boolean(),
+      next_cursor: nullable(reference),
+      next_transcript_id: nullable(id3),
+      next_reference: nullable(reference),
+      transcript_pages: count3,
+      skipped_unavailable: count3,
+      has_more: boolean(),
+      truncated_by: nullable(picklist(["cues", "bytes", "transcripts"])),
+      input: literal("bounded-meeting-pages"),
+      archive_completeness: literal("unknown")
+    }),
+    consistency: literal("live-reads"),
+    max_store_calls: literal(8)
+  })
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/meeting-series-inventory.js
+var count4 = pipe(number(), integer(), minValue(0));
+var id4 = pipe(string(), minLength(1), maxLength(1e3));
+var meetingSeriesInventory = strictObject({
+  schema_version: literal(1),
+  kind: literal("meeting_series_inventory"),
+  scope: strictObject({ provider: id4, account: id4 }),
+  after: isoTime,
+  until: isoTime,
+  items: array(strictObject({
+    meeting_id: id4,
+    title: nullable(pipe(string(), maxLength(8192))),
+    kind: picklist(["single", "recurring", "unscheduled", "unknown"]),
+    scheduled_start_at: nullable(isoTime)
+  })),
+  page: pageSchema,
+  fingerprint: pipe(string(), minLength(1), maxLength(200)),
+  limits: strictObject({ limit: count4, max_read_bytes: count4, bytes: count4 }),
+  coverage: strictObject({
+    selection: picklist(["provider-window", "provider-inventory"]),
+    source_partial: boolean(),
+    has_more: boolean(),
+    undated: count4,
+    date_hints_outside_window: count4,
+    calendar_completeness: literal("unknown"),
+    occurrence_proof: literal("not-read"),
+    consistency: literal("live-provider-pages")
+  })
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/saved-search.js
+var savedSearch = strictObject({
+  id,
+  /** `null` for a run in the history. */
+  name: nullable(text),
+  command: picklist(["search", "stats", "message-top", "author-top", "admin-statistics", "meetings-search"]),
+  /** The query and the options it runs with, as the command took them. */
+  params: record(string(), unknown()),
+  language: text,
+  version: count,
+  fields_version: count,
+  created_at: time,
+  last_run_at: nullable(time),
+  runs: count
+});
+var searchHistoryClear = strictObject({ cleared: count });
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/account.js
+var account = strictObject({
+  provider: text,
+  id,
+  name: nullable(text),
+  username: nullable(text),
+  phone: optional(nullable(text)),
+  scope: optional(picklist(["personal", "work"]))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/account-session.js
+var accountSession = strictObject({
+  current: boolean(),
+  client: nullable(text),
+  device: nullable(text),
+  location: nullable(text),
+  last_active_at: nullable(time),
+  created_at: optional(nullable(time))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/account-change.js
+var accountChange = strictObject({ operation_id: id, account: omit(account, ["provider", "scope"]) });
+var endedAccountSessions = strictObject({ operation_id: id, sessions: array(accountSession) });
+var audience = picklist(["everyone", "contacts", "nobody"]);
+var shownAudience = picklist(["everyone", "contacts", "nobody", "contacts_except"]);
+var accountPrivacy = strictObject({
+  find_by_phone: optional(audience),
+  phone_number: optional(audience),
+  calls: optional(audience),
+  chat_invites: optional(audience),
+  hide_online: optional(boolean()),
+  read_receipts: optional(boolean()),
+  profile_photo: optional(shownAudience),
+  about: optional(shownAudience),
+  last_seen: optional(shownAudience)
+});
+var accountPrivacyChange = strictObject({ operation_id: id, privacy: accountPrivacy });
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/account-profile.js
+var accountProfile = strictObject({
+  profile: id,
+  current: boolean(),
+  account: nullable(id),
+  name: nullable(text),
+  /** False for a profile with no session on this computer; absent when the messenger does not say. */
+  signed_in: optional(boolean())
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/counter-reading.js
+var milliseconds = pipe(number(), minValue(0));
+var counterReading = strictObject({
+  counter: picklist(["views", "reactions", "comments"]),
+  value: nullable(number()),
+  observed_at: nullable(time),
+  source: nullable(text),
+  age_ms: nullable(milliseconds),
+  freshness: picklist(["fresh", "stale", "unknown"])
+});
+var selection = record(string(), unknown());
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/admin-report.js
+var adminRow = strictObject({
+  ref: reference,
+  /** What `stats * evidence` takes: a person id, a stay or a message locator. */
+  id,
+  status: picklist(["observed", "no-observed-answer", "partial", "unknown"]),
+  chat_ref: optional(reference),
+  person_ref: optional(reference),
+  identity_known: optional(boolean()),
+  questions: optional(count),
+  answered: optional(count),
+  median_ms: optional(nullable(milliseconds)),
+  p90_ms: optional(nullable(milliseconds)),
+  age_ms: optional(milliseconds),
+  joined_at: optional(time),
+  window_end: optional(time),
+  pending: optional(boolean()),
+  views: optional(count),
+  observed_replies: optional(count),
+  comment_snapshot: optional(nullable(count)),
+  counters: optional(array(counterReading)),
+  selection
+});
+var adminReport = strictObject({
+  report: picklist(["unanswered", "responses", "newcomers", "discussion"]),
+  cutoff: time,
+  /** Rows the report found; `rows` holds the first `--limit` of them. */
+  total: count,
+  summary: strictObject({
+    questions: count,
+    answered: count,
+    no_observed_answer: count,
+    excluded_future: count,
+    unknown_join: count,
+    missing_views: count
+  }),
+  quality: strictObject({
+    graph: strictObject({
+      unknown_links: count,
+      unknown_authors: count,
+      missing_parents: count,
+      cycles: count,
+      complete: boolean()
+    }),
+    archives: array(strictObject({ chat_ref: reference, state: text, fetched_at: nullable(time) })),
+    archives_total: count,
+    membership: text,
+    counter_freshness: text,
+    answerer_roles: text
+  }),
+  rows: array(adminRow)
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/analysis-consent.js
+var analysisConsent = strictObject({ chat: id, provider: text, at: time });
+var analysisConsentRevocation = strictObject({ revoked: boolean() });
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/attachment-results.js
+var fingerprint = pipe(text, regex(/^[a-f0-9]{64}$/));
+var attachmentBytes = strictObject({
+  ref: reference,
+  attachment: count,
+  name: nullable(text),
+  mime_type: text,
+  total_bytes: count,
+  sha256: fingerprint,
+  offset_bytes: count,
+  read_bytes: count,
+  next_offset_bytes: nullable(count),
+  complete: boolean(),
+  base64: optional(text),
+  pdf: optional(strictObject({ page: count, page_count: count, source_sha256: fingerprint, source_bytes: count }))
+});
+var attachmentExtraction = union([
+  strictObject({ ...omit(extractionReport, ["items"]).entries, files: array(extractionItem) }),
+  extractionItem
+]);
+var attachmentTextChange = strictObject({
+  ref: reference,
+  attachment: count,
+  origin: literal("agent"),
+  chars: count,
+  replaced: nullable(picklist(["extracted", "agent"]))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/chart.js
+var chart = strictObject({
+  version: literal(1),
+  kind: picklist(["bar", "line", "grouped-bar"]),
+  title: text,
+  x: strictObject({ type: picklist(["day", "week"]), values: array(text) }),
+  series: array(strictObject({ name: text, values: array(nullable(number())) })),
+  unit: picklist(["messages", "people"]),
+  timezone: text,
+  /** Lower bounds: the store or the events did not hold the whole period. */
+  partial: boolean(),
+  reasons: array(picklist(["store-incomplete", "events-incomplete"])),
+  file: optional(strictObject({ path: text, format: picklist(["svg", "png"]), width: count, height: count }))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/folder.js
+var named = strictObject({
+  id,
+  title: nullable(text),
+  kind: nullable(picklist(["dialog", "group", "channel", "saved", "unknown"]))
+});
+var folder = strictObject({
+  id,
+  title: text,
+  /** Chats added by hand; a folder that selects chats by a rule of its own lists none. */
+  chat_ids: array(id),
+  emoji: optional(text),
+  /** Kinds of chat it takes by itself. */
+  include: optional(array(picklist(["contacts", "non-contacts", "groups", "channels", "bots"]))),
+  skip: optional(array(picklist(["muted", "read", "archived"]))),
+  excluded_chat_ids: optional(array(id)),
+  pinned_chat_ids: optional(array(id)),
+  /** `chats folders show`: the chats in it, pinned and left out, by name. */
+  chats: optional(array(named)),
+  pinned_chats: optional(array(named)),
+  excluded_chats: optional(array(named))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/invite-link.js
+var inviteLink = strictObject({
+  link: text,
+  /** Who joins by it asks first, and an admin lets them in. */
+  approval: boolean(),
+  /** `null` when it never expires. */
+  expires_at: nullable(time),
+  /** `null` for no limit. */
+  max_uses: nullable(count),
+  /** The group's own link; revoking it makes the messenger issue a new one. */
+  primary: optional(boolean()),
+  revoked: optional(boolean()),
+  pending_count: optional(count),
+  joined_count: optional(count)
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/chat-admin.js
+var operated = { operation_id: id, chat_id: id };
+var group = strictObject({
+  ...omit(chat, ["ref", "provider", "account", "invite_link", "members"]).entries,
+  parent_chat_id: optional(nullable(id)),
+  muted_until: optional(nullable(time)),
+  description: nullable(text),
+  link: nullable(text),
+  settings: strictObject({
+    ...unwrap(chat.entries.settings).entries,
+    all_can_pin: nullable(boolean()),
+    only_admins_add: nullable(boolean()),
+    only_admins_call: nullable(boolean()),
+    only_owner_edits_info: nullable(boolean()),
+    members_see_link: nullable(boolean())
+  })
+});
+var chatGroupChange = union([
+  strictObject({ operation_id: id, chat: group }),
+  strictObject({ operation_id: id, requested: literal(true) })
+]);
+var chatInspection = strictObject({
+  kind: chat.entries.kind,
+  title: nullable(text),
+  id: nullable(id),
+  username: nullable(text),
+  participants_count: nullable(count),
+  description: nullable(text),
+  member: nullable(boolean()),
+  approval_needed: optional(boolean())
+});
+var chatSender = strictObject({
+  id,
+  title: text,
+  kind: picklist(["self", "channel", "group"]),
+  premium_required: boolean(),
+  default: boolean()
+});
+var chatRead = strictObject({ ...operated, until: nullable(id), thread_id: optional(id) });
+var chatMembersFetch = strictObject({
+  chat_id: id,
+  joined: array(id),
+  gone: array(id),
+  changed: array(id),
+  read: count,
+  participants: nullable(count),
+  complete: boolean(),
+  more: boolean(),
+  tracked: boolean()
+});
+var chatMembersChange = union([
+  strictObject({ ...operated, added: array(id), not_added: array(id) }),
+  strictObject({ ...operated, removed: array(id) })
+]);
+var chatInvite = strictObject({ chat_id: id, title: nullable(text), link: text });
+var chatInviteChange = strictObject({
+  ...operated,
+  ...omit(inviteLink, ["pending_count", "joined_count"]).entries,
+  pending: optional(count),
+  joined: optional(count)
+});
+var chatRequestChange = union([
+  strictObject({ ...operated, person_id: id, accepted: boolean(), already: boolean() }),
+  strictObject({ chat_id: id, accepted: boolean(), counted: count, operation_id: optional(id) })
+]);
+var chatAdminChange = strictObject({
+  ...operated,
+  person_id: id,
+  rights: optional(array(picklist(["read", "members", "admins", "info", "pin", "link", "post", "edit", "delete"])))
+});
+var chatFolderChange = strictObject({
+  operation_id: id,
+  folder: omit(folder, ["chats", "pinned_chats", "excluded_chats"])
+});
+var chatFolderRemoval = strictObject({ operation_id: id, folder_id: id });
+var chatFolderOrder = strictObject({
+  operation_id: id,
+  folders: array(strictObject({ id, title: text }))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/chat-change.js
+var operated2 = { operation_id: id, chat_id: id };
+var chatRemoval = strictObject(operated2);
+var chatMuting = strictObject({
+  ...operated2,
+  muted_until: nullable(union([time, literal("forever")]))
+});
+var chatArchive = strictObject({ ...operated2, archived: boolean() });
+var chatPin = strictObject({ ...operated2, pinned: boolean() });
+var chatUnread = strictObject({ ...operated2, unread: literal(true) });
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/chat-event.js
+var who = strictObject({ id: nullable(id), name: nullable(text), username: optional(nullable(text)) });
+var chatEvent = strictObject({
+  chat_id: id,
+  time,
+  /** `join`, `leave`, `add`, `remove`, `create`, `title`, `pin`, `profile`; a messenger may pass others through. */
+  type: text,
+  /** The service message that says so, where there is one. */
+  message_id: optional(id),
+  by: optional(who),
+  people: array(who),
+  /** `create` and `title` carry the chat's title. */
+  title: optional(text),
+  /** `profile`: the name and username seen before. */
+  before: optional(strictObject({ name: nullable(text), username: nullable(text) }))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/chat-metadata.js
+var chatMetadata = strictObject({
+  chat_id: id,
+  title: nullable(text),
+  username: nullable(text),
+  description: nullable(text),
+  fetched_at: time
+});
+var cachedChatMetadata = strictObject({ chat_id: id, metadata: nullable(chatMetadata) });
+var failedChatMetadata = strictObject({ chat_id: id, error: strictObject({ code: text, message: text }) });
+var chatMetadataRefresh = strictObject({
+  chats: array(union([chatMetadata, failedChatMetadata])),
+  has_more: boolean()
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/chat-moderation.js
+var action = picklist(["report", "delete", "remove"]);
+var level = picklist(["deny", "readonly", "ask", "allow"]);
+var chatRules = strictObject({
+  chat_id: id,
+  title: nullable(text),
+  file: text,
+  saved: boolean(),
+  rules: strictObject({
+    title: nullable(text),
+    trusted: array(id),
+    blocked: array(id),
+    blocked_names: array(text),
+    links: action,
+    invites: action,
+    forwards: action,
+    blocked_people: action,
+    flood: strictObject({ messages: count, minutes: count, action }),
+    new_account: strictObject({ days: count, action: picklist(["report", "remove"]) }),
+    consent: strictObject({ delete: level, remove: level })
+  })
+});
+var chatModeration = strictObject({
+  chat_id: id,
+  rows: array(strictObject({
+    kind: picklist(["message", "member"]),
+    rule: picklist(["blocked", "invites", "links", "forwards", "flood", "newAccount"]),
+    person_id: id,
+    person_name: nullable(text),
+    message_id: optional(id),
+    action,
+    outcome: picklist(["reported", "done", "planned", "forbidden", "declined", "refused", "failed", "skipped"]),
+    reason: optional(text),
+    command: optional(text)
+  }))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/chat-stats.js
+var optionalCount = optional(count);
+var minutes = nullable(number());
+var chatStats = strictObject({
+  chat: reference,
+  since: time,
+  until: time,
+  /** The store holds the chat whole and the messenger read every join and leave; otherwise lower bounds. */
+  complete: boolean(),
+  completeness: strictObject({
+    state: picklist(["complete", "partial", "unknown"]),
+    up_to_date: nullable(boolean()),
+    gaps: boolean(),
+    reaches_start: boolean(),
+    fetched_at: nullable(time)
+  }),
+  messages: count,
+  senders: count,
+  replies: count,
+  threads: count,
+  reactions: count,
+  views: optionalCount,
+  forwards: optionalCount,
+  comments: optionalCount,
+  top_posts: array(strictObject({
+    ref: reference,
+    timestamp: time,
+    reactions: count,
+    views: optionalCount,
+    forwards: optionalCount,
+    comments: optionalCount
+  })),
+  questions: strictObject({
+    asked: count,
+    answered: count,
+    median_minutes_to_answer: minutes,
+    answered_by: picklist(["owner", "owner-and-admins"])
+  }),
+  member_counts: optional(array(strictObject({ day: text, participants: nullable(count), listed: count, complete: boolean() }))),
+  /** Absent where joins and leaves were not asked, or not recorded for the chat yet (then `missing` says so). */
+  members: optional(strictObject({
+    joined: count,
+    left: count,
+    net: number(),
+    wrote: count,
+    median_minutes_to_first_message: minutes,
+    /** The messenger stopped reading its history before `since`: the counts are lower bounds. */
+    more: boolean()
+  })),
+  series: optional(array(strictObject({ key: text, messages: count, senders: count, joined: optionalCount, left: optionalCount })))
+});
+var taskStats = strictObject({
+  /** Open tasks across every row. */
+  open: count,
+  rows: array(strictObject({
+    chat: reference,
+    open: count,
+    oldest_open_at: nullable(time),
+    median_close_ms: nullable(pipe(number(), minValue(0)))
+  }))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/chat-tracking.js
+var memberCount = strictObject({
+  day: pipe(text, isoDate()),
+  participants: nullable(count),
+  listed: count,
+  complete: boolean()
+});
+var trackedChat = strictObject({
+  chat_id: id,
+  title: nullable(text),
+  tracked_at: time,
+  last_count: nullable(memberCount)
+});
+var trackedChatHistory = strictObject({
+  chat_id: id,
+  tracked_at: nullable(time),
+  counts: array(memberCount)
+});
+var chatTracking = strictObject({
+  chat_id: id,
+  tracked: boolean()
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/contact.js
+var contact = strictObject({
+  ref: reference,
+  id,
+  name: nullable(text),
+  username: nullable(text),
+  alias: optional(nullable(text)),
+  display_name: optional(nullable(text)),
+  /** Whatever they wrote about themselves. */
+  description: nullable(text),
+  /** The newest message in a one-to-one chat with them. */
+  last_messaged_at: nullable(time),
+  /** For a source that knows it, such as a Zoom contact. */
+  email: optional(nullable(text)),
+  phones: optional(array(strictObject({ number: text, label: nullable(text) }))),
+  /** `contacts show`: the chats shared with them. */
+  chats: optional(array(pick(chat, ["ref", "id", "title", "kind", "last_message_at"]))),
+  /** `contacts show --with-notes`: the owner's private notes about them. */
+  notes: optional(array(strictObject({ id, text, revision: count, created_at: time, updated_at: time })))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/contact-activity.js
+var linkedIdentity = strictObject({
+  provider: text,
+  id,
+  name: nullable(text),
+  username: nullable(text),
+  is_bot: nullable(boolean()),
+  accounts: array(id),
+  method: text,
+  linked_by: text,
+  linked_at: time
+});
+var linkedPerson = strictObject({ uid: id, name: nullable(text), identities: array(linkedIdentity) });
+var contactActivity = strictObject({
+  at: time,
+  subject: text,
+  subject_id: count,
+  role: text,
+  scope: text,
+  provider: nullable(text),
+  account: nullable(text),
+  chat_id: nullable(text),
+  locator: nullable(text),
+  project_id: nullable(count)
+});
+var botReason = picklist(Object.keys(WEIGHTS));
+var contactCheck = strictObject({
+  person: strictObject({ id, name: nullable(text), username: nullable(text), provider: text }),
+  score: count,
+  reasons: array(strictObject({ reason: botReason, weight: count, source: text, detail: optional(text) })),
+  registries: array(strictObject({
+    name: picklist(["cas", "lols"]),
+    answer: picklist(["listed", "clean", "unknown"]),
+    checked_at: time,
+    detail: optional(text),
+    reasons: optional(array(picklist(["cas_banned", "lols_banned", "lols_scammer"])))
+  })),
+  unknown: array(botReason),
+  checked_at: time
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/contact-context.js
+var contextPerson = strictObject({ ...linkedPerson.entries, provider: text, id });
+var contextMessage = strictObject({
+  locator: reference,
+  provider: text,
+  account: id,
+  chat_id: id,
+  chat_title: nullable(text),
+  id,
+  timestamp: time,
+  sender_id: nullable(id),
+  sender_name: nullable(text),
+  outgoing: nullable(boolean()),
+  text
+});
+var sharedChat = strictObject({
+  provider: text,
+  account: id,
+  chat_id: id,
+  title: nullable(text),
+  kind: chat.entries.kind,
+  last_message_at: nullable(time)
+});
+var contextEvent = strictObject({
+  ref: reference,
+  title: nullable(text),
+  starts_at: nullable(time),
+  ends_at: nullable(time),
+  all_day: boolean(),
+  location: nullable(text),
+  status: nullable(text)
+});
+var context = strictObject({
+  person: contextPerson,
+  shared: array(sharedChat),
+  last: strictObject({
+    from_them: nullable(contextMessage),
+    from_me: nullable(contextMessage),
+    from_them_anywhere: nullable(contextMessage)
+  }),
+  recent: strictObject({ direct: array(contextMessage), groups: array(contextMessage) }),
+  mentions: array(contextMessage),
+  /** Calendar events they are invited to, one occurrence per series. */
+  events: optional(strictObject({ upcoming: array(contextEvent), recent: array(contextEvent) })),
+  limits: strictObject({ messages: count, bytes: count }),
+  complete: boolean(),
+  not_read: array(strictObject({
+    provider: text,
+    account: id,
+    chat_id: id,
+    title: nullable(text),
+    reason: picklist(["not_fetched", "partial"])
+  }))
+});
+var shortMessage = strictObject({ at: time, text, transcript: optional(text) });
+var identifiedMessage = strictObject({
+  ...shortMessage.entries,
+  id,
+  locator: reference,
+  sender_id: nullable(id),
+  reply_to: nullable(id)
+});
+var counterObservation = strictObject({
+  value: number(),
+  observed_at: time,
+  source: picklist(["remote_fetch", "remote_update"]),
+  reactions: optional(message.entries.reactions.wrapped.wrapped)
+});
+var { reply_addresses: mailReplyTo, ...mailFields } = message.entries.email.wrapped.entries;
+var fullMessage = strictObject({
+  ...pick(message, [
+    "id",
+    "chat_id",
+    "chat_title",
+    "excerpt",
+    "sender_id",
+    "sender_name",
+    "sender_username",
+    "mentions",
+    "sender_is_chat",
+    "timestamp",
+    "edited_at",
+    "text",
+    "outgoing",
+    "attachments",
+    "reply_to",
+    "reply_to_id",
+    "forwarded_from",
+    "thread_id",
+    "thread_root_id",
+    "scheduled_for",
+    "provider_metadata",
+    "delivery"
+  ]).entries,
+  reactions: nullable(message.entries.reactions.wrapped.wrapped),
+  starred: optional(boolean()),
+  email: optional(strictObject({ ...mailFields, reply_to: mailReplyTo })),
+  counter_observations: optional(partial(strictObject({
+    views: counterObservation,
+    reactions: counterObservation,
+    comments: counterObservation
+  }))),
+  ...shortMessage.entries,
+  locator: reference
+});
+var contactMessages = strictObject({
+  person: strictObject({ uid: id, provider: text, id, name: nullable(text) }),
+  chats: array(strictObject({
+    chat: pick(chat, ["id", "title", "kind"]),
+    messages: array(union([shortMessage, identifiedMessage, fullMessage])),
+    complete: boolean(),
+    more: boolean()
+  })),
+  limits: strictObject({ messages: count })
+});
+var contactContext = union([context, contactMessages]);
+var coverage = strictObject({
+  included: count,
+  has_more: boolean(),
+  cut_by: nullable(picklist(["limit", "bytes"]))
+});
+var meetingCue = strictObject({
+  reference,
+  fingerprint: text,
+  transcript_id: count,
+  content_hash: nullable(text),
+  position: count,
+  start_ms: count,
+  end_ms: count,
+  speaker_participant_id: nullable(count),
+  speaker_name: nullable(text),
+  text,
+  revision: picklist(["current", "superseded"])
+});
+var contactPreparation = strictObject({
+  ...context.entries,
+  prepare: strictObject({
+    waiting: array(strictObject({
+      provider: text,
+      account: id,
+      chat_id: id,
+      title: nullable(text),
+      message: contextMessage,
+      partial: boolean()
+    })),
+    tasks: array(strictObject({
+      ref: reference,
+      title: text,
+      role: text,
+      due_at: nullable(time),
+      project: reference,
+      source: nullable(reference),
+      created_at: time
+    })),
+    facts: array(strictObject({
+      ref: reference,
+      type: text,
+      statement: text,
+      subject: nullable(reference),
+      project: nullable(reference),
+      updated_at: time
+    })),
+    notes: array(strictObject({ ref: reference, title: nullable(text), text, revision: count, updated_at: time })),
+    meetings: array(strictObject({
+      reference,
+      cues: array(meetingCue),
+      cue_coverage: strictObject({ included: count, omitted: nullable(count), has_more: boolean() })
+    })),
+    limits: strictObject({ items: count, bytes: count }),
+    coverage: strictObject({
+      waiting: strictObject({
+        ...coverage.entries,
+        rule: literal("their message is the newest the store holds in a one-to-one chat")
+      }),
+      tasks: strictObject({
+        ...coverage.entries,
+        selection: literal("open, assigned to them in any role"),
+        accounts: array(text)
+      }),
+      facts: strictObject({
+        ...coverage.entries,
+        selection: literal("accepted, about them or a project they are a member of")
+      }),
+      notes: strictObject({
+        ...coverage.entries,
+        selection: literal("written by you, about them"),
+        withheld: optional(literal("contacts.notes.list"))
+      }),
+      meetings: strictObject({
+        ...coverage.entries,
+        read: literal("every account of the store that saw them"),
+        accounts: array(text),
+        pending: count
+      })
+    })
+  })
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/contact-note.js
+var contactNote = strictObject({
+  id,
+  /** The contact, as a `contact:` reference. */
+  contact: reference,
+  text,
+  /** Starts at 1; an edit names the revision it read. */
+  revision: count,
+  created_at: time,
+  updated_at: time
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/contact-read.js
+var contactLookup = strictObject({ id, name: nullable(text), username: nullable(text) });
+var contactSync = strictObject({ added: count, changed: count, known: count });
+var contactProfile = strictObject({
+  id,
+  name: nullable(text),
+  usernames: array(text),
+  bio: nullable(text),
+  birthday: optional(nullable(text)),
+  phone: optional(nullable(text)),
+  flags: partial(strictObject({
+    bot: boolean(),
+    verified: boolean(),
+    premium: boolean(),
+    scam: boolean(),
+    fake: boolean(),
+    restricted: boolean(),
+    deleted: boolean(),
+    support: boolean()
+  })),
+  seen: optional(text),
+  contact: optional(boolean()),
+  mutual_contact: optional(boolean()),
+  common_chats_count: optional(nullable(count)),
+  registered: optional(nullable(strictObject({
+    at: text,
+    source: picklist(["telegram", "max", "estimate"]),
+    precision: picklist(["day", "month"])
+  }))),
+  has_photo: optional(boolean()),
+  chats: array(strictObject({
+    id,
+    title: nullable(text),
+    kind: chat.entries.kind,
+    their_messages: count,
+    first_at: nullable(time),
+    last_at: nullable(time),
+    complete: boolean()
+  })),
+  aliases: array(strictObject({
+    name: optional(text),
+    username: optional(text),
+    link: optional(text),
+    first_seen_at: time,
+    last_seen_at: time,
+    source: picklist(["profile", "messages"])
+  }))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/contact-write.js
+var addressBookPerson = strictObject({ id, name: nullable(text), username: nullable(text) });
+var contactUpdate = strictObject({ operation_id: id, person: addressBookPerson });
+var contactStateChange = strictObject({ operation_id: id, person_id: id });
+var contactImport = strictObject({ operation_id: id, sent: count, recognised: array(addressBookPerson) });
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/conversation-results.js
+var conversationDetails = union([
+  strictObject({ ...conversation.entries, messages: array(message) }),
+  message
+]);
+var conversationBatchStatus = strictObject({
+  chat: id,
+  messages: count,
+  characters: count,
+  batches: count,
+  tokens_estimate: count
+});
+var batchMessage = strictObject({
+  id,
+  at: time,
+  sender: strictObject({ id: nullable(id), name: nullable(text) }),
+  text,
+  reply_to: optional(id),
+  thread: optional(id),
+  mentions: optional(array(id)),
+  answer: boolean(),
+  candidates: optional(array(strictObject({ parent: nullable(id), source: text, kind: text, confidence: number() })))
+});
+var conversationBatch = union([
+  strictObject({ batch: null_() }),
+  strictObject({
+    batch: id,
+    chat: id,
+    messages: array(batchMessage),
+    remaining: strictObject({ messages: count, characters: count })
+  })
+]);
+var analyzedConversation = strictObject({
+  chat: id,
+  model: text,
+  batches: count,
+  stored: count,
+  tokens: count,
+  reserved_tokens: count,
+  max_tokens: count,
+  stopped: picklist(["complete", "budget"]),
+  remaining: conversationBatchStatus,
+  built: optional(conversationBuild)
+});
+var conversationBuildResult = union([conversationBuild, conversationPreparation, analyzedConversation]);
+var conversationEmbedding = union([chatEmbedding, conversationPreparation]);
+var conversationChange = union([
+  strictObject({ chat: id, stored: count }),
+  strictObject({ chat: id, cleared: count })
+]);
+var conversationReadiness = strictObject({
+  chat: id,
+  model: text,
+  state: picklist(["ready", "stale", "partial", "words-only", "not-built"]),
+  graph: nullable(strictObject({ built_at: time, rules_version: nullable(count), outdated_rules: boolean() })),
+  pending: strictObject({ new: count, edited: count, deleted: count }),
+  vectors: strictObject({ chunks: count, current: count, stale: count, missing: count })
+});
+var conversationEmbeddingStatus = strictObject({
+  chat: id,
+  model: text,
+  chunks: count,
+  embedded: count,
+  left: count,
+  estimate_seconds: nullable(number()),
+  tokens_at_most: count,
+  price_at_most: optional(strictObject({ usd: number(), read: text }))
+});
+var summary = strictObject({
+  id,
+  chat_id: id,
+  first_message_id: id,
+  first_at: time,
+  last_at: time,
+  message_count: count,
+  senders: count,
+  built_at: time,
+  algorithm_version: count
+});
+var conversationHit = strictObject({
+  source: optional(strictObject({ provider: text, account: id })),
+  locator: optional(reference),
+  summary,
+  chunk: strictObject({ first_message_id: id, last_message_id: id }),
+  score: nullable(number()),
+  matched_in: optional(literal("context")),
+  by: array(picklist(["meaning", "words"])),
+  stale: boolean()
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/counters.js
+var counters = strictObject({
+  cutoff: time,
+  max_age_ms: milliseconds,
+  /** Pins exactly these messages for `counters refresh --selection`. */
+  selection: strictObject({
+    kind: literal("counter-targets"),
+    version: literal(1),
+    locators: array(reference)
+  }),
+  rows: array(strictObject({ ref: reference, counters: array(counterReading) }))
+});
+var counterRefresh = strictObject({
+  dry_run: boolean(),
+  targets: array(reference),
+  counters: array(text),
+  supported: array(text),
+  unsupported: array(text),
+  max_messages: count,
+  time_ms: milliseconds,
+  results: optional(array(strictObject({
+    ref: reference,
+    updated: array(text),
+    missing: array(text),
+    status: text
+  }))),
+  stopped: optional(text),
+  complete: optional(boolean())
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/document.js
+var document = strictObject({
+  ref: reference,
+  id,
+  title: nullable(text),
+  url: nullable(text),
+  mime: optional(text),
+  size: optional(count),
+  /** When its source last changed it. */
+  source_modified_at: nullable(time),
+  /** When the store last read it; not the source's time. */
+  stored_at: optional(nullable(time)),
+  owners: optional(array(text))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/document-link.js
+var documentLink = strictObject({
+  ref: reference,
+  url: text,
+  document_id: nullable(id),
+  title: nullable(text),
+  in_store: boolean(),
+  sent_at: time,
+  sender: strictObject({ id: nullable(id), name: nullable(text) })
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/evidence.js
+var evidenceMessage = pick(message, ["ref", "chat_title", "timestamp", "sender_name", "text"]);
+var contribution = strictObject({
+  message: evidenceMessage,
+  related: optional(evidenceMessage),
+  contribution: nullable(number()),
+  counters: optional(array(counterReading))
+});
+var retentionStay = strictObject({
+  person_ref: reference,
+  joined_at: time,
+  cohort: text,
+  checkpoints: array(strictObject({
+    checkpoint_ms: milliseconds,
+    target_at: time,
+    state: text,
+    observed_at: nullable(time),
+    lag_ms: nullable(milliseconds),
+    complete: boolean()
+  })),
+  activity: strictObject({
+    state: text,
+    first_message_at: nullable(time),
+    window_end: nullable(time),
+    archive_covered: boolean()
+  }),
+  departure: strictObject({ after: nullable(time), at_or_before: nullable(time), early: text })
+});
+var evidence = union([contribution, retentionStay]);
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/fact.js
+var fact = strictObject({
+  ref: reference,
+  id,
+  kind: picklist(FACT_TYPES),
+  text,
+  status: picklist(FACT_STATUSES),
+  project: nullable(text),
+  subject: nullable(reference),
+  occurred_at: nullable(time),
+  supersedes: nullable(reference),
+  author,
+  model: nullable(text),
+  /** Who accepted it; `null` while it is proposed. */
+  confirmed_by: optional(nullable(strictObject({ type: picklist(["person", "bot"]), id }))),
+  scope: nullable(picklist(MEMORY_SCOPES)),
+  /** Who recorded it: the owner, or an agent whose fact waits as proposed. */
+  origin: picklist(["owner", "agent"]),
+  evidence: array(reference),
+  created_at: time,
+  updated_at: time
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/hit.js
+var hit = strictObject({
+  kind: picklist(["message", "mail", "note", "document", "event", "meeting"]),
+  ref: reference,
+  provider: text,
+  url: optional(text),
+  /** The account it was found in; a note's folder id, or `internal` for a note written in memo. */
+  account: text,
+  /** The chat, the mail thread's subject, the note's, the event's or the meeting's title. */
+  title: nullable(text),
+  /** Null for a meeting whose start is unknown. */
+  timestamp: nullable(time),
+  excerpt: text,
+  sender_name: optional(nullable(text)),
+  /** The writer's `person:` reference, where the store has one. */
+  sender_ref: optional(nullable(reference)),
+  found_by: optional(array(picklist(["title", "words", "meaning"]))),
+  /** How far into the meeting the passage is. */
+  offset_ms: optional(nullable(count)),
+  /** A meeting passage's place: its transcript, chat or summary. */
+  scope: optional(picklist(["transcript", "chat", "summary"])),
+  /** A meeting passage's stored line, so two passages of one meeting stay apart; `search meetings` gives the same. */
+  id: optional(pipe(string(), minLength(1))),
+  /** Absent on a note hit: the owner wrote it. */
+  untrusted
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/identity.js
+var identity = strictObject({
+  ref: reference,
+  provider: text,
+  account: text,
+  /** The messenger's own id for them. */
+  id,
+  name: nullable(text),
+  username: nullable(text),
+  /** The `person:` they are linked to, when one is. */
+  person: optional(nullable(reference))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/image-embedding.js
+var imageEmbedding = strictObject({
+  model: text,
+  embedded: count,
+  skipped: count,
+  failed: count,
+  more: boolean()
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/join-request.js
+var joinRequest = strictObject({
+  person_id: id,
+  name: nullable(text),
+  username: nullable(text),
+  /** `null` where the messenger does not say. */
+  requested_at: nullable(time),
+  /** The note they sent with the request. */
+  about: optional(text)
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/poll-vote.js
+var pollVote = strictObject({
+  person_id: id,
+  name: nullable(text),
+  username: nullable(text),
+  /** Answer ids, as `polls show` prints them. */
+  answers: array(id),
+  voted_at: time
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/listener.js
+var reactions = unwrap(unwrap(message.entries.reactions));
+var observation = strictObject({
+  value: pipe(number(), minValue(0)),
+  observed_at: time,
+  source: picklist(["remote_fetch", "remote_update"]),
+  reactions: optional(reactions)
+});
+var watchedMessage = strictObject({
+  ...message.entries,
+  starred: optional(boolean()),
+  counter_observations: optional(partial(strictObject({ views: observation, reactions: observation, comments: observation })))
+});
+var target = { chat_id: id, chat_title: nullable(text), message_id: id };
+var messageEvent = variant("event", [
+  strictObject({ event: picklist(["message", "edit"]), message: watchedMessage }),
+  strictObject({ event: literal("delete"), ...target, chat_id: nullable(id) }),
+  strictObject({ event: literal("reaction"), ...target, reactions, counter_observation: optional(observation) }),
+  strictObject({ event: literal("vote"), ...target, vote: pollVote }),
+  strictObject({
+    event: literal("person_reaction"),
+    ...target,
+    reaction: strictObject({ person: member, own: boolean(), reaction: nullable(text), reacted_at: time })
+  }),
+  strictObject({ event: literal("star"), ...target, starred: boolean() }),
+  strictObject({ event: literal("delivery"), ...target, delivery: unwrap(message.entries.delivery), at: time }),
+  strictObject({ event: literal("chat_event"), chat_id: id, chat_title: nullable(text), change: chatEvent })
+]);
+var watchItem = union([watchedMessage, messageEvent]);
+var totals = record(text, count);
+var serveSummary = strictObject({
+  profile: text,
+  started_at: time,
+  stopped_at: time,
+  kept: totals,
+  replies: optional(strictObject({ sent: totals, skipped: totals, tasks: optional(totals) })),
+  members: optional(strictObject({ fetched: count, failed: count })),
+  stems: optional(strictObject({ stemmed: count })),
+  tasks: optional(strictObject({ added: count, closed: count, review: count }))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/media-archive.js
+var mediaArchive = strictObject({
+  directory: text,
+  chats: count,
+  saved: count,
+  existing: count,
+  complete: boolean()
+});
+var mediaArchiveCheck = strictObject({
+  valid: boolean(),
+  checked: count,
+  files: array(strictObject({ path: text, valid: boolean(), archive_directory: optional(text) }))
+});
+var mediaArchiveMove = strictObject({
+  directory: text,
+  archive_directory: text,
+  before_time: time,
+  selected: count,
+  selected_bytes: count,
+  moved: count,
+  moved_bytes: count,
+  already_archived: count,
+  undated: count,
+  complete: boolean(),
+  dry_run: boolean()
+});
+var timer = { name: text, installed: boolean(), service_path: text, timer_path: text };
+var mediaArchiveTimer = union([
+  strictObject({ ...timer, active: boolean() }),
+  strictObject({ ...timer, action: picklist(["install", "start", "stop", "uninstall"]) })
+]);
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/meeting-evidence.js
+var meetingEvidence = preparationEvidence;
+var meetingPersonContext = strictObject({
+  person: strictObject({ uid: string(), name: nullable(string()) }),
+  items: array(strictObject({
+    ref: reference,
+    cues: array(preparationCue),
+    cue_coverage: strictObject({ included: preparationCount, omitted: nullable(preparationCount), has_more: boolean() })
+  })),
+  limits: strictObject({ meetings: preparationCount, cues: preparationCount, bytes: preparationCount, scan_limit: preparationCount }),
+  content_bytes: preparationCount,
+  coverage: strictObject({
+    involvements_scanned: preparationCount,
+    scan_limit_reached: boolean(),
+    pending: preparationCount,
+    truncated_by: nullable(picklist(["meetings", "bytes"])),
+    skipped_unavailable: preparationCount,
+    complete: literal(false),
+    input: literal("bounded-meeting-pages")
+  })
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/meeting-findings.js
+var evidence2 = strictObject({ reference, fingerprint: text });
+var base = { id, project: reference, evidence: array(evidence2) };
+var finding = variant("kind", [
+  strictObject({ ...base, kind: literal("fact"), type: picklist(FACT_TYPES), statement: text }),
+  strictObject({
+    ...base,
+    kind: literal("task"),
+    type: picklist(WORK_TASK_TYPES),
+    title: text,
+    reason: text,
+    commitment: picklist(["explicit", "inferred"]),
+    due_at: optional(time),
+    due_evidence: optional(array(reference)),
+    assignee: optional(reference),
+    assignee_evidence: optional(array(reference))
+  })
+]);
+var outcome = strictObject({
+  id,
+  fingerprint: text,
+  status: picklist(["accepted", "rejected"]),
+  reference: nullable(reference),
+  reused: boolean()
+});
+var meetingFindings = strictObject({
+  id,
+  account: strictObject({ provider: text, account: text }),
+  input: strictObject({ schema_version: literal(1), key: text, extractor: text, findings: array(finding) }),
+  fingerprint: text,
+  status: picklist(["proposed", "reviewed"]),
+  author,
+  decided_by: nullable(strictObject({ type: picklist(["person", "bot"]), id })),
+  decided_at: nullable(time),
+  previous: array(outcome),
+  receipt: nullable(strictObject({ preview_fingerprint: text, accepted: array(id), items: array(outcome) }))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/meeting-task-proposal.js
+var text4 = string();
+var id5 = pipe(number(), integer(), minValue(1));
+var revision = picklist(["current", "superseded"]);
+var meetingTaskProposal = strictObject({
+  id: text4,
+  source: reference,
+  source_kind: literal("meeting"),
+  group: reference,
+  account_id: id5,
+  kind: picklist(TASK_KINDS),
+  preview: nullable(text4),
+  revision: nullable(revision),
+  applied: literal(false),
+  persistence: literal("proposal-only")
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/memory.js
+var memory = strictObject({
+  ref: reference,
+  id,
+  kind: picklist(MEMORY_KINDS),
+  text,
+  subject: nullable(reference),
+  author,
+  model: nullable(text),
+  confidence: nullable(number()),
+  status: picklist(MEMORY_STATUSES),
+  scope: picklist(MEMORY_SCOPES),
+  supersedes: nullable(reference),
+  evidence: array(reference),
+  last_verified_at: nullable(time),
+  created_at: time,
+  updated_at: time
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/mention.js
+var kind = picklist(["phone", "email", "url", "document", "person-name", "place"]);
+var status = picklist(["found", "linked", "dismissed"]);
+var mention = strictObject({
+  id: count,
+  kind,
+  value: text,
+  domain: nullable(text),
+  confidence: number(),
+  status,
+  field: text,
+  author: nullable(text),
+  target: nullable(reference),
+  sent_at: time,
+  found_at: time,
+  written: text,
+  locator: reference
+});
+var mentionDetails = strictObject({
+  ...mention.entries,
+  before: text,
+  after: text,
+  same_value: count,
+  candidates: array(reference)
+});
+var mentionDomain = strictObject({ domain: text, links: count, chats: count, first_at: time, last_at: time });
+var place = strictObject({ id: count, address: text, mentions: count });
+var mentionDecision = strictObject({
+  kind,
+  value: text,
+  status,
+  target: nullable(reference),
+  mentions: count
+});
+var mentionRebuild = strictObject({
+  messages: count,
+  attachments: count,
+  documents: count,
+  notes: count,
+  emails: count,
+  mentions: count
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/message-change.js
+var operated3 = { operation_id: id, chat_id: id };
+var messagePin = strictObject({ ...operated3, message_id: id, pinned: boolean() });
+var messageStar = strictObject({ ...operated3, message_id: id, starred: boolean() });
+var messageDeletion = strictObject({ ...operated3, deleted: array(id), for_everyone: boolean() });
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/message-read.js
+var messageTranscript = strictObject({
+  message_id: id,
+  text,
+  pending: boolean(),
+  via: text,
+  model: optional(text)
+});
+var conversationLink = strictObject({
+  parent_id: nullable(id),
+  source: picklist(["provider", "rule", "agent"]),
+  kind: text,
+  confidence: number(),
+  method: text,
+  version: nullable(text),
+  created_at: time,
+  stale: boolean(),
+  chosen: boolean()
+});
+var messageLinks = strictObject({
+  chat: id,
+  message: id,
+  links: array(conversationLink),
+  chain: array(id)
+});
+var fingerprint2 = pipe(text, regex(/^[a-f0-9]{64}$/));
+var evidencePacket = strictObject({
+  schema_version: literal(1),
+  id,
+  kind: picklist(["chats", "news", "person"]),
+  source: strictObject({ provider: text, account: id, chat: id }),
+  fingerprint: fingerprint2,
+  limits: strictObject({ messages: count, bytes: count }),
+  content_bytes: count,
+  coverage: strictObject({
+    provided: count,
+    included: count,
+    omitted: count,
+    has_more: boolean(),
+    history: literal("unknown"),
+    truncated_by: nullable(picklist(["messages", "bytes"]))
+  }),
+  items: array(strictObject({
+    locator: reference,
+    fingerprint: fingerprint2,
+    timestamp: time,
+    edited_at: nullable(time),
+    sender_id: nullable(id),
+    sender_name: nullable(text),
+    sender_is_chat: boolean(),
+    outgoing: nullable(boolean()),
+    text,
+    reply_to: nullable(reference),
+    thread_id: nullable(id),
+    attachment_kinds: array(text)
+  }))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/message-context.js
+var messageThread = strictObject({
+  ref: reference,
+  chat: id,
+  message: id,
+  mode: picklist(["thread", "time"]),
+  fallback: optional(picklist(["not_built", "not_stored", "not_linked"])),
+  items: array(message),
+  links: array(strictObject({ ...conversationLink.entries, message_id: id })),
+  chain: array(id),
+  stale: boolean(),
+  built_at: nullable(time),
+  stopped: array(picklist(["hops", "messages", "bytes", "time", "links", "cycle", "aborted", "thread"])),
+  bounds: strictObject({ max_hops: count, max_messages: count, max_bytes: count, within_ms: count })
+});
+var messageContext = union([message, messageThread]);
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/message-counts.js
+var messageCounts = strictObject({
+  by: picklist(["chat", "sender", "day", "hour"]),
+  total: count,
+  rows: array(strictObject({
+    /** The chat or sender id, or the calendar day or hour. */
+    key: text,
+    ref: optional(reference),
+    name: nullable(text),
+    count
+  }))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/message-link.js
+var messageLink = strictObject({
+  ref: reference,
+  url: nullable(text),
+  access: picklist(["public", "restricted", "unknown", "unavailable"]),
+  /** Why there is no link. */
+  reason: nullable(picklist(["unsupported_chat", "unsupported_provider", "offline"]))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/message-write.js
+var messageWrite = strictObject({
+  operation_id: id,
+  message,
+  /** An album's messages, in order; `message` is the first. Absent for a single message. */
+  messages: optional(array(message)),
+  scheduled_for: optional(time)
+});
+var draftWrite = strictObject({
+  operation_id: id,
+  chat_id: id,
+  saved: literal(true)
+});
+var messageSend = union([messageWrite, draftWrite]);
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/model.js
+var model = strictObject({
+  id,
+  kind: picklist(["audio", "text", "image", "reranker"]),
+  title: text,
+  /** Which languages it reads, in words. */
+  languages: text,
+  licence: optional(text),
+  /** What its files take on disk once downloaded. */
+  size_bytes: count,
+  downloaded: boolean(),
+  /** The one used when no model is named. */
+  default: boolean(),
+  /** The folder its files are in once downloaded, so an agent can place them by hand. */
+  path: text
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/model-key.js
+var source = picklist(["environment", "keyring", "file"]);
+var modelKey = strictObject({
+  provider: text,
+  stored: optional(source),
+  removed: optional(array(source))
+});
+var storedModelKey = strictObject({ ...omit(modelKey, ["removed"]).entries, stored: source });
+var removedModelKey = strictObject({ ...omit(modelKey, ["stored"]).entries, removed: array(source) });
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/official-stats.js
+var versus = strictObject({ current: number(), previous: number() });
+var person = { person_ref: reference, name: nullable(text) };
+var graph = strictObject({
+  kind: text,
+  x: strictObject({ type: picklist(["date", "time", "number"]), values: array(union([text, number()])) }),
+  series: array(strictObject({ key: text, name: text, kind: text, values: array(number()) })),
+  stacked: optional(boolean()),
+  percentage: optional(boolean())
+});
+var officialStats = strictObject({
+  chat_id: id,
+  title: text,
+  kind: picklist(["group", "channel"]),
+  since: time,
+  until: time,
+  totals: record(string(), versus),
+  top: optional(strictObject({
+    posters: array(strictObject({ ...person, messages: count, average_chars: number() })),
+    admins: array(strictObject({ ...person, deleted: count, removed: count, banned: count })),
+    inviters: array(strictObject({ ...person, invited: count }))
+  })),
+  notifications: optional(strictObject({ enabled: count, total: count })),
+  recent_posts: optional(array(strictObject({
+    kind: picklist(["message", "story"]),
+    id,
+    views: count,
+    forwards: count,
+    reactions: count
+  }))),
+  /** A graph the messenger did not give is `{ error }`; the others still answer. */
+  graphs: record(string(), union([graph, strictObject({ error: text })]))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/person.js
+var person2 = strictObject({
+  ref: reference,
+  name: nullable(text),
+  identities: optional(array(identity))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/poll.js
+var poll = strictObject({
+  chat_id: id,
+  message_id: id,
+  question: text,
+  answers: array(strictObject({ id, text, voters: nullable(count), chosen: boolean() })),
+  closed: boolean(),
+  multiple: boolean(),
+  anonymous: boolean(),
+  voters: nullable(count),
+  quiz: optional(boolean()),
+  revote: optional(boolean()),
+  creator: optional(boolean())
+});
+var pollChange = strictObject({ operation_id: id, poll });
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/private-contact.js
+var contactAlias = strictObject({ person_id: id, alias: nullable(text) });
+var contactNoteRemoval = strictObject({ id, person_id: id, removed: boolean() });
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/ranking.js
+var figures = record(string(), number());
+var freshness = picklist(["fresh", "stale", "partial", "unknown"]);
+var rankingRow = strictObject({
+  rank: count,
+  /** The message's locator, or the author's `contact:` reference. */
+  ref: reference,
+  /** The message or person id, as `stats * evidence` takes it. */
+  id,
+  chat_ref: optional(reference),
+  name: nullable(text),
+  /** A message's kind (`posts`, `comments`); null for authors. */
+  kind: nullable(text),
+  value: number(),
+  components: record(string(), nullable(number())),
+  messages: count,
+  known_reactions: count,
+  unknown_reactions: count,
+  reactions: optional(array(strictObject({ reaction: string(), count }))),
+  score: nullable(strictObject({ score: number(), normalized: figures, contributions: figures })),
+  quality: strictObject({
+    reactions: picklist(["known", "partial", "unknown"]),
+    graph: picklist(["complete", "partial", "not_used"]),
+    counter_freshness: freshness
+  }),
+  counters: optional(array(counterReading)),
+  selection
+});
+var ranking = strictObject({
+  target: picklist(["messages", "contacts"]),
+  measure: text,
+  order: picklist(["ascending", "descending"]),
+  preset: nullable(text),
+  weights: nullable(figures),
+  min_messages: count,
+  message_kind: text,
+  /** Messages the query selected. */
+  total: count,
+  population: count,
+  eligible: count,
+  excluded: strictObject({ minimum: count, missing: count, unknown_sender: count, unknown_kind: count }),
+  maxima: figures,
+  counter_freshness: freshness,
+  expanded_discussion_chats: optional(array(text)),
+  rows: array(rankingRow)
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/reaction-change.js
+var reactionChange = strictObject({
+  operation_id: id,
+  chat_id: id,
+  message_id: id,
+  reaction: nullable(text)
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/recipient.js
+var recipient = strictObject({ id, title: nullable(text), partner_id: optional(id), added_at: time });
+var recipientAdded = strictObject({ id, title: nullable(text), added: boolean() });
+var recipientRemoved = strictObject({ id, title: nullable(text), removed: boolean() });
+var recipientOff = strictObject({ off: boolean(), was_on: boolean() });
+var recipientChange = strictObject({
+  ...partial(recipientAdded).entries,
+  ...partial(recipientRemoved).entries,
+  ...partial(recipientOff).entries
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/recorded-run.js
+var events = array(record(string(), unknown()));
+var recordedRun = strictObject({
+  run_id: id,
+  command: text,
+  profile: optional(text),
+  started_at: time,
+  completed_at: optional(time),
+  status: picklist(["success", "failed", "partial", "running"]),
+  requests: optional(count),
+  duration_ms: optional(count),
+  cli_version: text,
+  runtime: optional(text),
+  platform: optional(text),
+  arch: optional(text),
+  error_code: optional(text),
+  partial: optional(strictObject({
+    failed: count,
+    stop_reason: optional(text),
+    failures: array(strictObject({ id: text, stage: text, error_code: text, attachment: optional(count) }))
+  })),
+  provider_error: optional(text),
+  kept_because_failed: optional(boolean()),
+  operations: optional(array(text)),
+  codes: optional(array(text)),
+  trace_id: optional(id),
+  cli_command: optional(text),
+  argv: optional(array(text)),
+  unknown_command: optional(text),
+  agent: optional(strictObject({
+    kind: text,
+    session_id: nullable(text),
+    from_chat: optional(literal(true)),
+    client: optional(strictObject({ name: text, version: optional(text), id: optional(text) }))
+  })),
+  via: optional(picklist(["cli", "mcp-stdio", "mcp-http", "desktop"])),
+  mcp: optional(strictObject({
+    tool: text,
+    request_id: optional(text),
+    connection_id: optional(text),
+    proxied: optional(literal(true))
+  })),
+  events_dropped: optional(count),
+  error: optional(strictObject({
+    class: text,
+    code: optional(text),
+    reason: optional(text),
+    message: optional(text),
+    operation: optional(text),
+    http: optional(strictObject({ method: optional(text), endpoint_template: optional(text), status: optional(count) })),
+    provider: optional(strictObject({ key: optional(text), code: optional(number()) })),
+    causes: optional(array(strictObject({ class: text, message: optional(text) }))),
+    stack: optional(array(text))
+  })),
+  directory: optional(text),
+  event_count: optional(count),
+  events: optional(events),
+  events_truncated: optional(boolean())
+});
+var runDetails = strictObject({
+  ...omit(recordedRun, ["events_truncated"]).entries,
+  directory: text,
+  event_count: count,
+  events
+});
+var runHit = strictObject({
+  ...omit(recordedRun, ["directory", "event_count"]).entries,
+  events,
+  events_truncated: boolean()
+});
+var runLocation = strictObject({ path: text });
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/relationship.js
+var relationship = strictObject({
+  id,
+  from: reference,
+  to: reference,
+  kind: picklist(RELATION_KINDS),
+  role: nullable(text),
+  evidence: nullable(text),
+  /** An agent's suggestion stays unconfirmed, and `weak`, until the owner confirms it. */
+  confirmed: boolean(),
+  provenance: nullable(text),
+  confidence_category: picklist(["owner-confirmed", "weak"]),
+  created_at: time
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/retention.js
+var retentionCohort = strictObject({
+  /** The first day of the joining day or week. */
+  cohort: text,
+  stays: count,
+  checkpoints: array(strictObject({
+    age_ms: milliseconds,
+    eligible: count,
+    observable: count,
+    present: count,
+    absent: count,
+    unknown: count,
+    pending: count,
+    rate: nullable(number())
+  })),
+  activity: strictObject({ observed: count, no_observed: count, pending: count, archive_covered: count }),
+  early_departure: strictObject({ observed: count, not_observed: count, unknown: count, pending: count }),
+  selection
+});
+var retention = strictObject({
+  chat_ref: reference,
+  cutoff: time,
+  since: time,
+  until: time,
+  checkpoints_ms: array(milliseconds),
+  within_ms: milliseconds,
+  by: picklist(["day", "week"]),
+  timezone: text,
+  /** Cohorts found; `rows` holds the first `--limit` of them. */
+  total: count,
+  unknown_join: count,
+  eligible_stays: count,
+  quality: strictObject({
+    membership: text,
+    tolerance_ms: milliseconds,
+    archive: nullable(strictObject({
+      state: text,
+      up_to_date: nullable(boolean()),
+      gaps: boolean(),
+      reaches_start: boolean(),
+      fetched_at: nullable(time)
+    })),
+    continuous_survival: boolean(),
+    group_silent_rate: nullable(number())
+  }),
+  rows: array(retentionCohort)
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/send-attempt.js
+var sendAttempt = strictObject({
+  at: time,
+  profile: text,
+  chat_id: nullable(id),
+  outcome: picklist(["sent", "outcome_unknown", "refused", "failed", "reserved"]),
+  kind: optional(picklist(["message", "reaction", "edit", "forward", "pin", "read", "delete", "chat", "account"])),
+  action: optional(text),
+  people: optional(count),
+  message_id: optional(id),
+  key: optional(text),
+  count: optional(count),
+  for_everyone: optional(boolean()),
+  operation_id: optional(id),
+  parent_operation_id: optional(id),
+  reply_to: optional(id),
+  thread_id: optional(id),
+  send_as: optional(id),
+  result_chat_id: optional(id),
+  length: optional(count),
+  attachments: optional(array(strictObject({ kind: picklist(["photo", "file", "video", "voice", "sticker"]), bytes: count }))),
+  scheduled_for: optional(time),
+  notify: optional(boolean()),
+  origin: optional(text),
+  reservation: optional(id),
+  error_code: optional(text)
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/store-maintenance.js
+var absent = strictObject({ path: text, exists: literal(false) });
+var schema = strictObject({ version: count, min_compatible: count, writable: boolean(), speaks: count });
+var infoSchema = strictObject({
+  ...schema.entries,
+  reason: picklist(["missing", "older", "current", "newer", "too_new"]),
+  upgrade: nullable(strictObject({ version: count, min_compatible: count }))
+});
+var client = strictObject({ command: text, version: text, core: text, speaks: count, seen_at: time });
+var wordIndex = strictObject({
+  watermark: count,
+  filled_through: count,
+  pending_normalization: count,
+  ready: boolean(),
+  terms_through: count,
+  newest: count,
+  terms_ready: boolean(),
+  built_at: nullable(time)
+});
+var stemIndex = strictObject({
+  watermark: count,
+  filled_through: count,
+  pending: count,
+  built: nullable(text),
+  wanted: text,
+  ready: boolean(),
+  cause: optional(picklist(["building", "stemmer_changed", "stemmer_unknown"])),
+  built_at: nullable(time)
+});
+var readFailure = { path: text, exists: literal(true), opens: literal(false), error: text };
+var rows = partial(strictObject({
+  accounts: count,
+  chats: count,
+  messages: count,
+  emails: count,
+  documents: count,
+  meetings: count,
+  events: count,
+  attachments: count,
+  identities: count
+}));
+var perAccount = { chats: count, messages: count, emails: count, documents: count, meetings: count };
+var contents = {
+  by_provider: optional(array(strictObject({ provider: text, accounts: count, ...perAccount }))),
+  by_chat_kind: optional(array(strictObject({ provider: text, kind: text, chats: count, messages: count }))),
+  /** `name` is the one `account list` shows; the messenger's own id for the account is left out. */
+  by_account: optional(array(strictObject({ provider: text, account_id: count, name: nullable(text), ...perAccount }))),
+  /** Calendar years in UTC. */
+  by_year: optional(array(strictObject({ provider: text, year: count, messages: count }))),
+  /** `type` is what the file is attached to: a message, an email, a document… `bytes` counts the sizes known. */
+  by_attachment_kind: optional(array(strictObject({ type: text, kind: text, count, bytes: count })))
+};
+var storeInfo = union([
+  strictObject({ ...absent.entries, schema: infoSchema }),
+  strictObject({ ...readFailure, schema: strictObject({ speaks: count }) }),
+  strictObject({
+    path: text,
+    exists: literal(true),
+    bytes: strictObject({ file: count, wal: count }),
+    journal_mode: text,
+    /** `free` pages hold nothing; a `VACUUM` would give them back. */
+    pages: strictObject({ size: count, count, free: count }),
+    migrations: array(strictObject({ version: count, min_compatible: count, applied_at: time })),
+    /** From the marker a backup job leaves in `backups/last.json` beside the store; null without one. */
+    backup: nullable(strictObject({ at: time, file: nullable(text), checked: nullable(text) })),
+    schema: infoSchema,
+    clients: array(client),
+    rows,
+    pending_normalization: nullable(count),
+    word_index: nullable(wordIndex),
+    stem_index: nullable(stemIndex),
+    ...contents
+  })
+]);
+var storeCheck = union([
+  strictObject({ ...absent.entries, ok: literal(true) }),
+  strictObject({ ...readFailure, ok: literal(false) }),
+  strictObject({
+    path: text,
+    exists: literal(true),
+    opens: literal(true),
+    ok: boolean(),
+    checks: strictObject({
+      schema: boolean(),
+      integrity: boolean(),
+      foreign_keys: boolean(),
+      search_indexes: boolean(),
+      vector_indexes: boolean(),
+      disk: boolean()
+    }),
+    schema,
+    integrity: array(text),
+    foreign_key_violations: count,
+    search_indexes: record(text, text),
+    disk: strictObject({ free: count, needed: count }),
+    pending_normalization: nullable(count),
+    word_index: nullable(wordIndex),
+    stem_index: nullable(stemIndex),
+    chats_behind: array(strictObject({
+      provider: text,
+      account: text,
+      chat: text,
+      title: nullable(text),
+      newest: time,
+      held: nullable(time),
+      refreshed: time
+    })),
+    orphan_pointers: array(strictObject({ table: text, pointer: text, type: text, count, known: boolean() })),
+    conversations: array(strictObject({
+      provider: text,
+      account: text,
+      chat: text,
+      title: nullable(text),
+      built_at: nullable(time),
+      rules_version: nullable(count),
+      current: boolean(),
+      stale_agent_links: count
+    })),
+    vectors: nullable(strictObject({ models: record(text, count), unused: count })),
+    vector_indexes: array(strictObject({
+      model: text,
+      dims: count,
+      ready: boolean(),
+      indexed: count,
+      expected: count,
+      missing: count,
+      extra: count
+    }))
+  })
+]);
+var indexed = { normalized: count, indexed: count, terms: count, stemmed: count, notes_indexed: count };
+var storeMigration = union([
+  absent,
+  strictObject({ path: text, exists: literal(true), from: count, to: count, ...indexed })
+]);
+var storeReindex = union([
+  absent,
+  strictObject({
+    path: text,
+    exists: literal(true),
+    ...indexed,
+    file_texts: count,
+    involvements: count,
+    unused_vectors_dropped: count
+  })
+]);
+var storeBackup = strictObject({
+  path: text,
+  from: text,
+  bytes: count,
+  schema: count,
+  rows: strictObject({ chats: count, messages: count }),
+  encrypted: optional(literal(true))
+});
+var storeDecrypt = strictObject({ path: text, from: text, bytes: count });
+var storeRestore = strictObject({
+  path: text,
+  restored_from: text,
+  kept_at: nullable(text),
+  schema: count
+});
+var storeReset = union([
+  strictObject({ ...absent.entries, reset: literal(false) }),
+  strictObject({
+    path: text,
+    exists: literal(true),
+    reset: literal(false),
+    dry_run: literal(true),
+    files: array(text),
+    bytes: count,
+    schema: count,
+    tables: array(strictObject({ name: text, rows: count })),
+    backup_first: boolean(),
+    in_use: nullable(boolean())
+  }),
+  strictObject({
+    path: text,
+    exists: literal(true),
+    reset: literal(true),
+    backup: nullable(text),
+    backed_up: nullable(strictObject({ schema: count, rows: partial(strictObject({ chats: count, messages: count })) })),
+    schema: count
+  })
+]);
+var storeRepair = union([
+  absent,
+  strictObject({
+    path: text,
+    dry_run: boolean(),
+    repaired: array(strictObject({
+      table: text,
+      action: picklist(["created", "columns-added", "rebuilt"]),
+      columns_added: optional(array(text)),
+      copy: optional(text),
+      rows_in_copy: optional(count),
+      rows_copied: optional(count),
+      only_in_copy: optional(array(text)),
+      dropped_from_copy: optional(array(text))
+    })),
+    indexes_created: array(text),
+    triggers_created: array(text),
+    mismatches: array(strictObject({ table: text, what: text })),
+    foreign_key_violations: array(strictObject({ table: text, rows: count })),
+    copies: array(strictObject({ name: text, rows: count }))
+  })
+]);
+var storeCopyRemoval = strictObject({ path: text, deleted: strictObject({ name: text, rows: count }) });
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/tag-change.js
+var tagTarget = variant("type", [
+  strictObject({ type: literal("chat"), chat_id: id }),
+  strictObject({ type: literal("contact"), person_id: id }),
+  strictObject({ type: literal("message"), chat_id: id, message_id: id, locator: reference }),
+  strictObject({ type: literal("task"), task_id: id })
+]);
+var receipt = { target: tagTarget, unchanged: array(text) };
+var tagChange = union([
+  strictObject({ ...receipt, added: array(text) }),
+  strictObject({ ...receipt, removed: array(text) })
+]);
+var automaticTags = strictObject({
+  items: array(union([
+    strictObject({
+      chat_id: id,
+      tags: array(strictObject({
+        tag: text,
+        score: number(),
+        fields: array(picklist(["title", "username", "description"]))
+      })),
+      algorithm: text,
+      fetched_at: nullable(time),
+      source: picklist(["metadata", "stored-chat"])
+    }),
+    strictObject({ chat_id: id, error: strictObject({ code: text, message: text }) })
+  ])),
+  has_more: boolean(),
+  dry_run: boolean()
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/task-pair.js
+var side = strictObject({ ref: reference, key: text, title: text, status: text });
+var taskPair = strictObject({
+  task: nullable(side),
+  source: nullable(reference),
+  other: side,
+  score: number(),
+  band: picklist(["likely", "maybe", "different"]),
+  levels: strictObject({
+    text: picklist(["high", "middle", "low"]),
+    person: picklist(["same", "different", "unknown"]),
+    amount: picklist(["equal", "different", "missing"]),
+    category: picklist(["same", "different", "unknown"]),
+    due: picklist(["near", "far", "missing"]),
+    reply: picklist(["yes", "no"]),
+    time: picklist(["near", "weeks", "far"])
+  }),
+  reasons: array(text),
+  decision: picklist(["review", "unsure", "merged", "rejected", "unmerged", "attached", "new"]),
+  decided_at: nullable(time),
+  created_at: time
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/task-results.js
+var nullableTime = nullable(time);
+var link = strictObject({
+  id,
+  from: reference,
+  to: nullable(reference),
+  kind: picklist(LINK_KINDS),
+  anchor: nullable(text),
+  origin: picklist(LINK_SOURCES),
+  target_text: nullable(text),
+  role: nullable(text),
+  evidence: nullable(text),
+  provenance: nullable(text),
+  confirmed: boolean(),
+  created_at: time
+});
+var taskCard = strictObject({
+  id,
+  ref: reference,
+  key: text,
+  project: reference,
+  title: text,
+  description: nullable(text),
+  type: picklist(TASK_TYPES),
+  status: picklist(TASK_STATES),
+  priority: nullable(number()),
+  parent: nullable(reference),
+  source: nullable(text),
+  due_at: nullableTime,
+  next_check_at: nullableTime,
+  closed_at: nullableTime,
+  reason: nullable(text),
+  verdict: nullable(picklist(TASK_VERDICTS)),
+  category: nullable(text),
+  claimed_by: nullable(text),
+  claimed_until: nullableTime,
+  close_certainty: nullable(number()),
+  close_suggestion: nullable(closeSuggestion),
+  assignments: array(strictObject({ to: reference, role: picklist(["assignee", "reviewer", "watcher"]) })),
+  created_at: time,
+  updated_at: time,
+  links: array(link),
+  linked_from: array(link)
+});
+var taskView = strictObject({
+  id,
+  source: text,
+  source_kind: text,
+  account: text,
+  group: text,
+  kind: picklist(TASK_KINDS),
+  state: picklist(TASK_STATES),
+  reason: optional(text),
+  origin: picklist(TASK_ORIGINS),
+  created_at: time,
+  due_at: optional(time),
+  closed_at: optional(time),
+  closed_by: optional(picklist(TASK_ORIGINS)),
+  key: optional(text),
+  category: optional(text),
+  claimed_by: optional(text),
+  claimed_until: optional(time),
+  message: nullable(strictObject({ sender_name: nullable(text), text, timestamp: time })),
+  note: optional(nullable(strictObject({ id, title: nullable(text), text, updated_at: time })))
+});
+var taskCreated = strictObject({
+  ...taskView.entries,
+  created: boolean(),
+  attached: optional(literal(true)),
+  review: optional(count),
+  follow_up_of: optional(taskPair.entries.other),
+  card: optional(taskCard)
+});
+var taskClosed = strictObject({
+  ...taskView.entries,
+  close_certainty: nullable(number()),
+  close_suggestion: nullable(closeSuggestion)
+});
+var taskLinks = union([
+  strictObject({ ...taskCard.entries, review: optional(count) }),
+  strictObject({
+    relations: array(strictObject({
+      id,
+      from: reference,
+      to: reference,
+      kind: picklist(["blocked-by", "follow-up-of", "related-to", "duplicate-of", "discovered-from"])
+    }))
+  })
+]);
+var taskSimilar = strictObject({
+  ref: reference,
+  key: text,
+  title: text,
+  status: text,
+  created_at: time,
+  found_by: array(picklist(["text", "person", "category", "reply"])),
+  score: number(),
+  band: taskPair.entries.band,
+  levels: taskPair.entries.levels,
+  reasons: array(text),
+  text: strictObject({ shared_stems: count, all_stems: count, stems: number(), trigrams: number() })
+});
+var taskMerge = strictObject({ pair: taskPair, linked: count, review: count, task: taskCard });
+var taskUnmerge = strictObject({ pair: taskPair, task: taskCard });
+var taskCategories = strictObject({
+  categories: array(strictObject({
+    name: text,
+    meaning: text,
+    triggers: strictObject({ en: array(text), ru: array(text), es: array(text) })
+  })),
+  unlisted: array(strictObject({ name: text, open: count, total: count })),
+  file: nullable(text)
+});
+var taskScan = strictObject({
+  chat: text,
+  messages: count,
+  added: count,
+  closed: count,
+  review: count,
+  held: optional(count),
+  held_chats: optional(count),
+  tasks: array(strictObject({ source: text, kind: picklist(TASK_KINDS), category: nullable(text) }))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/topic.js
+var topic = strictObject({
+  id,
+  title: text,
+  closed: boolean(),
+  pinned: boolean(),
+  /** The General topic only, where the messenger says. */
+  hidden: optional(boolean()),
+  unread_count: nullable(count),
+  last_message_at: nullable(time),
+  created_at: nullable(time),
+  untrusted
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/entities/index.js
+var ENTITIES = {
+  sync_progress: progress,
+  ...MEETING_RESULT_ENTITIES,
+  message,
+  message_context: messageContext,
+  message_download: messageDownload,
+  message_sync: messageSync,
+  "message.hit": strictObject({
+    ...pick(message, [
+      "ref",
+      "chat_title",
+      "timestamp",
+      "sender_name",
+      "excerpt",
+      "matched_in",
+      "score",
+      "match",
+      "corrections",
+      "found_in",
+      "discovery",
+      "context",
+      "email"
+    ]).entries,
+    untrusted
+  }),
+  "message.summary": pick(message, [
+    "ref",
+    "chat_id",
+    "chat_title",
+    "timestamp",
+    "sender_name",
+    "outgoing",
+    "text",
+    "transcript",
+    "attachments"
+  ]),
+  message_link: messageLink,
+  message_write: messageWrite,
+  message_send: messageSend,
+  message_pin: messagePin,
+  message_star: messageStar,
+  message_deletion: messageDeletion,
+  message_transcript: messageTranscript,
+  message_links: messageLinks,
+  evidence_packet: evidencePacket,
+  chat_metadata: cachedChatMetadata,
+  chat_metadata_refresh: chatMetadataRefresh,
+  chat,
+  mention,
+  "mention.details": mentionDetails,
+  mention_domain: mentionDomain,
+  mention_decision: mentionDecision,
+  mention_rebuild: mentionRebuild,
+  place,
+  person: person2,
+  identity,
+  contact_context: contactContext,
+  contact_preparation: contactPreparation,
+  contact_activity: contactActivity,
+  contact_check: contactCheck,
+  linked_person: linkedPerson,
+  contact,
+  contact_note: contactNote,
+  contact_lookup: contactLookup,
+  contact_profile: contactProfile,
+  contact_sync: contactSync,
+  contact_update: contactUpdate,
+  contact_state_change: contactStateChange,
+  contact_import: contactImport,
+  contact_alias: contactAlias,
+  contact_note_removal: contactNoteRemoval,
+  account,
+  account_session: accountSession,
+  account_change: accountChange,
+  ended_account_sessions: endedAccountSessions,
+  account_privacy: accountPrivacy,
+  account_privacy_change: accountPrivacyChange,
+  account_profile: accountProfile,
+  organization,
+  project,
+  reminder,
+  bot_profile: botProfile,
+  bot_template: botTemplate,
+  bot_seen_chat: botSeenChat,
+  bot_admin: botAdmin,
+  bot_menu_entry: botMenuEntry,
+  bot_webhook: botWebhook,
+  scheduled_job: scheduledJob,
+  call_record: callRecord,
+  sticker_inventory: stickerInventory,
+  note,
+  "note.hit": strictObject({
+    ...pick(note, [
+      "kind",
+      "provider",
+      "account",
+      "url",
+      "ref",
+      "source",
+      "folder_id",
+      "path",
+      "title",
+      "updated_at",
+      "excerpt",
+      "found_by",
+      "links"
+    ]).entries,
+    untrusted
+  }),
+  hit,
+  document,
+  document_link: documentLink,
+  image_embedding: imageEmbedding,
+  attachment,
+  attachment_bytes: attachmentBytes,
+  attachment_extraction: attachmentExtraction,
+  attachment_text_change: attachmentTextChange,
+  media_archive: mediaArchive,
+  media_archive_check: mediaArchiveCheck,
+  media_archive_move: mediaArchiveMove,
+  media_archive_timer: mediaArchiveTimer,
+  task,
+  task_pair: taskPair,
+  task_card: taskCard,
+  task_created: taskCreated,
+  task_closed: taskClosed,
+  task_links: taskLinks,
+  task_similar: taskSimilar,
+  task_merge: taskMerge,
+  task_unmerge: taskUnmerge,
+  task_categories: taskCategories,
+  task_scan: taskScan,
+  fact,
+  memory,
+  meeting,
+  meeting_details: meetingDetails,
+  meeting_hit: meetingHit,
+  meeting_series_inventory: meetingSeriesInventory,
+  meeting_project_candidates: meetingProjectCandidates,
+  meeting_project_evidence: meetingProjectEvidence,
+  meeting_preparation: meetingPreparation,
+  meeting_findings: meetingFindings,
+  meeting_transcript: meetingTranscript,
+  meeting_summary: meetingSummary,
+  meeting_evidence: meetingEvidence,
+  meeting_person_context: meetingPersonContext,
+  event,
+  meeting_review: meetingReview,
+  meeting_link: meetingLink,
+  meeting_stats: meetingStats,
+  meeting_speaker: meetingSpeaker,
+  meeting_participants: meetingParticipants,
+  meeting_passage: meetingPassage,
+  meeting_task_proposal: meetingTaskProposal,
+  reference,
+  relationship,
+  recipient,
+  recipient_change: recipientChange,
+  "recipient_change.added": recipientAdded,
+  "recipient_change.removed": recipientRemoved,
+  "recipient_change.off": recipientOff,
+  run: recordedRun,
+  "run.details": runDetails,
+  "run.hit": runHit,
+  run_location: runLocation,
+  tag_change: tagChange,
+  automatic_tags: automaticTags,
+  send_attempt: sendAttempt,
+  tagging,
+  "conversation.details": conversationDetails,
+  conversation_build: conversationBuildResult,
+  conversation_batch_status: conversationBatchStatus,
+  conversation_batch: conversationBatch,
+  conversation_change: conversationChange,
+  conversation_readiness: conversationReadiness,
+  conversation_embedding: conversationEmbedding,
+  conversation_embedding_status: conversationEmbeddingStatus,
+  conversation_preparation: conversationPreparation,
+  conversation_hit: conversationHit,
+  conversation,
+  saved_search: savedSearch,
+  search_history_clear: searchHistoryClear,
+  watch_item: watchItem,
+  serve_summary: serveSummary,
+  job,
+  store_chat_status: storeChatStatus,
+  store_clear: storeClear,
+  store_export: storeExport,
+  store_gap_plan: storeGapPlan,
+  store_gap_repair: storeGapRepair,
+  store_job_details: storeJobDetails,
+  store_job_cancel: storeJobCancel,
+  store_job_retry: storeJobRetry,
+  store_job_clear: storeJobClear,
+  store_info: storeInfo,
+  store_check: storeCheck,
+  store_migration: storeMigration,
+  store_reindex: storeReindex,
+  store_backup: storeBackup,
+  store_decrypt: storeDecrypt,
+  store_restore: storeRestore,
+  store_reset: storeReset,
+  store_repair: storeRepair,
+  store_copy_removal: storeCopyRemoval,
+  store_table: storeTable,
+  agenda,
+  model,
+  chat_group_change: chatGroupChange,
+  chat_inspection: chatInspection,
+  chat_sender: chatSender,
+  chat_read: chatRead,
+  chat_members_fetch: chatMembersFetch,
+  chat_members_change: chatMembersChange,
+  chat_invite: chatInvite,
+  chat_invite_change: chatInviteChange,
+  chat_request_change: chatRequestChange,
+  chat_admin_change: chatAdminChange,
+  chat_folder_change: chatFolderChange,
+  chat_folder_removal: chatFolderRemoval,
+  chat_folder_order: chatFolderOrder,
+  chat_rules: chatRules,
+  chat_moderation: chatModeration,
+  model_key: modelKey,
+  "model_key.stored": storedModelKey,
+  "model_key.removed": removedModelKey,
+  chat_event: chatEvent,
+  chat_removal: chatRemoval,
+  chat_muting: chatMuting,
+  chat_archive: chatArchive,
+  chat_pin: chatPin,
+  chat_unread: chatUnread,
+  invite_link: inviteLink,
+  join_request: joinRequest,
+  member,
+  poll,
+  poll_change: pollChange,
+  poll_vote: pollVote,
+  reaction_change: reactionChange,
+  topic,
+  folder,
+  message_counts: messageCounts,
+  ranking,
+  admin_report: adminReport,
+  analysis_consent: analysisConsent,
+  analysis_consent_revocation: analysisConsentRevocation,
+  retention,
+  evidence,
+  counters,
+  counter_refresh: counterRefresh,
+  official_stats: officialStats,
+  chart,
+  chat_stats: chatStats,
+  tracked_chat: trackedChat,
+  tracked_chat_history: trackedChatHistory,
+  chat_tracking: chatTracking,
+  task_stats: taskStats
+};
+var entityDefinitions = /* @__PURE__ */ __name(() => Object.fromEntries(Object.entries(ENTITIES).map(([name, schema2]) => {
+  const { $schema: _, ...definition } = jsonSchemaOf(schema2);
+  return [name, definition];
+})), "entityDefinitions");
+
+export {
+  accountSession,
+  accountProfile,
+  analysisConsent,
+  member,
+  chat,
+  folder,
+  inviteLink,
+  chatEvent,
+  contact,
+  message,
+  contactNote,
+  documentLink,
+  checkpointPath,
+  readCheckpoint,
+  saveCheckpoint,
+  progressOf,
+  spawnDetached,
+  jobsDir,
+  saveJob,
+  readJob,
+  tracedJob,
+  jobStarted,
+  finishJob,
+  updateJob,
+  removeJob,
+  listJobs,
+  jobDetails,
+  jobItem,
+  stateOf,
+  startArchiveJob,
+  job,
+  joinRequest,
+  botProfile,
+  botSeenChat,
+  botAdmin,
+  botMenuEntry,
+  botWebhook,
+  scheduledJob,
+  botTemplate,
+  callRecord,
+  stickerInventory,
+  pollVote,
+  meetingPreparation,
+  meetingProjectCandidates,
+  meetingSeriesInventory,
+  model,
+  recipient,
+  recordedRun,
+  savedSearch,
+  sendAttempt,
+  progress,
+  topic,
+  ENTITIES,
+  entityDefinitions
+};