@ai-matrx/desktop-protocol 0.21.29 → 0.21.30

package/dist/client.js

@@ -112,7 +112,7 @@ import { z as z2 } from "zod";
 import { z } from "zod";
 import { UUID_SHAPE_PATTERN } from "@ai-matrx/kit/uuid";
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 37;
+var PROTOCOL_MINOR = 39;
 var PROTOCOL_VERSION = `${PROTOCOL_MAJOR}.${PROTOCOL_MINOR}`;
 var ProtocolVersion = z.string().regex(/^[1-9][0-9]{0,2}\.[0-9]{1,3}$/);
 var RequestId = z.string().min(1).max(64).regex(/^[A-Za-z0-9_-]+$/);
@@ -1074,7 +1074,22 @@ var AccountAgent = z14.strictObject({
   shared_by: z14.string().max(320).nullable(),
   /** The organization it belongs to. */
   organization: z14.string().max(200).nullable(),
-  updated_at_ms: epochMs
+  updated_at_ms: epochMs,
+  // 1.39: the catalogue's own row (agx_get_list_full, read whole through @ai-matrx/agents/catalog).
+  /** The agent's tags (the library's search and its inspector). */
+  tags: z14.array(z14.string().max(120)).max(50).optional(),
+  /** The model it runs (a model catalogue id); absent when it names none. */
+  model_id: AccountRowId.optional(),
+  /** The person's access: owner, admin, editor, viewer or system (the database's own words); absent when unknown. */
+  access_level: z14.string().min(1).max(40).optional(),
+  /** The organization's id (the label is `organization`); absent when it has none. */
+  organization_id: AccountRowId.optional(),
+  /** Whose it is: the person's own, shared with them, or one AI Matrx ships (Gallery). */
+  origin: z14.enum(["mine", "shared", "system"]).optional(),
+  /** Archived (the catalogue's archive filter decides whether the library lists it). */
+  is_archived: z14.boolean().optional(),
+  /** An orchestra: it conducts other agents. */
+  orchestra: z14.boolean().optional()
 });
 var AccountAgentsListParams = z14.strictObject({});
 var AccountAgentsListResult = z14.strictObject({
@@ -1083,6 +1098,70 @@ var AccountAgentsListResult = z14.strictObject({
   problem: z14.string().max(300).nullable(),
   agents: z14.array(AccountAgent).max(2e3)
 });
+var AccountAgentVariable = z14.strictObject({
+  name: z14.string().min(1).max(200),
+  /** The default value as text ("" when it has none). */
+  default_value: z14.string().max(4e3),
+  required: z14.boolean(),
+  help: z14.string().max(1e3)
+});
+var AccountAgentDetail = z14.strictObject({
+  agent: AccountAgent,
+  /** The inputs a run asks for (the agent's variables). */
+  variables: z14.array(AccountAgentVariable).max(100),
+  /** How many tools, custom tools, skills and connections it may use. */
+  tool_count: z14.int().min(0),
+  custom_tool_count: z14.int().min(0),
+  skill_count: z14.int().min(0),
+  connection_count: z14.int().min(0),
+  /** The model's display name when the catalogue knows it. */
+  model_name: z14.string().max(200).nullable()
+});
+var AccountAgentsGetParams = z14.strictObject({ agent_id: AccountRowId });
+var AccountAgentsGetResult = z14.strictObject({
+  state: AccountReadState,
+  problem: z14.string().max(300).nullable(),
+  /** Null when the person cannot open it (not theirs, not shared with them, or gone). */
+  detail: AccountAgentDetail.nullable()
+});
+var AccountAgentRunStatus = z14.enum(["succeeded", "warned", "failed", "stopped", "waiting", "running"]);
+var AccountAgentRun = z14.strictObject({
+  run_id: AccountRowId,
+  status: AccountAgentRunStatus,
+  started_at_ms: epochMs,
+  completed_at_ms: epochMs.nullable(),
+  duration_ms: z14.int().min(0).nullable(),
+  cost: z14.number().min(0).nullable(),
+  tokens: z14.int().min(0).nullable(),
+  /** One line of the answer (at most 240 characters), when the run kept one. */
+  output_preview: z14.string().max(240).nullable(),
+  /** The run's error, one line. */
+  error: z14.string().max(300).nullable(),
+  /** The mandate it served, when one named it. */
+  mandate_key: z14.string().max(200).nullable(),
+  organization: z14.string().max(200).nullable(),
+  /** The conversation that holds its transcript, when it kept one. */
+  conversation_id: AccountRowId.nullable(),
+  has_transcript: z14.boolean()
+});
+var AccountAgentRunSort = z14.enum(["started_at", "duration", "cost", "status"]);
+var AccountAgentsRunsParams = z14.strictObject({
+  agent_id: AccountRowId,
+  status: AccountAgentRunStatus.optional(),
+  sort: AccountAgentRunSort.optional(),
+  descending: z14.boolean().optional(),
+  offset: z14.int().min(0).max(1e5).optional(),
+  limit: z14.int().min(1).max(100).optional()
+});
+var AccountAgentsRunsResult = z14.strictObject({
+  state: AccountReadState,
+  problem: z14.string().max(300).nullable(),
+  /** Every run of this agent the person may see (rows is one page of it). */
+  total: z14.int().min(0),
+  rows: z14.array(AccountAgentRun).max(100)
+});
+var AccountAgentsFavoriteParams = z14.strictObject({ agent_id: AccountRowId, favorite: z14.boolean() });
+var AccountAgentsFavoriteResult = z14.strictObject({ favorite: z14.boolean() });
 var VaultItemKind = z14.enum(["login", "passkey", "key", "other"]);
 var VaultFieldSummary = z14.strictObject({
   key: z14.string().min(1).max(120),
@@ -1992,24 +2071,389 @@ var CodingHistoryProgressEvent = z27.strictObject({
   failed: nonNegInt
 });
 
-// src/schema/apps.ts
+// src/schema/coding-sessions.ts
 import { z as z28 } from "zod";
+var CodingProviderName = z28.enum(["claude", "codex"]);
+var CodingRunStatus = z28.enum(["starting", "running", "completed", "stopped", "failed"]);
+var SessionKey = z28.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+var IsoTime = z28.string().min(10).max(40);
+var LocalPath = z28.string().min(1).max(4096);
+var CodingClientRequestId = z28.string().regex(/^[A-Za-z0-9_-]{8,64}$/);
+var ShortText = z28.string().max(500);
+var CodingRunUsage = z28.strictObject({
+  inputTokens: nonNegInt,
+  outputTokens: nonNegInt,
+  cachedInputTokens: nonNegInt
+});
+var CodingStartedBy = z28.strictObject({
+  kind: z28.enum(["this_computer", "web", "phone", "agent", "other"]),
+  label: z28.string().min(1).max(80)
+});
+var CodingRunRecord = z28.strictObject({
+  runId: z28.string().min(1).max(64),
+  sessionId: SessionKey,
+  provider: CodingProviderName,
+  cwd: LocalPath,
+  prompt: z28.string().max(1048576),
+  model: z28.string().max(200).nullable(),
+  status: CodingRunStatus,
+  startedAt: IsoTime,
+  endedAt: IsoTime.nullable(),
+  error: z28.string().max(65536).nullable(),
+  usage: CodingRunUsage.nullable(),
+  costUsd: z28.number().nullable(),
+  billing: z28.enum(["subscription", "api", "unknown"]).nullable(),
+  startedBy: CodingStartedBy.nullable()
+});
+var CodingSessionAgentPart = z28.strictObject({
+  part: z28.enum(["instructions", "skills", "tools"]),
+  loaded: nonNegInt,
+  total: nonNegInt
+});
+var CodingSessionAgent = z28.strictObject({
+  agentId: z28.string().min(1).max(64),
+  versionId: z28.string().max(64).nullable(),
+  versionNumber: nonNegInt.nullable(),
+  name: z28.string().max(300),
+  definitionHash: z28.string().max(200),
+  loaded: z28.array(CodingSessionAgentPart).max(3),
+  unavailable: z28.array(z28.strictObject({ kind: z28.string().max(60), name: z28.string().max(300), reason: ShortText })).max(500),
+  skills: z28.array(z28.string().max(300)).max(500),
+  tools: z28.array(z28.string().max(300)).max(500),
+  variables: z28.record(z28.string().max(200), z28.unknown()),
+  blockDue: z28.boolean(),
+  deliveredAt: IsoTime.nullable(),
+  replaces: z28.string().max(300).nullable()
+});
+var CodingSessionRecord = z28.strictObject({
+  id: SessionKey,
+  provider: CodingProviderName,
+  providerSessionId: SessionKey.nullable(),
+  cwd: LocalPath,
+  title: z28.string().max(500),
+  model: z28.string().max(200).nullable(),
+  effort: z28.string().max(40).nullable(),
+  origin: z28.enum(["started", "takeover"]),
+  createdAt: IsoTime,
+  updatedAt: IsoTime,
+  lastRunId: z28.string().max(64).nullable(),
+  lastRunStatus: CodingRunStatus.nullable(),
+  queued: z28.array(z28.string().max(1048576)).max(100),
+  agent: CodingSessionAgent.nullable(),
+  agentRemovedDue: z28.boolean()
+});
+var CodingActiveElsewhere = z28.strictObject({
+  reason: z28.enum(["process", "recent-write", "open-tool-call", "open"]),
+  message: ShortText,
+  /** The process driving it, when the evidence is a process (re-checked before any stop). */
+  pid: z28.int().min(1).nullable()
+});
+var CodingTitleSource = z28.enum(["app", "app-remembered", "custom-title", "ai-title", "agent-name", "summary", "first-prompt", "last-prompt", "unknown"]);
+var CodingDiscoveredChat = z28.strictObject({
+  provider: CodingProviderName,
+  providerSessionId: SessionKey,
+  cwd: LocalPath.nullable(),
+  title: z28.string().max(500),
+  titleSource: CodingTitleSource.optional(),
+  titlePending: z28.boolean().optional(),
+  archived: z28.boolean().optional(),
+  scheduled: z28.boolean().optional(),
+  unlisted: z28.boolean().optional(),
+  unavailable: ShortText.nullable(),
+  updatedAt: IsoTime,
+  source: z28.string().max(60).nullable(),
+  activeElsewhere: CodingActiveElsewhere.nullable()
+});
+var CodingTranscriptItem = z28.discriminatedUnion("kind", [
+  z28.strictObject({ kind: z28.literal("user"), id: z28.string().max(200), text: z28.string(), at: IsoTime.nullable() }),
+  z28.strictObject({ kind: z28.literal("text"), id: z28.string().max(200), text: z28.string() }),
+  z28.strictObject({ kind: z28.literal("text-delta"), id: z28.string().max(200), text: z28.string() }),
+  z28.strictObject({ kind: z28.literal("reasoning"), id: z28.string().max(200), text: z28.string() }),
+  z28.strictObject({ kind: z28.literal("tool-call"), id: z28.string().max(200), name: z28.string().max(300), input: z28.unknown() }),
+  z28.strictObject({
+    kind: z28.literal("tool-result"),
+    id: z28.string().max(200),
+    output: z28.string(),
+    isError: z28.boolean(),
+    /** The output's full size when only its start is here; `coding.item.full` reads the rest. */
+    fullBytes: nonNegInt.optional()
+  }),
+  z28.strictObject({ kind: z28.literal("usage"), usage: CodingRunUsage, costUsd: z28.number().nullable() }),
+  z28.strictObject({ kind: z28.literal("notice"), id: z28.string().max(200), level: z28.enum(["info", "warning"]), text: z28.string() }),
+  z28.strictObject({ kind: z28.literal("error"), id: z28.string().max(200), text: z28.string() })
+]);
+var CodingHistoryRecord = z28.strictObject({
+  items: z28.array(CodingTranscriptItem),
+  /** Only the end of the chat is here; "Show earlier" reads more (a bigger `max_bytes`). */
+  truncated: z28.boolean(),
+  unavailable: ShortText.nullable(),
+  /** The last live item `seq` this read already contains; a watch applies only newer ones. */
+  seq: nonNegInt
+});
+var CodingQuotaWindow = z28.strictObject({
+  label: z28.string().max(120),
+  usedPercent: z28.number().nullable(),
+  resetsAt: z28.string().max(80).nullable(),
+  valueLabel: z28.string().max(120).nullable()
+});
+var CodingProviderProblem = z28.strictObject({
+  kind: z28.enum(["usage-limit", "signed-out"]),
+  message: z28.string().max(2e3),
+  until: z28.string().max(120).nullable(),
+  at: IsoTime
+});
+var CodingProviderBinary = z28.strictObject({
+  path: LocalPath,
+  version: z28.string().max(80).nullable(),
+  source: z28.enum(["desktop-app", "path", "npm-global", "configured"]),
+  sourceLabel: z28.string().max(120),
+  newer: z28.strictObject({ path: LocalPath, version: z28.string().max(80), sourceLabel: z28.string().max(120) }).nullable()
+});
+var CodingProviderStatus = z28.strictObject({
+  provider: CodingProviderName,
+  label: z28.string().max(60),
+  installed: z28.boolean(),
+  version: z28.string().max(80).nullable(),
+  loggedIn: z28.boolean(),
+  billing: z28.enum(["subscription", "api", "unknown"]),
+  plan: z28.string().max(80).nullable(),
+  account: z28.string().max(320).nullable(),
+  problem: ShortText.nullable(),
+  fix: ShortText.nullable(),
+  ready: z28.boolean(),
+  lastProblem: CodingProviderProblem.nullable(),
+  quota: z28.array(CodingQuotaWindow).max(20),
+  models: z28.array(z28.strictObject({ id: z28.string().max(200), label: z28.string().max(200) })).max(200),
+  efforts: z28.array(z28.string().max(40)).max(20),
+  defaultModel: z28.strictObject({ id: z28.string().max(200), source: z28.enum(["settings", "driver"]) }).nullable(),
+  defaultEffort: z28.string().max(40).nullable(),
+  binary: CodingProviderBinary.nullable()
+});
+var CodingChatPreference = z28.strictObject({
+  title: z28.string().max(500).nullable(),
+  pinned: z28.boolean(),
+  hidden: z28.boolean(),
+  /** When the person last had this chat open on any screen of this computer (the "New output" dot). */
+  lastSeenAt: IsoTime.nullable(),
+  updatedAt: IsoTime.nullable()
+});
+var CodingTitleStatus = z28.strictObject({
+  owner: z28.boolean(),
+  pending: z28.boolean(),
+  problem: ShortText.nullable(),
+  renames: ShortText.nullable()
+});
+var CodingRecentRow = z28.strictObject({
+  target: z28.string().min(3).max(200),
+  title: z28.string().max(500),
+  provider: CodingProviderName,
+  sessionId: SessionKey.nullable(),
+  providerSessionId: SessionKey.nullable(),
+  cwd: LocalPath.nullable(),
+  updatedAt: IsoTime,
+  state: z28.enum(["running", "needs_attention", "new_output", "elsewhere", "idle"]),
+  stateLabel: z28.string().max(120).nullable(),
+  pinned: z28.boolean(),
+  startedBy: CodingStartedBy.nullable()
+});
+var CodingFolderCheck = z28.strictObject({
+  path: z28.string().max(4096),
+  exists: z28.boolean(),
+  isDirectory: z28.boolean()
+});
+var CodingRecentFolder = z28.strictObject({ path: LocalPath, lastUsedAt: IsoTime, exists: z28.boolean() });
+var CodingAgentSelectionParams = z28.strictObject({
+  agent_id: z28.string().min(1).max(64),
+  version_id: z28.string().min(1).max(64).optional(),
+  variables: z28.record(z28.string().max(200), z28.unknown()).optional()
+});
+var CodingSendResult = z28.strictObject({
+  session: CodingSessionRecord,
+  run: CodingRunRecord.nullable(),
+  /** The prompt waits behind a live run (it shows as a queued bubble). */
+  queued: z28.boolean()
+});
+var CodingProvidersParams = z28.strictObject({});
+var CodingProvidersResult = z28.strictObject({ providers: z28.array(CodingProviderStatus).max(4) });
+var CodingSessionsListParams = z28.strictObject({});
+var CodingSessionsListResult = z28.strictObject({
+  sessions: z28.array(CodingSessionRecord),
+  /** The latest run of each session, by session id. */
+  runs: z28.record(z28.string().max(128), CodingRunRecord),
+  recent: z28.array(CodingRecentRow),
+  title_status: CodingTitleStatus
+});
+var CodingDiscoverParams = z28.strictObject({ limit: z28.int().min(1).max(1e3).optional() });
+var CodingDiscoverResult = z28.strictObject({ chats: z28.array(CodingDiscoveredChat) });
+var CodingRunsListParams = z28.strictObject({ session_id: SessionKey });
+var CodingRunsListResult = z28.strictObject({ runs: z28.array(CodingRunRecord) });
+var CodingHistoryParams = z28.strictObject({ session_id: SessionKey, max_bytes: z28.int().min(1024).max(209715200).optional() });
+var CodingHistoryResult = CodingHistoryRecord;
+var CodingTranscriptReadParams = z28.strictObject({
+  provider: CodingProviderName,
+  provider_session_id: SessionKey,
+  max_bytes: z28.int().min(1024).max(209715200).optional()
+});
+var CodingTranscriptReadResult = CodingHistoryRecord;
+var CodingItemFullParams = z28.strictObject({
+  provider: CodingProviderName,
+  provider_session_id: SessionKey,
+  item_id: z28.string().min(1).max(200)
+});
+var CodingItemFullResult = z28.strictObject({ output: z28.string(), bytes: nonNegInt });
+var CodingActivityParams = z28.strictObject({ provider: CodingProviderName, provider_session_id: SessionKey });
+var CodingActivityResult = z28.strictObject({ active: CodingActiveElsewhere.nullable() });
+var CodingFoldersRecentParams = z28.strictObject({});
+var CodingFoldersRecentResult = z28.strictObject({ folders: z28.array(CodingRecentFolder).max(100) });
+var CodingFoldersCheckParams = z28.strictObject({ path: z28.string().min(1).max(4096) });
+var CodingFoldersCheckResult = CodingFolderCheck;
+var CodingFoldersCreateParams = z28.strictObject({ path: z28.string().min(1).max(4096) });
+var CodingFoldersCreateResult = CodingFolderCheck;
+var CodingStartParams = z28.strictObject({
+  provider: CodingProviderName,
+  cwd: z28.string().min(1).max(4096),
+  prompt: z28.string().min(1).max(1048576),
+  model: z28.string().min(1).max(200).optional(),
+  effort: z28.string().min(1).max(40).optional(),
+  agent: CodingAgentSelectionParams.optional(),
+  /** One of the person's coding accounts on this computer (Accounts); absent = the default login. */
+  account_profile_id: z28.string().min(1).max(64).optional(),
+  client_request_id: CodingClientRequestId
+});
+var CodingStartResult = CodingSendResult;
+var CodingTakeoverParams = z28.strictObject({
+  provider: CodingProviderName,
+  provider_session_id: SessionKey,
+  cwd: z28.string().min(1).max(4096),
+  title: z28.string().max(500).optional(),
+  agent: CodingAgentSelectionParams.optional(),
+  confirm_elsewhere: z28.boolean().optional()
+});
+var CodingTakeoverResult = z28.strictObject({ session: CodingSessionRecord });
+var CodingSendParams = z28.strictObject({
+  session_id: SessionKey,
+  prompt: z28.string().min(1).max(1048576),
+  client_request_id: CodingClientRequestId
+});
+var CodingStopParams = z28.strictObject({ run_id: z28.string().min(1).max(64) });
+var CodingStopResult = z28.strictObject({ run: CodingRunRecord.nullable() });
+var CodingStopElsewhereParams = z28.strictObject({
+  provider: CodingProviderName,
+  provider_session_id: SessionKey,
+  pid: z28.int().min(1)
+});
+var CodingStopElsewhereResult = z28.strictObject({ stopped: z28.boolean(), message: ShortText });
+var CodingOptionsSetParams = z28.strictObject({
+  session_id: SessionKey,
+  model: z28.string().max(200).optional(),
+  effort: z28.string().max(40).optional()
+});
+var CodingOptionsSetResult = z28.strictObject({ session: CodingSessionRecord });
+var CodingAgentSetParams = z28.strictObject({ session_id: SessionKey, agent: CodingAgentSelectionParams.optional() });
+var CodingAgentSetResult = z28.strictObject({ session: CodingSessionRecord });
+var CodingAgentsAccessParams = z28.strictObject({});
+var CodingAgentsAccessResult = z28.strictObject({
+  signedIn: z28.boolean(),
+  userId: z28.string().max(64).nullable(),
+  organizationId: z28.string().max(64).nullable(),
+  configured: z28.boolean()
+});
+var CodingTitlesStatusParams = z28.strictObject({});
+var CodingTitlesStatusResult = CodingTitleStatus;
+var CodingPrefsListParams = z28.strictObject({});
+var CodingPrefsListResult = z28.strictObject({ preferences: z28.record(z28.string().max(200), CodingChatPreference) });
+var CodingPrefsSetParams = z28.strictObject({
+  key: z28.string().min(1).max(200),
+  title: z28.string().min(1).max(500).optional(),
+  clear_title: z28.boolean().optional(),
+  pinned: z28.boolean().optional(),
+  hidden: z28.boolean().optional()
+});
+var CodingPrefsSetResult = CodingPrefsListResult;
+var CodingRecentSeenParams = z28.strictObject({ target: z28.string().min(3).max(200) });
+var CodingRecentSeenResult = z28.strictObject({ recent: z28.array(CodingRecentRow) });
+var CodingSearchParams = z28.strictObject({
+  query: z28.string().min(1).max(500),
+  cursor: nonNegInt.optional(),
+  limit: z28.int().min(1).max(100).optional()
+});
+var CodingSearchResult = z28.strictObject({
+  query: z28.string().max(500),
+  hits: z28.array(
+    z28.strictObject({
+      provider: CodingProviderName,
+      providerSessionId: SessionKey,
+      title: z28.string().max(500),
+      cwd: LocalPath.nullable(),
+      updatedAt: IsoTime,
+      where: z28.enum(["title", "content"]),
+      snippet: z28.string().max(2e3).nullable()
+    })
+  ),
+  scanned: nonNegInt,
+  total: nonNegInt,
+  nextCursor: nonNegInt.nullable()
+});
+var CodingReconcileParams = z28.strictObject({ provider: CodingProviderName, provider_session_id: SessionKey });
+var CodingReconcileResult = z28.strictObject({
+  state: z28.enum(["done", "blocked", "nothing_to_do"]),
+  summary: z28.string().max(400)
+});
+var CodingTranscriptRawParams = z28.strictObject({ provider: CodingProviderName, provider_session_id: SessionKey });
+var CodingTranscriptRawResult = z28.strictObject({
+  available: z28.boolean(),
+  reason: ShortText.nullable(),
+  file_name: z28.string().max(300).nullable(),
+  bytes: nonNegInt,
+  /** The opt-in cloud backup was refreshed (false: off, unchanged, or signed out). */
+  backup_refreshed: z28.boolean(),
+  /** Subagent transcripts beside the chat (Claude Code), downloaded separately. */
+  subagents: nonNegInt
+});
+var CodingWatchParams = z28.strictObject({});
+var CodingWatchResult = z28.strictObject({ resource_id: ResourceId });
+var CodingSessionWatchParams = z28.strictObject({ session_id: SessionKey, since_seq: nonNegInt.optional() });
+var CodingSessionWatchResult = z28.strictObject({
+  resource_id: ResourceId,
+  /** The newest item seq the device has for this session right now. */
+  seq: nonNegInt
+});
+var CodingChangedEvent = z28.discriminatedUnion("kind", [
+  z28.strictObject({ kind: z28.literal("session"), session: CodingSessionRecord }),
+  z28.strictObject({ kind: z28.literal("run"), run: CodingRunRecord }),
+  z28.strictObject({ kind: z28.literal("preferences"), preferences: z28.record(z28.string().max(200), CodingChatPreference) }),
+  z28.strictObject({ kind: z28.literal("titles") }),
+  z28.strictObject({ kind: z28.literal("recent"), recent: z28.array(CodingRecentRow) })
+]);
+var CodingWatchStateEvent = z28.strictObject({ live: z28.boolean(), reason: ShortText.nullable(), beat_ms: z28.int().min(1e3) });
+var CodingItemEvent = z28.strictObject({
+  session_id: SessionKey,
+  run_id: z28.string().min(1).max(64),
+  seq: nonNegInt,
+  item: CodingTranscriptItem
+});
+var CodingGapEvent = z28.strictObject({ session_id: SessionKey, since_seq: nonNegInt, seq: nonNegInt });
+var SessionIdentifyParams = z28.strictObject({ label: z28.string().min(1).max(60) });
+var SessionIdentifyResult = z28.strictObject({ label: z28.string().max(60) });
+
+// src/schema/apps.ts
+import { z as z29 } from "zod";
 import { UUID_SHAPE_PATTERN as UUID_SHAPE_PATTERN4 } from "@ai-matrx/kit/uuid";
-var AppKey = z28.string().regex(/^[a-z][a-z0-9_-]{0,39}$/);
-var AppProfileId = z28.string().regex(UUID_SHAPE_PATTERN4);
-var AppProfileLocator = z28.string().min(1).max(512).regex(/^[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}(\/[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}){0,7}$/);
-var AppSupport = z28.enum(["supported", "partial", "unsupported"]);
-var AppFeatureStatus = z28.strictObject({
+var AppKey = z29.string().regex(/^[a-z][a-z0-9_-]{0,39}$/);
+var AppProfileId = z29.string().regex(UUID_SHAPE_PATTERN4);
+var AppProfileLocator = z29.string().min(1).max(512).regex(/^[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}(\/[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}){0,7}$/);
+var AppSupport = z29.enum(["supported", "partial", "unsupported"]);
+var AppFeatureStatus = z29.strictObject({
   status: AppSupport,
   /** One line, set whenever status is not "supported". */
-  reason: z28.string().max(140).nullable()
+  reason: z29.string().max(140).nullable()
 });
-var AppInfo = z28.strictObject({
+var AppInfo = z29.strictObject({
   app_key: AppKey,
-  name: z28.string().max(64),
-  installed: z28.boolean(),
+  name: z29.string().max(64),
+  installed: z29.boolean(),
   /** The app's own version string, or null when it is not installed or does not say. */
-  version: z28.string().max(64).nullable(),
+  version: z29.string().max(64).nullable(),
   /** The install found (an .app bundle, an .exe, a binary), or null. */
   location: AbsPath.nullable(),
   /** Open the app at all on this OS. */
@@ -2019,148 +2463,148 @@ var AppInfo = z28.strictObject({
   /** Plan usage read from the app's own files on this OS. */
   usage: AppFeatureStatus
 });
-var AppUsageReading = z28.strictObject({
-  window: z28.enum(["five_hour", "weekly", "extra"]),
+var AppUsageReading = z29.strictObject({
+  window: z29.enum(["five_hour", "weekly", "extra"]),
   /** 0–100 for five_hour and weekly; extra-usage spend as a percent of its cap (may pass 100). */
-  percent: z28.number().min(0).max(1e4),
+  percent: z29.number().min(0).max(1e4),
   /** When the app recorded it. */
   sampled_at_ms: epochMs,
   /** True when the window has rolled over since the sample, so the figure has reset. */
-  reset_since: z28.boolean()
+  reset_since: z29.boolean()
 });
-var AppProfile = z28.strictObject({
+var AppProfile = z29.strictObject({
   /** The row's id; null for a folder found on disk that no row names yet. */
   id: AppProfileId.nullable(),
   app_key: AppKey,
-  display_name: z28.string().min(1).max(120),
+  display_name: z29.string().min(1).max(120),
   /** The account the person means to be signed in here; null when not stated (never guessed). */
-  account_identity: z28.string().min(3).max(320).nullable(),
+  account_identity: z29.string().min(3).max(320).nullable(),
   profile_locator: AppProfileLocator.nullable(),
   /** The device the row is tied to; null when the row names none. */
   device_id: DeviceId.nullable(),
   /** The folder this profile resolves to on this device; null for a row tied to another device. */
   folder: AbsPath.nullable(),
   /** The folder exists on this device. */
-  on_disk: z28.boolean(),
+  on_disk: z29.boolean(),
   /** An instance with this profile is running; null when it could not be determined. */
-  running: z28.boolean().nullable(),
+  running: z29.boolean().nullable(),
   /** Usage the app recorded for this profile; null when the app exposes none here. */
-  usage: z28.array(AppUsageReading).nullable(),
+  usage: z29.array(AppUsageReading).nullable(),
   last_opened_ms: epochMs.nullable()
 });
-var AppsListParams = z28.strictObject({});
-var AppsListResult = z28.strictObject({ apps: z28.array(AppInfo) });
-var AppsProfilesListParams = z28.strictObject({
+var AppsListParams = z29.strictObject({});
+var AppsListResult = z29.strictObject({ apps: z29.array(AppInfo) });
+var AppsProfilesListParams = z29.strictObject({
   /** Only this app's profiles; every app's when absent. */
   app_key: AppKey.optional()
 });
-var AppsProfilesListResult = z28.strictObject({
-  profiles: z28.array(AppProfile),
+var AppsProfilesListResult = z29.strictObject({
+  profiles: z29.array(AppProfile),
   /**
    * Whether the saved rows could be read: false while signed out or offline, when only folders
    * found on disk are listed.
    */
-  registry: z28.enum(["ok", "signed_out", "unavailable"])
+  registry: z29.enum(["ok", "signed_out", "unavailable"])
 });
-var AppsProfilesSaveParams = z28.strictObject({
+var AppsProfilesSaveParams = z29.strictObject({
   id: AppProfileId.optional(),
   app_key: AppKey,
-  display_name: z28.string().min(1).max(120),
-  account_identity: z28.string().min(3).max(320).nullable(),
+  display_name: z29.string().min(1).max(120),
+  account_identity: z29.string().min(3).max(320).nullable(),
   /** On create: the folder to use (one found on disk), or null for the app's default profile. Ignored on update. */
   profile_locator: AppProfileLocator.nullable(),
   /** On create with profile_locator null: make a new folder named after display_name instead. */
-  new_folder: z28.boolean().default(false)
+  new_folder: z29.boolean().default(false)
 });
 var AppsProfilesSaveResult = AppProfile;
-var AppsProfilesRemoveParams = z28.strictObject({ id: AppProfileId });
-var AppsProfilesRemoveResult = z28.strictObject({ removed: z28.boolean() });
-var AppsOpenParams = z28.strictObject({
+var AppsProfilesRemoveParams = z29.strictObject({ id: AppProfileId });
+var AppsProfilesRemoveResult = z29.strictObject({ removed: z29.boolean() });
+var AppsOpenParams = z29.strictObject({
   app_key: AppKey,
   profile_id: AppProfileId.optional()
 });
-var AppsOpenResult = z28.strictObject({
+var AppsOpenResult = z29.strictObject({
   /** True when an instance with this profile was already running; it is brought forward. */
-  already_running: z28.boolean(),
+  already_running: z29.boolean(),
   folder: AbsPath.nullable()
 });
 
 // src/schema/apps-chats.ts
-import { z as z29 } from "zod";
-var ChatId = z29.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/);
-var ChatPlace = z29.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/);
-var ChatProjectId = z29.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
-var ChatWindow = z29.strictObject({
+import { z as z30 } from "zod";
+var ChatId = z30.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/);
+var ChatPlace = z30.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/);
+var ChatProjectId = z30.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
+var ChatWindow = z30.strictObject({
   key: ChatPlace,
   /** The app's default profile (Claude: the main window, which lists every account's chats). */
-  main: z29.boolean(),
+  main: z30.boolean(),
   /** The account the window is signed into, when known. */
-  account: z29.string().max(320).nullable()
+  account: z30.string().max(320).nullable()
 });
-var ChatProject = z29.strictObject({
+var ChatProject = z30.strictObject({
   id: ChatProjectId,
-  name: z29.string().min(1).max(200),
-  archived: z29.boolean(),
+  name: z30.string().min(1).max(200),
+  archived: z30.boolean(),
   /** Chats in it. */
   count: nonNegInt
 });
-var ChatPin = z29.strictObject({
+var ChatPin = z30.strictObject({
   /** The window whose account pins it; an account with no window of its own is named by its email. */
-  window: z29.string().min(1).max(320),
+  window: z30.string().min(1).max(320),
   /** When that account's pin list was last read; null when the reading has no time. */
   observed_at_ms: epochMs.nullable()
 });
-var ChatRunning = z29.strictObject({
+var ChatRunning = z30.strictObject({
   window: ChatPlace,
   /** process: a live process resumed this chat there (exact); activity: that window's own record moved in the last 3 minutes. */
-  how: z29.enum(["process", "activity"])
+  how: z30.enum(["process", "activity"])
 });
-var ChatHidden = z29.strictObject({
+var ChatHidden = z30.strictObject({
   window: ChatPlace,
-  reason: z29.string().max(200)
+  reason: z30.string().max(200)
 });
-var ChatLastUse = z29.strictObject({
+var ChatLastUse = z30.strictObject({
   /** The conversation's last reply. */
   at_ms: epochMs,
   window: ChatPlace.nullable(),
-  account: z29.string().max(320).nullable(),
+  account: z30.string().max(320).nullable(),
   /** How the window was decided (one short line). */
-  how: z29.string().max(120).nullable(),
+  how: z30.string().max(120).nullable(),
   /** The account's 1-hour prompt cache is still warm. */
-  cache_warm: z29.boolean(),
+  cache_warm: z30.boolean(),
   cache_minutes_left: nonNegInt
 });
-var ChatAppProject = z29.strictObject({
-  id: z29.string().min(1).max(200),
-  name: z29.string().max(200)
+var ChatAppProject = z30.strictObject({
+  id: z30.string().min(1).max(200),
+  name: z30.string().max(200)
 });
-var ChatTitleSource = z29.enum(["app", "app-remembered", "custom-title", "ai-title", "agent-name", "summary", "first-prompt", "last-prompt"]);
-var ChatRow = z29.strictObject({
+var ChatTitleSource = z30.enum(["app", "app-remembered", "custom-title", "ai-title", "agent-name", "summary", "first-prompt", "last-prompt"]);
+var ChatRow = z30.strictObject({
   id: ChatId,
   /** The short id people see (the listing's first 8 characters). */
-  short_id: z29.string().max(16),
+  short_id: z30.string().max(16),
   /** The listing's own name (Claude: local_<id>), null for a chat only in the holder. */
-  record: z29.string().max(160).nullable(),
-  title: z29.string().max(1e3),
+  record: z30.string().max(160).nullable(),
+  title: z30.string().max(1e3),
   last_active_ms: epochMs.nullable(),
   created_ms: epochMs.nullable(),
-  projects: z29.array(ChatProjectId).max(500),
-  starred: z29.boolean(),
-  pinned_in: z29.array(ChatPin).max(200),
+  projects: z30.array(ChatProjectId).max(500),
+  starred: z30.boolean(),
+  pinned_in: z30.array(ChatPin).max(200),
   /** Every place it is listed now: window keys, plus "holder". */
-  places: z29.array(ChatPlace).max(200),
-  held: z29.boolean(),
-  running: z29.array(ChatRunning).max(200),
-  hidden_in: z29.array(ChatHidden).max(200),
+  places: z30.array(ChatPlace).max(200),
+  held: z30.boolean(),
+  running: z30.array(ChatRunning).max(200),
+  hidden_in: z30.array(ChatHidden).max(200),
   /** Kept out of the main window on purpose. */
-  hidden_from_main: z29.boolean(),
+  hidden_from_main: z30.boolean(),
   /** Listed in a side window and not yet copied into main. */
-  main_pending: z29.boolean(),
+  main_pending: z30.boolean(),
   /** A scheduled routine's run (its task id). */
-  scheduled: z29.string().max(200).nullable(),
+  scheduled: z30.string().max(200).nullable(),
   /** Created recently and in no project: offered for filing. */
-  new_unfiled: z29.boolean(),
-  warnings: z29.array(z29.string().max(400)).max(20),
+  new_unfiled: z30.boolean(),
+  warnings: z30.array(z30.string().max(400)).max(20),
   last_use: ChatLastUse.nullable(),
   /** 1.13: the app's own project the chat is grouped under in the app (Codex), read only; absent = none or not an app that groups. */
   app_project: ChatAppProject.optional(),
@@ -2170,140 +2614,140 @@ var ChatRow = z29.strictObject({
    * 1.14: the chat's own title before the person's rename (the one title rule, `@ai-matrx/coding-sessions/sessions`);
    * `title` is what to show (`title_override` when set, else this).
    */
-  original_title: z29.string().max(1e3).optional(),
+  original_title: z30.string().max(1e3).optional(),
   /** 1.14: where `original_title` came from (the one rule's sources, strongest first; 1.15: a closed set). */
   title_source: ChatTitleSource.optional(),
   /** 1.14: the person's rename inside Matrx (Coding Sessions), applied once by the row builder; absent = none. */
-  title_override: z29.string().min(1).max(300).optional(),
+  title_override: z30.string().min(1).max(300).optional(),
   /** 1.15: the app itself archived it (hidden_in says where and why, in words for people; this is the typed fact). */
-  archived: z29.boolean().optional()
+  archived: z30.boolean().optional()
 });
-var ChatFamily = z29.strictObject({
+var ChatFamily = z30.strictObject({
   id: ChatId,
   fork_of: ChatId.nullable(),
   copy_of: ChatId.nullable()
 });
-var AppsChatsListParams = z29.strictObject({
+var AppsChatsListParams = z30.strictObject({
   app_key: AppKey,
   /** Only these chats (a live update re-reads just what changed). */
-  ids: z29.array(ChatId).max(500).optional()
+  ids: z30.array(ChatId).max(500).optional()
 });
-var AppsChatsListResult = z29.strictObject({
+var AppsChatsListResult = z30.strictObject({
   app_key: AppKey,
   /** Bumps on every change the index sees; `apps.chats.changed` carries the same number. */
   version: nonNegInt,
-  windows: z29.array(ChatWindow).max(200),
-  projects: z29.array(ChatProject).max(5e3),
-  chats: z29.array(ChatRow).max(2e4),
+  windows: z30.array(ChatWindow).max(200),
+  projects: z30.array(ChatProject).max(5e3),
+  chats: z30.array(ChatRow).max(2e4),
   /** How long a chat in no project counts as new. */
   new_window_ms: nonNegInt,
   /** 1.9: this is the copy saved at the last read, shown while everything is read again. */
-  updating: z29.boolean().optional(),
+  updating: z30.boolean().optional(),
   /** 1.9: false while the folder watches are down (changes are not arriving); `apps.chats.watch_state` says when it changes. */
-  live: z29.boolean().optional(),
+  live: z30.boolean().optional(),
   /** 1.10: every listed chat that is a fork or a copy of another (read from the conversations' first lines). */
-  families: z29.array(ChatFamily).max(2e4).optional()
+  families: z30.array(ChatFamily).max(2e4).optional()
 });
-var AppsChatsWatchParams = z29.strictObject({ app_key: AppKey });
-var AppsChatsWatchResult = z29.strictObject({ resource_id: ResourceId, version: nonNegInt });
-var AppsChatsChangedEvent = z29.strictObject({
+var AppsChatsWatchParams = z30.strictObject({ app_key: AppKey });
+var AppsChatsWatchResult = z30.strictObject({ resource_id: ResourceId, version: nonNegInt });
+var AppsChatsChangedEvent = z30.strictObject({
   app_key: AppKey,
   version: nonNegInt,
-  ids: z29.array(ChatId).max(1e3),
-  all: z29.boolean()
+  ids: z30.array(ChatId).max(1e3),
+  all: z30.boolean()
 });
-var AppsChatsWatchStateEvent = z29.strictObject({
+var AppsChatsWatchStateEvent = z30.strictObject({
   app_key: AppKey,
-  live: z29.boolean(),
-  updating: z29.boolean(),
-  reason: z29.string().max(300).nullable()
+  live: z30.boolean(),
+  updating: z30.boolean(),
+  reason: z30.string().max(300).nullable()
 });
-var AppsChatsPlaceParams = z29.strictObject({
+var AppsChatsPlaceParams = z30.strictObject({
   app_key: AppKey,
   chat_id: ChatId,
-  action: z29.enum(["place", "take_off", "hold"]),
+  action: z30.enum(["place", "take_off", "hold"]),
   /** The window (for place and take_off). */
   window: ChatPlace.optional(),
   /** take_off where it is open: stop it there first (the person confirmed). */
-  stop_if_open: z29.boolean().default(false)
+  stop_if_open: z30.boolean().default(false)
 });
-var AppsChatsPlaceResult = z29.strictObject({ chat: ChatRow, message: z29.string().max(400) });
-var AppsProjectsFileManyParams = z29.strictObject({
+var AppsChatsPlaceResult = z30.strictObject({ chat: ChatRow, message: z30.string().max(400) });
+var AppsProjectsFileManyParams = z30.strictObject({
   app_key: AppKey,
-  chat_ids: z29.array(ChatId).min(1).max(500),
+  chat_ids: z30.array(ChatId).min(1).max(500),
   project_id: ChatProjectId.optional(),
-  new_project_name: z29.string().min(1).max(200).optional()
+  new_project_name: z30.string().min(1).max(200).optional()
 });
-var AppsProjectsFileManyResult = z29.strictObject({ chats: z29.array(ChatRow).max(500), project: ChatProject });
-var AppsProjectsUpdateParams = z29.strictObject({
+var AppsProjectsFileManyResult = z30.strictObject({ chats: z30.array(ChatRow).max(500), project: ChatProject });
+var AppsProjectsUpdateParams = z30.strictObject({
   app_key: AppKey,
   project_id: ChatProjectId,
-  name: z29.string().min(1).max(200).optional(),
-  archived: z29.boolean().optional()
+  name: z30.string().min(1).max(200).optional(),
+  archived: z30.boolean().optional()
 });
-var AppsProjectsUpdateResult = z29.strictObject({ project: ChatProject });
-var AppsProjectsCopyParams = z29.strictObject({ app_key: AppKey, project_id: ChatProjectId, new_project_name: z29.string().min(1).max(200) });
-var AppsProjectsCopyResult = z29.strictObject({ project: ChatProject });
-var AppsProjectsFileParams = z29.strictObject({
+var AppsProjectsUpdateResult = z30.strictObject({ project: ChatProject });
+var AppsProjectsCopyParams = z30.strictObject({ app_key: AppKey, project_id: ChatProjectId, new_project_name: z30.string().min(1).max(200) });
+var AppsProjectsCopyResult = z30.strictObject({ project: ChatProject });
+var AppsProjectsFileParams = z30.strictObject({
   app_key: AppKey,
   chat_id: ChatId,
   project_id: ChatProjectId.optional(),
-  new_project_name: z29.string().min(1).max(200).optional()
+  new_project_name: z30.string().min(1).max(200).optional()
 });
-var AppsProjectsFileResult = z29.strictObject({ chat: ChatRow, project: ChatProject });
-var AppsProjectsUnfileParams = z29.strictObject({ app_key: AppKey, chat_id: ChatId, project_id: ChatProjectId });
-var AppsProjectsUnfileResult = z29.strictObject({ chat: ChatRow });
-var AppsChatsStarParams = z29.strictObject({ app_key: AppKey, chat_id: ChatId, starred: z29.boolean() });
-var AppsChatsStarResult = z29.strictObject({ chat: ChatRow });
+var AppsProjectsFileResult = z30.strictObject({ chat: ChatRow, project: ChatProject });
+var AppsProjectsUnfileParams = z30.strictObject({ app_key: AppKey, chat_id: ChatId, project_id: ChatProjectId });
+var AppsProjectsUnfileResult = z30.strictObject({ chat: ChatRow });
+var AppsChatsStarParams = z30.strictObject({ app_key: AppKey, chat_id: ChatId, starred: z30.boolean() });
+var AppsChatsStarResult = z30.strictObject({ chat: ChatRow });
 
 // src/schema/apps-accounts.ts
-import { z as z30 } from "zod";
-var AppWindowInfo = z30.strictObject({
+import { z as z31 } from "zod";
+var AppWindowInfo = z31.strictObject({
   key: ChatPlace,
   /** The app's default profile (Claude: main, which may sign into any account). */
-  main: z30.boolean(),
+  main: z31.boolean(),
   /** The account the window is meant for (null for main). */
-  account: z30.string().max(320).nullable(),
+  account: z31.string().max(320).nullable(),
   /** The account signed in there now: an email, or the account id while it has no saved name. */
-  signed_in: z30.string().max(320).nullable(),
-  signed_in_is_email: z30.boolean(),
+  signed_in: z31.string().max(320).nullable(),
+  signed_in_is_email: z31.boolean(),
   /** Signed into another account than the one it is meant for. */
-  mismatch: z30.boolean(),
+  mismatch: z31.boolean(),
   /** Its folder exists. */
-  created: z30.boolean(),
+  created: z31.boolean(),
   /** Open now. */
-  running: z30.boolean(),
+  running: z31.boolean(),
   /** Chats open in it now (a process resuming each one). */
   open_chats: nonNegInt
 });
-var AccountUsage = z30.strictObject({
+var AccountUsage = z31.strictObject({
   /** The account's email, or "org <8 chars>" when no window has ever sampled that org. */
-  account: z30.string().max(320),
-  org: z30.string().max(80).nullable(),
+  account: z31.string().max(320),
+  org: z31.string().max(80).nullable(),
   /** False when the org was sampled in several accounts' windows and the vote is not clear (≥ 75 %). */
-  account_certain: z30.boolean(),
+  account_certain: z31.boolean(),
   /** 5-hour use in percent (0 once the reading is over 5 hours old). */
-  five_hour: z30.number().nullable(),
-  five_hour_reset_since: z30.boolean(),
+  five_hour: z31.number().nullable(),
+  five_hour_reset_since: z31.boolean(),
   /** Weekly use in percent (0 once the week reset after the reading). */
-  weekly: z30.number().nullable(),
-  weekly_reset_since: z30.boolean(),
+  weekly: z31.number().nullable(),
+  weekly_reset_since: z31.boolean(),
   /** Extra-usage spend in percent of its cap, when on. */
-  extra_usage: z30.number().nullable(),
+  extra_usage: z31.number().nullable(),
   extra_usage_as_of_ms: epochMs.nullable(),
   as_of_ms: epochMs,
   /** The windows meant for this account (and main when main took the reading). */
-  windows: z30.array(ChatPlace).max(200),
+  windows: z31.array(ChatPlace).max(200),
   /** The window that took the reading is open now and the reading is under 30 minutes old. */
-  live: z30.boolean(),
+  live: z31.boolean(),
   /** The next weekly reset, when known. */
   weekly_resets_at_ms: epochMs.nullable(),
   /** That reset time is Claude's own (its reading, or a reset seen in its usage history). */
-  weekly_reset_official: z30.boolean().nullable(),
+  weekly_reset_official: z31.boolean().nullable(),
   /** 1.13: the account's plan as the app names it (Codex: "pro", "prolite"), when recorded. */
-  plan: z30.string().max(80).optional(),
+  plan: z31.string().max(80).optional(),
   /** 1.13: the account's credit balance as the app records it (Codex), when recorded. */
-  credits: z30.string().max(40).optional(),
+  credits: z31.string().max(40).optional(),
   /**
    * 1.25: the latest the account's 5-hour window can reset: 5 hours after the first reading of this
    * window's use (its usage history), so the real reset is at or before it. Absent when no 5-hour
@@ -2311,81 +2755,81 @@ var AccountUsage = z30.strictObject({
    */
   five_hour_resets_by_ms: epochMs.optional()
 });
-var AccountReset = z30.strictObject({
+var AccountReset = z31.strictObject({
   window: ChatPlace,
-  account: z30.string().max(320).nullable(),
+  account: z31.string().max(320).nullable(),
   next_reset_ms: epochMs.nullable(),
   /** claude: the app's own reading; usage_history: a weekly drop seen in its usage record; your_list: the person's own entry. */
-  source: z30.enum(["claude", "usage_history", "your_list"]).nullable(),
+  source: z31.enum(["claude", "usage_history", "your_list"]).nullable(),
   /** claude or usage_history. */
-  official: z30.boolean(),
+  official: z31.boolean(),
   /** Set when the person's list disagrees with the official time. */
-  note: z30.string().max(200).nullable()
+  note: z31.string().max(200).nullable()
 });
-var AppsWindowsListParams = z30.strictObject({ app_key: AppKey });
-var AppsWindowsListResult = z30.strictObject({ app_key: AppKey, windows: z30.array(AppWindowInfo).max(200) });
-var AppsAccountsUsageParams = z30.strictObject({ app_key: AppKey });
-var AppsAccountsUsageResult = z30.strictObject({
+var AppsWindowsListParams = z31.strictObject({ app_key: AppKey });
+var AppsWindowsListResult = z31.strictObject({ app_key: AppKey, windows: z31.array(AppWindowInfo).max(200) });
+var AppsAccountsUsageParams = z31.strictObject({ app_key: AppKey });
+var AppsAccountsUsageResult = z31.strictObject({
   app_key: AppKey,
-  accounts: z30.array(AccountUsage).max(500),
+  accounts: z31.array(AccountUsage).max(500),
   /** 1.12: the rows are right but something around them failed (a newly read reset time could not be saved); shown, never hidden. */
-  problem: z30.string().max(400).optional()
+  problem: z31.string().max(400).optional()
 });
-var AppsAccountsResetsParams = z30.strictObject({ app_key: AppKey });
-var AppsAccountsResetsResult = z30.strictObject({
+var AppsAccountsResetsParams = z31.strictObject({ app_key: AppKey });
+var AppsAccountsResetsResult = z31.strictObject({
   app_key: AppKey,
-  resets: z30.array(AccountReset).max(200),
+  resets: z31.array(AccountReset).max(200),
   /** 1.12: as on `apps.accounts.usage`. */
-  problem: z30.string().max(400).optional()
+  problem: z31.string().max(400).optional()
 });
-var AppsWindowActionResult = z30.strictObject({ message: z30.string().max(400) });
-var AppsWindowsOpenParams = z30.strictObject({ app_key: AppKey, window: ChatPlace });
-var AppsWindowsReloadParams = z30.strictObject({ app_key: AppKey, window: ChatPlace });
-var ShownSection = z30.strictObject({
-  title: z30.string().max(300),
+var AppsWindowActionResult = z31.strictObject({ message: z31.string().max(400) });
+var AppsWindowsOpenParams = z31.strictObject({ app_key: AppKey, window: ChatPlace });
+var AppsWindowsReloadParams = z31.strictObject({ app_key: AppKey, window: ChatPlace });
+var ShownSection = z31.strictObject({
+  title: z31.string().max(300),
   /** Rows drawn under it (a collapsed section draws none). */
-  rows: z30.number().int().nonnegative(),
-  expanded: z30.boolean()
+  rows: z31.number().int().nonnegative(),
+  expanded: z31.boolean()
 });
-var AppsWindowsShownParams = z30.strictObject({ app_key: AppKey, window: ChatPlace });
-var AppsWindowsShownResult = z30.strictObject({
+var AppsWindowsShownParams = z31.strictObject({ app_key: AppKey, window: ChatPlace });
+var AppsWindowsShownResult = z31.strictObject({
   window: ChatPlace,
-  open: z30.boolean(),
-  sections: z30.array(ShownSection).max(200),
-  problem: z30.string().max(400).nullable()
+  open: z31.boolean(),
+  sections: z31.array(ShownSection).max(200),
+  problem: z31.string().max(400).nullable()
 });
-var AppsWindowsRestartParams = z30.strictObject({ app_key: AppKey, window: ChatPlace, force: z30.boolean().default(false) });
-var AppsWindowsRefreshUsageParams = z30.strictObject({ app_key: AppKey, window: ChatPlace });
-var AppsProjectsMoveParams = z30.strictObject({
+var AppsWindowsRestartParams = z31.strictObject({ app_key: AppKey, window: ChatPlace, force: z31.boolean().default(false) });
+var AppsWindowsRefreshUsageParams = z31.strictObject({ app_key: AppKey, window: ChatPlace });
+var AppsProjectsMoveParams = z31.strictObject({
   app_key: AppKey,
   chat_id: ChatId,
   from_project_id: ChatProjectId,
   to_project_id: ChatProjectId.optional(),
-  new_project_name: z30.string().min(1).max(200).optional()
-});
-var AppsProjectsMoveResult = z30.strictObject({ chat: ChatRow, project: ChatProject });
-var AppsProjectsCreateParams = z30.strictObject({ app_key: AppKey, name: z30.string().min(1).max(200) });
-var AppsProjectsCreateResult = z30.strictObject({ project: ChatProject });
-var AppsProjectsImportPinsParams = z30.strictObject({ app_key: AppKey });
-var AppsProjectsImportPinsResult = z30.strictObject({ message: z30.string().max(400) });
-var ProjectMoveChat = z30.strictObject({ chat_id: ChatId, title: z30.string().max(300) });
-var ProjectMoveSkip = z30.strictObject({ chat_id: ChatId, title: z30.string().max(300), window: ChatPlace.nullable(), reason: z30.string().max(400) });
-var ProjectMoveGroup = z30.strictObject({
-  ok: z30.boolean(),
-  name: z30.string().max(200),
+  new_project_name: z31.string().min(1).max(200).optional()
+});
+var AppsProjectsMoveResult = z31.strictObject({ chat: ChatRow, project: ChatProject });
+var AppsProjectsCreateParams = z31.strictObject({ app_key: AppKey, name: z31.string().min(1).max(200) });
+var AppsProjectsCreateResult = z31.strictObject({ project: ChatProject });
+var AppsProjectsImportPinsParams = z31.strictObject({ app_key: AppKey });
+var AppsProjectsImportPinsResult = z31.strictObject({ message: z31.string().max(400) });
+var ProjectMoveChat = z31.strictObject({ chat_id: ChatId, title: z31.string().max(300) });
+var ProjectMoveSkip = z31.strictObject({ chat_id: ChatId, title: z31.string().max(300), window: ChatPlace.nullable(), reason: z31.string().max(400) });
+var ProjectMoveGroup = z31.strictObject({
+  ok: z31.boolean(),
+  name: z31.string().max(200),
   /** Why it is not (or was not) grouped — e.g. the window is open. */
-  reason: z30.string().max(400).optional(),
+  reason: z31.string().max(400).optional(),
   /** Chats that get (or got) the group; already in it; taken from another group of the window. */
   assign: nonNegInt.optional(),
   already: nonNegInt.optional(),
   from_other_groups: nonNegInt.optional(),
   /** A group of that name was already there (reused, never doubled). */
-  group_exists: z30.boolean().optional()
+  group_exists: z31.boolean().optional()
 });
-var ProjectMovePin = z30.strictObject({
-  ok: z30.boolean(),
+var ProjectMovePin = z31.strictObject({
+  ok: z31.boolean(),
   /** "now" = written into the closed window; "next_close" = queued until that window closes. */
-  when: z30.enum(["now", "next_close"]),
+  when: z31.enum(["now", "next_close"]),
   /** Pinned by this call (dry run: would be). */
   pinned: nonNegInt,
   /** Already pinned there. */
@@ -2393,108 +2837,108 @@ var ProjectMovePin = z30.strictObject({
   /** Waiting for the window to close (dry run: would wait). */
   queued: nonNegInt,
   /** Why not pinned (ok false), or why queued. */
-  reason: z30.string().max(400).optional()
+  reason: z31.string().max(400).optional()
 });
-var AppsProjectsToWindowParams = z30.strictObject({
+var AppsProjectsToWindowParams = z31.strictObject({
   app_key: AppKey,
   project_id: ChatProjectId,
   window: ChatPlace,
   /** Also take each chat off its other side windows where safe (never main, the holder, an open window). */
-  take_off: z30.boolean().default(false),
+  take_off: z31.boolean().default(false),
   /** Also group them under the project's name in that window's sidebar (closed windows only). */
-  group: z30.boolean().default(false),
+  group: z31.boolean().default(false),
   /** 1.32: also pin them in that window (now if closed, else when it next closes). */
-  pin: z30.boolean().optional(),
+  pin: z31.boolean().optional(),
   /** 1.36: a batch: exactly these chats of the project and no other (a reused marker is a label, never a sweep). */
-  chat_ids: z30.array(ChatId).min(1).max(5e3).optional(),
+  chat_ids: z31.array(ChatId).min(1).max(5e3).optional(),
   /** 1.36: take them off this one side window only (a Move's origin), never main or another window that lists them. */
   take_off_from: ChatPlace.optional(),
-  dry_run: z30.boolean().default(false)
+  dry_run: z31.boolean().default(false)
 });
-var AppsProjectsToWindowResult = z30.strictObject({
+var AppsProjectsToWindowResult = z31.strictObject({
   project_id: ChatProjectId,
   window: ChatPlace,
-  dry_run: z30.boolean(),
-  place: z30.array(ProjectMoveChat).max(5e3),
-  already: z30.array(ProjectMoveChat).max(5e3),
-  take_off: z30.array(ProjectMoveChat.extend({ window: ChatPlace })).max(2e4),
-  skipped: z30.array(ProjectMoveSkip).max(2e4),
+  dry_run: z31.boolean(),
+  place: z31.array(ProjectMoveChat).max(5e3),
+  already: z31.array(ProjectMoveChat).max(5e3),
+  take_off: z31.array(ProjectMoveChat.extend({ window: ChatPlace })).max(2e4),
+  skipped: z31.array(ProjectMoveSkip).max(2e4),
   /** Chats of the project from other apps (no windows to place into), left as they are. */
   other_apps: nonNegInt,
   group: ProjectMoveGroup.nullable(),
   /** 1.32: the pin in the target window (absent: not asked). */
   pin: ProjectMovePin.optional(),
-  message: z30.string().max(400)
+  message: z31.string().max(400)
 });
-var ColdChat = z30.strictObject({
+var ColdChat = z31.strictObject({
   id: ChatId,
-  title: z30.string().max(1e3),
-  repo: z30.string().max(200).nullable(),
-  window: z30.string().max(64).nullable(),
-  account: z30.string().max(320).nullable(),
-  model_name: z30.string().max(120).nullable(),
+  title: z31.string().max(1e3),
+  repo: z31.string().max(200).nullable(),
+  window: z31.string().max(64).nullable(),
+  account: z31.string().max(320).nullable(),
+  model_name: z31.string().max(120).nullable(),
   context_tokens: nonNegInt,
   cold_at_ms: epochMs,
   /** Waking it once the cache is cold. */
-  cold_cost: z30.number().nullable(),
+  cold_cost: z31.number().nullable(),
   /** Waking it while the cache is warm. */
-  warm_cost: z30.number().nullable(),
+  warm_cost: z31.number().nullable(),
   /** Its account is on extra usage (a 5-minute cache, and real money). */
-  extra_usage: z30.boolean(),
+  extra_usage: z31.boolean(),
   /** A scheduled routine's run. */
-  scheduled: z30.boolean(),
+  scheduled: z31.boolean(),
   /** It can be shown in its window (started in the desktop app). */
-  openable: z30.boolean(),
+  openable: z31.boolean(),
   /** How its window was decided, or why it can't be opened. */
-  how: z30.string().max(200).nullable()
+  how: z31.string().max(200).nullable()
 });
-var AppsChatsColdParams = z30.strictObject({ app_key: AppKey });
-var AppsChatsColdResult = z30.strictObject({
+var AppsChatsColdParams = z31.strictObject({ app_key: AppKey });
+var AppsChatsColdResult = z31.strictObject({
   app_key: AppKey,
   /** Waiting for the person with a warm cache, most urgent first. */
-  waiting: z30.array(ColdChat).max(2e3),
+  waiting: z31.array(ColdChat).max(2e3),
   /** Went cold in the last while. */
-  recently_cold: z30.array(ColdChat).max(2e3),
+  recently_cold: z31.array(ColdChat).max(2e3),
   /** Chats working right now (not waiting). */
   working: nonNegInt
 });
-var TitleCopies = z30.strictObject({
+var TitleCopies = z31.strictObject({
   window: ChatPlace,
   /** Record copies in that window holding a different name (main keeps one per account folder). */
   copies: nonNegInt,
-  titles: z30.array(z30.strictObject({ title: z30.string().max(2e3), source: z30.string().max(32) })).max(50)
+  titles: z31.array(z31.strictObject({ title: z31.string().max(2e3), source: z31.string().max(32) })).max(50)
 });
-var TitleMismatch = z30.strictObject({
+var TitleMismatch = z31.strictObject({
   chat_id: ChatId,
   /** The right name: the latest one a person gave it (in any window, or in Matrx), else the newest automatic title. */
-  title: z30.string().max(2e3),
-  title_source: z30.enum(["user", "auto"]),
+  title: z31.string().max(2e3),
+  title_source: z31.enum(["user", "auto"]),
   /** Where the right name came from: a window, "matrx", or "ledger" (decided earlier). */
-  decided_from: z30.string().max(64),
-  kind: z30.enum(["user_vs_auto", "user_vs_user", "auto_vs_auto", "source_only"]),
-  windows: z30.array(ChatPlace).max(200),
-  differs_in: z30.array(TitleCopies).max(200)
+  decided_from: z31.string().max(64),
+  kind: z31.enum(["user_vs_auto", "user_vs_user", "auto_vs_auto", "source_only"]),
+  windows: z31.array(ChatPlace).max(200),
+  differs_in: z31.array(TitleCopies).max(200)
 });
-var StaleTitleWindow = z30.strictObject({
+var StaleTitleWindow = z31.strictObject({
   window: ChatPlace,
   /** First and latest time (ms) it was seen writing an old name back. */
   since_ms: nonNegInt,
   last_ms: nonNegInt
 });
-var AppsChatsTitlesCheckParams = z30.strictObject({ app_key: AppKey });
-var AppsChatsTitlesCheckResult = z30.strictObject({
+var AppsChatsTitlesCheckParams = z31.strictObject({ app_key: AppKey });
+var AppsChatsTitlesCheckResult = z31.strictObject({
   app_key: AppKey,
   chats_total: nonNegInt,
   chats_in_several_windows: nonNegInt,
   /** Chats with a different name in some window (or in Matrx). */
   chats_with_a_different_name: nonNegInt,
   copies_to_write: nonNegInt,
-  chats: z30.array(TitleMismatch).max(5e3),
+  chats: z31.array(TitleMismatch).max(5e3),
   /** Windows that keep writing old names back (each is fixed every pass; reloading it, Cmd+R, stops it). Since 1.33. */
-  stale_windows: z30.array(StaleTitleWindow).max(200).optional()
+  stale_windows: z31.array(StaleTitleWindow).max(200).optional()
 });
-var AppsChatsTitlesPushParams = z30.strictObject({ app_key: AppKey, chat_id: ChatId.optional(), dry_run: z30.boolean().optional() });
-var AppsChatsTitlesPushResult = z30.strictObject({
+var AppsChatsTitlesPushParams = z31.strictObject({ app_key: AppKey, chat_id: ChatId.optional(), dry_run: z31.boolean().optional() });
+var AppsChatsTitlesPushResult = z31.strictObject({
   app_key: AppKey,
   /** Record files rewritten (title and titleSource only, each backed up first). */
   written: nonNegInt,
@@ -2504,122 +2948,122 @@ var AppsChatsTitlesPushResult = z30.strictObject({
   /** Still different after the push (dry_run: would be written). */
   chats_with_a_different_name: nonNegInt
 });
-var AppsChatsOpenParams = z30.strictObject({ app_key: AppKey, chat_id: ChatId, window: ChatPlace.optional() });
-var SpendSplit = z30.strictObject({ main: z30.number(), helpers: z30.number() });
-var SpendScopes = z30.strictObject({ today: SpendSplit, week: SpendSplit });
-var SpendAccount = z30.strictObject({
-  account: z30.string().max(320),
+var AppsChatsOpenParams = z31.strictObject({ app_key: AppKey, chat_id: ChatId, window: ChatPlace.optional() });
+var SpendSplit = z31.strictObject({ main: z31.number(), helpers: z31.number() });
+var SpendScopes = z31.strictObject({ today: SpendSplit, week: SpendSplit });
+var SpendAccount = z31.strictObject({
+  account: z31.string().max(320),
   spend: SpendScopes,
-  last_hour: z30.number().nullable(),
-  last_5h: z30.number().nullable(),
-  five_hour: z30.number().nullable(),
-  weekly: z30.number().nullable(),
+  last_hour: z31.number().nullable(),
+  last_5h: z31.number().nullable(),
+  five_hour: z31.number().nullable(),
+  weekly: z31.number().nullable(),
   as_of_ms: epochMs.nullable(),
   weekly_resets_at_ms: epochMs.nullable(),
   /** When the 5-hour or weekly limit is projected to be reached at the current burn. */
   five_hour_full_at_ms: epochMs.nullable(),
   weekly_full_at_ms: epochMs.nullable(),
   /** The reading is too old to project. */
-  stale: z30.boolean()
+  stale: z31.boolean()
 });
-var SpendModel = z30.strictObject({ model: z30.string().max(120), name: z30.string().max(120), spend: SpendScopes });
-var SpendChat = z30.strictObject({
+var SpendModel = z31.strictObject({ model: z31.string().max(120), name: z31.string().max(120), spend: SpendScopes });
+var SpendChat = z31.strictObject({
   id: ChatId,
-  title: z30.string().max(1e3),
-  repo: z30.string().max(200).nullable(),
-  window: z30.string().max(64).nullable(),
+  title: z31.string().max(1e3),
+  repo: z31.string().max(200).nullable(),
+  window: z31.string().max(64).nullable(),
   spend: SpendScopes,
   helpers: nonNegInt
 });
-var SpendHelper = z30.strictObject({ model: z30.string().max(120), steps: nonNegInt, over_steps: z30.boolean(), description: z30.string().max(400) });
-var SpendLive = z30.strictObject({ id: ChatId, title: z30.string().max(1e3), window: z30.string().max(64).nullable(), helpers: z30.array(SpendHelper).max(200) });
-var SpendIdleScope = z30.strictObject({ count: nonNegInt, tokens: nonNegInt, cost: z30.number(), avoidable: z30.number() });
-var SpendIdle = z30.strictObject({ id: ChatId, chat: z30.string().max(1e3), who: z30.string().max(400), today: SpendIdleScope, week: SpendIdleScope, last_ms: epochMs });
-var SpendStart = z30.strictObject({ repo: z30.string().max(200), count: nonNegInt, median: nonNegInt, latest: z30.array(nonNegInt).max(20), alarm: z30.string().max(400).nullable() });
-var SpendDay = z30.strictObject({ date: z30.string().regex(/^\d{4}-\d{2}-\d{2}$/), main: z30.number(), helpers: z30.number() });
-var AppsSpendParams = z30.strictObject({ app_key: AppKey });
-var AppsSpendResult = z30.strictObject({
+var SpendHelper = z31.strictObject({ model: z31.string().max(120), steps: nonNegInt, over_steps: z31.boolean(), description: z31.string().max(400) });
+var SpendLive = z31.strictObject({ id: ChatId, title: z31.string().max(1e3), window: z31.string().max(64).nullable(), helpers: z31.array(SpendHelper).max(200) });
+var SpendIdleScope = z31.strictObject({ count: nonNegInt, tokens: nonNegInt, cost: z31.number(), avoidable: z31.number() });
+var SpendIdle = z31.strictObject({ id: ChatId, chat: z31.string().max(1e3), who: z31.string().max(400), today: SpendIdleScope, week: SpendIdleScope, last_ms: epochMs });
+var SpendStart = z31.strictObject({ repo: z31.string().max(200), count: nonNegInt, median: nonNegInt, latest: z31.array(nonNegInt).max(20), alarm: z31.string().max(400).nullable() });
+var SpendDay = z31.strictObject({ date: z31.string().regex(/^\d{4}-\d{2}-\d{2}$/), main: z31.number(), helpers: z31.number() });
+var AppsSpendParams = z31.strictObject({ app_key: AppKey });
+var AppsSpendResult = z31.strictObject({
   app_key: AppKey,
   /** False while older chats are still being read. */
-  complete: z30.boolean(),
-  today_total: z30.number(),
-  week_total: z30.number(),
-  idle_today: z30.number(),
-  idle_week: z30.number(),
+  complete: z31.boolean(),
+  today_total: z31.number(),
+  week_total: z31.number(),
+  idle_today: z31.number(),
+  idle_week: z31.number(),
   /** Models with no known list price. */
-  unpriced: z30.array(z30.string().max(120)).max(100),
+  unpriced: z31.array(z31.string().max(120)).max(100),
   /** Helpers past their step budget, unusual starting sizes. */
-  alarms: z30.array(z30.string().max(400)).max(200),
-  live: z30.array(SpendLive).max(200),
-  accounts: z30.array(SpendAccount).max(200),
-  models: z30.array(SpendModel).max(100),
+  alarms: z31.array(z31.string().max(400)).max(200),
+  live: z31.array(SpendLive).max(200),
+  accounts: z31.array(SpendAccount).max(200),
+  models: z31.array(SpendModel).max(100),
   /** (1.24) The last 7 days, oldest first (today last). */
-  days: z30.array(SpendDay).max(14).optional(),
-  chats: z30.array(SpendChat).max(500),
-  idle: z30.array(SpendIdle).max(500),
-  starts: z30.array(SpendStart).max(200)
-});
-var AppsSyncStatusParams = z30.strictObject({ app_key: AppKey });
-var AppsSyncStatusResult = z30.strictObject({
-  healthy: z30.boolean(),
-  summary: z30.string().max(400),
-  problems: z30.array(z30.string().max(400)).max(200),
-  warnings: z30.array(z30.string().max(400)).max(200),
+  days: z31.array(SpendDay).max(14).optional(),
+  chats: z31.array(SpendChat).max(500),
+  idle: z31.array(SpendIdle).max(500),
+  starts: z31.array(SpendStart).max(200)
+});
+var AppsSyncStatusParams = z31.strictObject({ app_key: AppKey });
+var AppsSyncStatusResult = z31.strictObject({
+  healthy: z31.boolean(),
+  summary: z31.string().max(400),
+  problems: z31.array(z31.string().max(400)).max(200),
+  warnings: z31.array(z31.string().max(400)).max(200),
   /** Accounts seen with no saved name yet (Save account names fixes them). */
-  unnamed_accounts: z30.array(z30.string().max(80)).max(200),
+  unnamed_accounts: z31.array(z31.string().max(80)).max(200),
   /** The full report. */
-  output: z30.string().max(2e5)
-});
-var AppsSyncRunParams = z30.strictObject({ app_key: AppKey });
-var AppsWindowsProcessesParams = z30.strictObject({ app_key: AppKey });
-var AppsWindowsProcessesResult = z30.strictObject({ processes: z30.array(z30.string().max(2e3)).max(2e3) });
-var AppsWindowsAddParams = z30.strictObject({ app_key: AppKey, window: ChatPlace, email: z30.string().min(3).max(320) });
-var AppsWindowsSaveNamesParams = z30.strictObject({ app_key: AppKey });
-var AppsWindowsUpdateStateParams = z30.strictObject({ app_key: AppKey });
-var AppsWindowsUpdateStateResult = z30.strictObject({
+  output: z31.string().max(2e5)
+});
+var AppsSyncRunParams = z31.strictObject({ app_key: AppKey });
+var AppsWindowsProcessesParams = z31.strictObject({ app_key: AppKey });
+var AppsWindowsProcessesResult = z31.strictObject({ processes: z31.array(z31.string().max(2e3)).max(2e3) });
+var AppsWindowsAddParams = z31.strictObject({ app_key: AppKey, window: ChatPlace, email: z31.string().min(3).max(320) });
+var AppsWindowsSaveNamesParams = z31.strictObject({ app_key: AppKey });
+var AppsWindowsUpdateStateParams = z31.strictObject({ app_key: AppKey });
+var AppsWindowsUpdateStateResult = z31.strictObject({
   app_key: AppKey,
-  pending: z30.boolean(),
+  pending: z31.boolean(),
   /** The downloaded release's name (Claude: "Claude 2.31226.1"), when the app's log names it. */
-  version: z30.string().max(120).nullable(),
+  version: z31.string().max(120).nullable(),
   /** When the update became pending (the download's time), when known. */
   since_ms: epochMs.nullable(),
   /** Windows open when the update became pending (or last seen open) that are closed now. */
-  closed: z30.array(ChatPlace).max(200),
+  closed: z31.array(ChatPlace).max(200),
   /**
    * Since 1.27: the windows in `closed` that the update itself quit (the app's log records a quit for
    * the update within a minute of when each was last seen running). Absent: not known.
    */
-  closed_by_update: z30.array(ChatPlace).max(200).optional()
+  closed_by_update: z31.array(ChatPlace).max(200).optional()
 });
-var AppsWindowsReopenParams = z30.strictObject({ app_key: AppKey, windows: z30.array(ChatPlace).min(1).max(200) });
-var AppsWindowsReopenResult = z30.strictObject({ message: z30.string().max(400), opened: z30.array(ChatPlace).max(200) });
-var AppsWindowsUpdateAndReopenParams = z30.strictObject({ app_key: AppKey, force: z30.boolean().default(false), dry_run: z30.boolean().default(false) });
-var AppsWindowsUpdateAndReopenResult = z30.strictObject({
-  message: z30.string().max(400),
+var AppsWindowsReopenParams = z31.strictObject({ app_key: AppKey, windows: z31.array(ChatPlace).min(1).max(200) });
+var AppsWindowsReopenResult = z31.strictObject({ message: z31.string().max(400), opened: z31.array(ChatPlace).max(200) });
+var AppsWindowsUpdateAndReopenParams = z31.strictObject({ app_key: AppKey, force: z31.boolean().default(false), dry_run: z31.boolean().default(false) });
+var AppsWindowsUpdateAndReopenResult = z31.strictObject({
+  message: z31.string().max(400),
   /** Windows quit (with dry_run: to be quit). */
-  quit: z30.array(ChatPlace).max(200),
+  quit: z31.array(ChatPlace).max(200),
   /** Windows reopened (with dry_run: to be reopened), main first. */
-  reopened: z30.array(ChatPlace).max(200),
+  reopened: z31.array(ChatPlace).max(200),
   /** The version installed, null when the install did not happen (or dry_run). */
-  installed_version: z30.string().max(64).nullable()
+  installed_version: z31.string().max(64).nullable()
 });
 
 // src/schema/browser.ts
-import { z as z31 } from "zod";
-var BrowserClientInstance = z31.string().min(1).max(64).regex(/^[A-Za-z0-9_.:-]+$/);
-var BrowserKind = z31.enum(["chrome", "edge", "brave", "arc", "opera", "vivaldi", "chromium", "firefox", "other"]);
-var BrowserSessionState = z31.enum(["connected", "different_account", "extension_signed_out", "device_signed_out", "unverified"]);
-var BrowserSession = z31.strictObject({
+import { z as z32 } from "zod";
+var BrowserClientInstance = z32.string().min(1).max(64).regex(/^[A-Za-z0-9_.:-]+$/);
+var BrowserKind = z32.enum(["chrome", "edge", "brave", "arc", "opera", "vivaldi", "chromium", "firefox", "other"]);
+var BrowserSessionState = z32.enum(["connected", "different_account", "extension_signed_out", "device_signed_out", "unverified"]);
+var BrowserSession = z32.strictObject({
   client_instance: BrowserClientInstance,
   /** What the person sees ("Chrome — Work"), set by the extension. */
-  client_label: z31.string().min(1).max(128),
+  client_label: z32.string().min(1).max(128),
   browser: BrowserKind,
-  extension_version: z31.string().min(1).max(32),
+  extension_version: z32.string().min(1).max(32),
   state: BrowserSessionState,
   /** True only for `connected`: an agent's call can reach this session. */
-  routable: z31.boolean(),
+  routable: z32.boolean(),
   /** The extension's account email from its token (null when signed out or unknown). */
-  account_email: z31.string().max(320).nullable(),
+  account_email: z32.string().max(320).nullable(),
   connected_at_ms: epochMs,
   last_call_at_ms: epochMs.nullable(),
   calls: nonNegInt,
@@ -2628,687 +3072,687 @@ var BrowserSession = z31.strictObject({
   p50_ms: nonNegInt.nullable(),
   p95_ms: nonNegInt.nullable(),
   /** A call is waiting for the person to confirm it in the browser. */
-  awaiting_confirmation: z31.boolean()
+  awaiting_confirmation: z32.boolean()
 });
-var BrowserRegisterParams = z31.strictObject({
+var BrowserRegisterParams = z32.strictObject({
   client_instance: BrowserClientInstance,
-  client_label: z31.string().min(1).max(128),
+  client_label: z32.string().min(1).max(128),
   browser: BrowserKind,
-  extension_version: z31.string().min(1).max(32),
+  extension_version: z32.string().min(1).max(32),
   /** The extension's current AI Matrx access token, checked against the device owner; null when signed out. */
-  account_token: z31.string().min(16).max(8192).nullable()
+  account_token: z32.string().min(16).max(8192).nullable()
 });
-var BrowserRegisterResult = z31.strictObject({ session: BrowserSession });
-var BrowserCallError = z31.strictObject({
-  message: z31.string().max(1e3),
+var BrowserRegisterResult = z32.strictObject({ session: BrowserSession });
+var BrowserCallError = z32.strictObject({
+  message: z32.string().max(1e3),
   /** The extension's own error code, when it has one ("tool_not_found", "denied"). */
-  code: z31.string().max(64).nullable()
+  code: z32.string().max(64).nullable()
 });
-var BrowserResultParams = z31.strictObject({
-  call_id: z31.string().min(1).max(64),
-  ok: z31.boolean(),
+var BrowserResultParams = z32.strictObject({
+  call_id: z32.string().min(1).max(64),
+  ok: z32.boolean(),
   /** The tool's result when ok (any JSON). */
-  result: z31.unknown(),
+  result: z32.unknown(),
   error: BrowserCallError.nullable()
 });
-var BrowserResultResult = z31.strictObject({ accepted: z31.boolean() });
-var BrowserCallPhase = z31.enum(["awaiting_confirmation", "running"]);
-var BrowserProgressParams = z31.strictObject({ call_id: z31.string().min(1).max(64), phase: BrowserCallPhase });
-var BrowserProgressResult = z31.strictObject({ accepted: z31.boolean() });
-var BrowserSessionsParams = z31.strictObject({});
-var BrowserSessionsResult = z31.strictObject({
+var BrowserResultResult = z32.strictObject({ accepted: z32.boolean() });
+var BrowserCallPhase = z32.enum(["awaiting_confirmation", "running"]);
+var BrowserProgressParams = z32.strictObject({ call_id: z32.string().min(1).max(64), phase: BrowserCallPhase });
+var BrowserProgressResult = z32.strictObject({ accepted: z32.boolean() });
+var BrowserSessionsParams = z32.strictObject({});
+var BrowserSessionsResult = z32.strictObject({
   /** The person's Browser connection switch. Off: no pairing, no extension sessions. */
-  enabled: z31.boolean(),
+  enabled: z32.boolean(),
   /** Whether Matrx 2 is signed in (without an owner no session is routable). */
-  owner_signed_in: z31.boolean(),
-  sessions: z31.array(BrowserSession).max(64)
-});
-var BrowserDisconnectParams = z31.strictObject({ client_instance: BrowserClientInstance });
-var BrowserDisconnectResult = z31.strictObject({ disconnected: z31.boolean() });
-var BrowserSetEnabledParams = z31.strictObject({ enabled: z31.boolean() });
-var BrowserSetEnabledResult = z31.strictObject({ enabled: z31.boolean() });
-var BrowserPairCodeParams = z31.strictObject({});
-var BrowserPairCodeResult = z31.strictObject({ code: z31.string().min(16).max(128) });
-var BrowserPairResetParams = z31.strictObject({});
-var BrowserCallParams = z31.strictObject({
-  tool: z31.string().min(1).max(96).regex(/^[a-z][a-z0-9_]*$/),
-  args: z31.record(z31.string(), z31.unknown()),
+  owner_signed_in: z32.boolean(),
+  sessions: z32.array(BrowserSession).max(64)
+});
+var BrowserDisconnectParams = z32.strictObject({ client_instance: BrowserClientInstance });
+var BrowserDisconnectResult = z32.strictObject({ disconnected: z32.boolean() });
+var BrowserSetEnabledParams = z32.strictObject({ enabled: z32.boolean() });
+var BrowserSetEnabledResult = z32.strictObject({ enabled: z32.boolean() });
+var BrowserPairCodeParams = z32.strictObject({});
+var BrowserPairCodeResult = z32.strictObject({ code: z32.string().min(16).max(128) });
+var BrowserPairResetParams = z32.strictObject({});
+var BrowserCallParams = z32.strictObject({
+  tool: z32.string().min(1).max(96).regex(/^[a-z][a-z0-9_]*$/),
+  args: z32.record(z32.string(), z32.unknown()),
   /** Which session; default: the most recently active routable one (BROWSER ambiguity → CONFLICT). */
   client_instance: BrowserClientInstance.optional(),
   /** How long to wait, including a person's confirmation; default 120 s. */
-  timeout_ms: z31.int().min(1e3).max(6e5).optional()
+  timeout_ms: z32.int().min(1e3).max(6e5).optional()
 });
-var BrowserCallResult = z31.strictObject({
+var BrowserCallResult = z32.strictObject({
   client_instance: BrowserClientInstance,
-  result: z31.unknown(),
+  result: z32.unknown(),
   duration_ms: nonNegInt
 });
-var BrowserToolMetricsParams = z31.strictObject({ client_instance: BrowserClientInstance });
-var BrowserToolMetric = z31.strictObject({
-  tool: z31.string().max(256),
+var BrowserToolMetricsParams = z32.strictObject({ client_instance: BrowserClientInstance });
+var BrowserToolMetric = z32.strictObject({
+  tool: z32.string().max(256),
   calls: nonNegInt,
   errors: nonNegInt,
   /** Over the last 200 answered calls; null before the first answer. */
   p50_ms: nonNegInt.nullable(),
   p95_ms: nonNegInt.nullable(),
   last_call_at_ms: epochMs.nullable(),
-  last_error: z31.string().max(2048).nullable()
+  last_error: z32.string().max(2048).nullable()
 });
-var BrowserToolMetricsResult = z31.strictObject({ client_instance: z31.string(), tools: z31.array(BrowserToolMetric) });
-var BrowserResetCountersParams = z31.strictObject({ client_instance: BrowserClientInstance });
-var BrowserResetCountersResult = z31.strictObject({ reset: z31.boolean() });
-var BrowserLogParams = z31.strictObject({
+var BrowserToolMetricsResult = z32.strictObject({ client_instance: z32.string(), tools: z32.array(BrowserToolMetric) });
+var BrowserResetCountersParams = z32.strictObject({ client_instance: BrowserClientInstance });
+var BrowserResetCountersResult = z32.strictObject({ reset: z32.boolean() });
+var BrowserLogParams = z32.strictObject({
   /** Only messages after this seq (0: from the oldest kept; the core keeps the last 500). */
   after_seq: nonNegInt.default(0),
-  limit: z31.int().min(1).max(500).default(500)
+  limit: z32.int().min(1).max(500).default(500)
 });
-var BrowserLogMessage = z31.strictObject({
+var BrowserLogMessage = z32.strictObject({
   seq: nonNegInt,
   at_ms: epochMs,
-  direction: z31.enum(["to_browser", "from_browser", "core"]),
-  client_instance: z31.string(),
-  kind: z31.enum(["register", "invoke", "result", "progress", "timeout", "closed"]),
-  tool: z31.string().nullable(),
-  call_id: z31.string().nullable(),
-  ok: z31.boolean().nullable(),
-  detail: z31.string().max(1024)
-});
-var BrowserLogResult = z31.strictObject({
-  messages: z31.array(BrowserLogMessage),
+  direction: z32.enum(["to_browser", "from_browser", "core"]),
+  client_instance: z32.string(),
+  kind: z32.enum(["register", "invoke", "result", "progress", "timeout", "closed"]),
+  tool: z32.string().nullable(),
+  call_id: z32.string().nullable(),
+  ok: z32.boolean().nullable(),
+  detail: z32.string().max(1024)
+});
+var BrowserLogResult = z32.strictObject({
+  messages: z32.array(BrowserLogMessage),
   /** The newest seq the core has written (pass it back as after_seq to follow the log). */
   last_seq: nonNegInt
 });
-var BrowserInvokeEvent = z31.strictObject({
-  call_id: z31.string().min(1).max(64),
-  tool: z31.string().min(1).max(96),
-  args: z31.record(z31.string(), z31.unknown()),
+var BrowserInvokeEvent = z32.strictObject({
+  call_id: z32.string().min(1).max(64),
+  tool: z32.string().min(1).max(96),
+  args: z32.record(z32.string(), z32.unknown()),
   deadline_ms: epochMs
 });
-var BrowserSessionsChangedEvent = z31.strictObject({ count: nonNegInt, enabled: z31.boolean() });
-var BrowserProgressEvent = z31.strictObject({
-  call_id: z31.string().min(1).max(64),
+var BrowserSessionsChangedEvent = z32.strictObject({ count: nonNegInt, enabled: z32.boolean() });
+var BrowserProgressEvent = z32.strictObject({
+  call_id: z32.string().min(1).max(64),
   client_instance: BrowserClientInstance,
   phase: BrowserCallPhase
 });
-var DesktopHealth = z31.strictObject({
-  status: z31.literal("ok"),
-  service: z31.literal("matrx-desktop"),
-  version: z31.string().max(32),
-  protocol_version: z31.string().max(16),
-  ws_path: z31.literal("/v1/connect"),
-  device_id: z31.string().max(64),
-  browser_connection: z31.enum(["on", "off"])
-});
-var BrowserPairRequest = z31.strictObject({ client_instance: BrowserClientInstance });
-var BrowserPairResult = z31.strictObject({ pair_token: z31.string().min(16).max(128), ws_path: z31.literal("/v1/connect") });
+var DesktopHealth = z32.strictObject({
+  status: z32.literal("ok"),
+  service: z32.literal("matrx-desktop"),
+  version: z32.string().max(32),
+  protocol_version: z32.string().max(16),
+  ws_path: z32.literal("/v1/connect"),
+  device_id: z32.string().max(64),
+  browser_connection: z32.enum(["on", "off"])
+});
+var BrowserPairRequest = z32.strictObject({ client_instance: BrowserClientInstance });
+var BrowserPairResult = z32.strictObject({ pair_token: z32.string().min(16).max(128), ws_path: z32.literal("/v1/connect") });
 
 // src/schema/net.ts
-import { z as z32 } from "zod";
-var NetInfoParams = z32.strictObject({});
-var NetAddress = z32.strictObject({
-  address: z32.string(),
-  family: z32.enum(["ipv4", "ipv6"]),
-  netmask: z32.string().nullable(),
+import { z as z33 } from "zod";
+var NetInfoParams = z33.strictObject({});
+var NetAddress = z33.strictObject({
+  address: z33.string(),
+  family: z33.enum(["ipv4", "ipv6"]),
+  netmask: z33.string().nullable(),
   /** CIDR form ("192.168.1.20/24"); null where the OS gives no prefix. */
-  cidr: z32.string().nullable()
+  cidr: z33.string().nullable()
 });
-var NetInterface = z32.strictObject({
-  name: z32.string(),
-  mac: z32.string().nullable(),
+var NetInterface = z33.strictObject({
+  name: z33.string(),
+  mac: z33.string().nullable(),
   /** Loopback and other internal interfaces. */
-  internal: z32.boolean(),
-  addresses: z32.array(NetAddress)
+  internal: z33.boolean(),
+  addresses: z33.array(NetAddress)
 });
-var NetInfoResult = z32.strictObject({
-  hostname: z32.string(),
-  interfaces: z32.array(NetInterface),
+var NetInfoResult = z33.strictObject({
+  hostname: z33.string(),
+  interfaces: z33.array(NetInterface),
   /** The default route's gateway; null when the OS does not say (or there is none). */
-  gateway: z32.string().nullable(),
+  gateway: z33.string().nullable(),
   /** The DNS servers the OS uses; empty when it does not say. */
-  dns: z32.array(z32.string())
+  dns: z33.array(z33.string())
 });
-var NetWifiParams = z32.strictObject({});
-var NetWifiNetwork = z32.strictObject({
+var NetWifiParams = z33.strictObject({});
+var NetWifiNetwork = z33.strictObject({
   /** null: the OS hides the name (macOS without Location Services for this app). */
-  ssid: z32.string().nullable(),
+  ssid: z33.string().nullable(),
   /** dBm; null where the OS does not say. */
-  rssi: z32.int().nullable(),
-  channel: z32.string().nullable(),
-  security: z32.string().nullable()
+  rssi: z33.int().nullable(),
+  channel: z33.string().nullable(),
+  security: z33.string().nullable()
 });
-var NetWifiResult = z32.strictObject({
+var NetWifiResult = z33.strictObject({
   /** Whether the computer has a Wi-Fi interface at all. */
-  available: z32.boolean(),
+  available: z33.boolean(),
   /** The network the computer is on; null when it is on none. */
   current: NetWifiNetwork.nullable(),
   /** Networks in range (may be empty where the OS lists none to apps). */
-  networks: z32.array(NetWifiNetwork)
+  networks: z33.array(NetWifiNetwork)
 });
-var NetBluetoothParams = z32.strictObject({});
-var NetBluetoothDevice = z32.strictObject({
-  name: z32.string(),
-  address: z32.string().nullable(),
-  connected: z32.boolean(),
+var NetBluetoothParams = z33.strictObject({});
+var NetBluetoothDevice = z33.strictObject({
+  name: z33.string(),
+  address: z33.string().nullable(),
+  connected: z33.boolean(),
   /** What it is, in the OS's words ("Headphones", "Keyboard"); null where it does not say. */
-  kind: z32.string().nullable(),
+  kind: z33.string().nullable(),
   /** Battery percent, where the OS reports it. */
-  battery: z32.int().min(0).max(100).nullable()
+  battery: z33.int().min(0).max(100).nullable()
 });
-var NetBluetoothResult = z32.strictObject({
+var NetBluetoothResult = z33.strictObject({
   /** Bluetooth is on; null where the OS does not say. */
-  powered: z32.boolean().nullable(),
-  devices: z32.array(NetBluetoothDevice)
-});
-var NetDevicesParams = z32.strictObject({});
-var NetDevice = z32.strictObject({
-  ip: z32.string(),
-  mac: z32.string().nullable(),
-  interface: z32.string().nullable(),
+  powered: z33.boolean().nullable(),
+  devices: z33.array(NetBluetoothDevice)
+});
+var NetDevicesParams = z33.strictObject({});
+var NetDevice = z33.strictObject({
+  ip: z33.string(),
+  mac: z33.string().nullable(),
+  interface: z33.string().nullable(),
   /** The name the local network gives it (reverse DNS / mDNS), when the table carries one. */
-  hostname: z32.string().nullable()
+  hostname: z33.string().nullable()
 });
-var NetDevicesResult = z32.strictObject({ devices: z32.array(NetDevice) });
-var NetMdnsParams = z32.strictObject({
+var NetDevicesResult = z33.strictObject({ devices: z33.array(NetDevice) });
+var NetMdnsParams = z33.strictObject({
   /** A service type ("_http._tcp"); absent lists the service types found. */
-  service_type: z32.string().min(1).max(64).regex(/^_[A-Za-z0-9-]+\._(tcp|udp)$/).optional(),
+  service_type: z33.string().min(1).max(64).regex(/^_[A-Za-z0-9-]+\._(tcp|udp)$/).optional(),
   /** How long to listen. */
-  timeout_s: z32.int().min(1).max(30).default(3)
+  timeout_s: z33.int().min(1).max(30).default(3)
 });
-var NetMdnsService = z32.strictObject({
-  name: z32.string(),
-  type: z32.string(),
-  domain: z32.string(),
-  interface: z32.string().nullable()
+var NetMdnsService = z33.strictObject({
+  name: z33.string(),
+  type: z33.string(),
+  domain: z33.string(),
+  interface: z33.string().nullable()
 });
-var NetMdnsResult = z32.strictObject({ services: z32.array(NetMdnsService) });
-var NetScanParams = z32.strictObject({
+var NetMdnsResult = z33.strictObject({ services: z33.array(NetMdnsService) });
+var NetScanParams = z33.strictObject({
   /** A host name or address; a private or loopback address unless `allow_public`. */
-  host: z32.string().min(1).max(253),
-  ports: z32.array(z32.int().min(1).max(65535)).min(1).max(1024),
-  timeout_ms: z32.int().min(50).max(1e4).default(800),
+  host: z33.string().min(1).max(253),
+  ports: z33.array(z33.int().min(1).max(65535)).min(1).max(1024),
+  timeout_ms: z33.int().min(50).max(1e4).default(800),
   /** Scanning a host on the public internet needs saying so. */
-  allow_public: z32.boolean().default(false)
+  allow_public: z33.boolean().default(false)
 });
-var NetScanResult = z32.strictObject({
-  host: z32.string(),
+var NetScanResult = z33.strictObject({
+  host: z33.string(),
   /** The address the host resolved to. */
-  address: z32.string(),
-  open: z32.array(z32.int().min(1).max(65535)),
+  address: z33.string(),
+  open: z33.array(z33.int().min(1).max(65535)),
   closed: nonNegInt,
   elapsed_ms: nonNegInt
 });
-var NetDownloadParams = z32.strictObject({
-  url: z32.string().min(1).max(8192).regex(/^https?:\/\//),
+var NetDownloadParams = z33.strictObject({
+  url: z33.string().min(1).max(8192).regex(/^https?:\/\//),
   /** Where to save it: an absolute path (a folder keeps the URL's file name). */
   path: AbsPath,
-  overwrite: z32.boolean().default(false),
-  timeout_s: z32.int().min(1).max(3600).default(300),
+  overwrite: z33.boolean().default(false),
+  timeout_s: z33.int().min(1).max(3600).default(300),
   /** Refuse anything larger. */
-  max_bytes: z32.int().min(1).max(10737418240).default(2147483648)
+  max_bytes: z33.int().min(1).max(10737418240).default(2147483648)
 });
-var NetDownloadResult = z32.strictObject({
-  path: z32.string(),
+var NetDownloadResult = z33.strictObject({
+  path: z33.string(),
   bytes: nonNegInt,
-  content_type: z32.string().nullable(),
+  content_type: z33.string().nullable(),
   /** The final URL after redirects. */
-  url: z32.string(),
+  url: z33.string(),
   elapsed_ms: nonNegInt
 });
 
 // src/schema/personal.ts
-import { z as z33 } from "zod";
-var Text = z33.string().max(65536);
-var AutomationScriptParams = z33.strictObject({
+import { z as z34 } from "zod";
+var Text = z34.string().max(65536);
+var AutomationScriptParams = z34.strictObject({
   /** applescript and jxa: macOS (osascript); powershell: Windows (and pwsh where installed). */
-  language: z33.enum(["applescript", "jxa", "powershell"]),
-  script: z33.string().min(1).max(262144),
-  timeout_s: z33.int().min(1).max(600).default(60)
-});
-var AutomationScriptResult = z33.strictObject({
-  stdout: z33.string(),
-  stderr: z33.string(),
-  exit_code: z33.int(),
-  timed_out: z33.boolean(),
+  language: z34.enum(["applescript", "jxa", "powershell"]),
+  script: z34.string().min(1).max(262144),
+  timeout_s: z34.int().min(1).max(600).default(60)
+});
+var AutomationScriptResult = z34.strictObject({
+  stdout: z34.string(),
+  stderr: z34.string(),
+  exit_code: z34.int(),
+  timed_out: z34.boolean(),
   /** stdout or stderr was cut at 1 MiB. */
-  truncated: z33.boolean(),
+  truncated: z34.boolean(),
   elapsed_ms: nonNegInt
 });
-var MailAccountsParams = z33.strictObject({});
-var MailAccount = z33.strictObject({ name: z33.string(), emails: z33.array(z33.string()), enabled: z33.boolean() });
-var MailAccountsResult = z33.strictObject({ accounts: z33.array(MailAccount) });
-var MailListParams = z33.strictObject({
+var MailAccountsParams = z34.strictObject({});
+var MailAccount = z34.strictObject({ name: z34.string(), emails: z34.array(z34.string()), enabled: z34.boolean() });
+var MailAccountsResult = z34.strictObject({ accounts: z34.array(MailAccount) });
+var MailListParams = z34.strictObject({
   /** The account's name in Mail; absent: every account. */
-  account: z33.string().min(1).max(256).optional(),
+  account: z34.string().min(1).max(256).optional(),
   /** The mailbox's name ("INBOX", "Sent Messages"). */
-  mailbox: z33.string().min(1).max(256).default("INBOX"),
-  unread_only: z33.boolean().default(false),
-  limit: z33.int().min(1).max(200).default(25)
-});
-var MailMessage = z33.strictObject({
-  id: z33.string(),
-  subject: z33.string(),
-  sender: z33.string(),
+  mailbox: z34.string().min(1).max(256).default("INBOX"),
+  unread_only: z34.boolean().default(false),
+  limit: z34.int().min(1).max(200).default(25)
+});
+var MailMessage = z34.strictObject({
+  id: z34.string(),
+  subject: z34.string(),
+  sender: z34.string(),
   received_at_ms: epochMs.nullable(),
-  read: z33.boolean(),
-  account: z33.string(),
-  mailbox: z33.string(),
+  read: z34.boolean(),
+  account: z34.string(),
+  mailbox: z34.string(),
   /** The first lines of the message's text. */
-  preview: z33.string()
+  preview: z34.string()
 });
-var MailListResult = z33.strictObject({ messages: z33.array(MailMessage) });
-var MailSendParams = z33.strictObject({
-  to: z33.array(z33.string().min(3).max(320)).min(1).max(50),
-  cc: z33.array(z33.string().min(3).max(320)).max(50).default([]),
-  subject: z33.string().max(998),
+var MailListResult = z34.strictObject({ messages: z34.array(MailMessage) });
+var MailSendParams = z34.strictObject({
+  to: z34.array(z34.string().min(3).max(320)).min(1).max(50),
+  cc: z34.array(z34.string().min(3).max(320)).max(50).default([]),
+  subject: z34.string().max(998),
   body: Text,
   /** The sending account's address; absent: Mail's default. */
-  from: z33.string().min(3).max(320).optional(),
+  from: z34.string().min(3).max(320).optional(),
   /** false leaves it open in Mail as a draft for the person to send. */
-  send: z33.boolean().default(true)
-});
-var MailSendResult = z33.strictObject({ sent: z33.boolean() });
-var MessagesChatsParams = z33.strictObject({ limit: z33.int().min(1).max(200).default(25) });
-var MessagesChat = z33.strictObject({
-  chat_id: z33.string(),
-  name: z33.string().nullable(),
-  participants: z33.array(z33.string()),
+  send: z34.boolean().default(true)
+});
+var MailSendResult = z34.strictObject({ sent: z34.boolean() });
+var MessagesChatsParams = z34.strictObject({ limit: z34.int().min(1).max(200).default(25) });
+var MessagesChat = z34.strictObject({
+  chat_id: z34.string(),
+  name: z34.string().nullable(),
+  participants: z34.array(z34.string()),
   last_message_at_ms: epochMs.nullable(),
-  service: z33.string().nullable()
+  service: z34.string().nullable()
 });
-var MessagesChatsResult = z33.strictObject({ chats: z33.array(MessagesChat) });
-var MessagesListParams = z33.strictObject({
+var MessagesChatsResult = z34.strictObject({ chats: z34.array(MessagesChat) });
+var MessagesListParams = z34.strictObject({
   /** One chat (messages.chats' chat_id); absent: the newest across all. */
-  chat_id: z33.string().min(1).max(512).optional(),
-  limit: z33.int().min(1).max(500).default(50)
-});
-var MessagesMessage = z33.strictObject({
-  id: z33.string(),
-  chat_id: z33.string().nullable(),
-  text: z33.string(),
-  from_me: z33.boolean(),
+  chat_id: z34.string().min(1).max(512).optional(),
+  limit: z34.int().min(1).max(500).default(50)
+});
+var MessagesMessage = z34.strictObject({
+  id: z34.string(),
+  chat_id: z34.string().nullable(),
+  text: z34.string(),
+  from_me: z34.boolean(),
   /** The other person's handle (phone or email); null for the person's own messages. */
-  sender: z33.string().nullable(),
+  sender: z34.string().nullable(),
   sent_at_ms: epochMs.nullable()
 });
-var MessagesListResult = z33.strictObject({ messages: z33.array(MessagesMessage) });
-var MessagesSendParams = z33.strictObject({
+var MessagesListResult = z34.strictObject({ messages: z34.array(MessagesMessage) });
+var MessagesSendParams = z34.strictObject({
   /** A phone number or email the person can message. */
-  to: z33.string().min(3).max(320),
-  text: z33.string().min(1).max(2e4)
+  to: z34.string().min(3).max(320),
+  text: z34.string().min(1).max(2e4)
 });
-var MessagesSendResult = z33.strictObject({ sent: z33.boolean() });
-var ContactsSearchParams = z33.strictObject({
+var MessagesSendResult = z34.strictObject({ sent: z34.boolean() });
+var ContactsSearchParams = z34.strictObject({
   /** Matched against names, organizations, emails and phone numbers. */
-  query: z33.string().min(1).max(256),
-  limit: z33.int().min(1).max(200).default(25)
+  query: z34.string().min(1).max(256),
+  limit: z34.int().min(1).max(200).default(25)
 });
-var ContactLabeled = z33.strictObject({ label: z33.string().nullable(), value: z33.string() });
-var ContactSummary = z33.strictObject({
-  id: z33.string(),
-  name: z33.string(),
-  organization: z33.string().nullable(),
-  emails: z33.array(ContactLabeled),
-  phones: z33.array(ContactLabeled)
-});
-var ContactsSearchResult = z33.strictObject({ contacts: z33.array(ContactSummary) });
-var ContactsGetParams = z33.strictObject({ id: z33.string().min(1).max(256) });
-var ContactDetail = z33.strictObject({
-  id: z33.string(),
-  name: z33.string(),
-  organization: z33.string().nullable(),
-  job_title: z33.string().nullable(),
-  emails: z33.array(ContactLabeled),
-  phones: z33.array(ContactLabeled),
-  addresses: z33.array(ContactLabeled),
-  birthday: z33.string().nullable(),
-  note: z33.string().nullable()
-});
-var ContactsGetResult = z33.strictObject({ contact: ContactDetail });
-var CalendarListParams = z33.strictObject({
+var ContactLabeled = z34.strictObject({ label: z34.string().nullable(), value: z34.string() });
+var ContactSummary = z34.strictObject({
+  id: z34.string(),
+  name: z34.string(),
+  organization: z34.string().nullable(),
+  emails: z34.array(ContactLabeled),
+  phones: z34.array(ContactLabeled)
+});
+var ContactsSearchResult = z34.strictObject({ contacts: z34.array(ContactSummary) });
+var ContactsGetParams = z34.strictObject({ id: z34.string().min(1).max(256) });
+var ContactDetail = z34.strictObject({
+  id: z34.string(),
+  name: z34.string(),
+  organization: z34.string().nullable(),
+  job_title: z34.string().nullable(),
+  emails: z34.array(ContactLabeled),
+  phones: z34.array(ContactLabeled),
+  addresses: z34.array(ContactLabeled),
+  birthday: z34.string().nullable(),
+  note: z34.string().nullable()
+});
+var ContactsGetResult = z34.strictObject({ contact: ContactDetail });
+var CalendarListParams = z34.strictObject({
   from_ms: epochMs,
   to_ms: epochMs,
   /** One calendar's name; absent: every calendar. */
-  calendar: z33.string().min(1).max(256).optional(),
-  limit: z33.int().min(1).max(500).default(100)
+  calendar: z34.string().min(1).max(256).optional(),
+  limit: z34.int().min(1).max(500).default(100)
 });
-var CalendarEvent = z33.strictObject({
-  id: z33.string(),
-  title: z33.string(),
+var CalendarEvent = z34.strictObject({
+  id: z34.string(),
+  title: z34.string(),
   start_ms: epochMs,
   end_ms: epochMs,
-  all_day: z33.boolean(),
-  calendar: z33.string(),
-  location: z33.string().nullable(),
-  notes: z33.string().nullable()
-});
-var CalendarListResult = z33.strictObject({ events: z33.array(CalendarEvent) });
-var CalendarCreateParams = z33.strictObject({
-  title: z33.string().min(1).max(1024),
+  all_day: z34.boolean(),
+  calendar: z34.string(),
+  location: z34.string().nullable(),
+  notes: z34.string().nullable()
+});
+var CalendarListResult = z34.strictObject({ events: z34.array(CalendarEvent) });
+var CalendarCreateParams = z34.strictObject({
+  title: z34.string().min(1).max(1024),
   start_ms: epochMs,
   end_ms: epochMs,
-  all_day: z33.boolean().default(false),
+  all_day: z34.boolean().default(false),
   /** The calendar's name; absent: the first writable calendar. */
-  calendar: z33.string().min(1).max(256).optional(),
-  location: z33.string().max(1024).optional(),
+  calendar: z34.string().min(1).max(256).optional(),
+  location: z34.string().max(1024).optional(),
   notes: Text.optional()
 });
-var CalendarCreateResult = z33.strictObject({ id: z33.string(), calendar: z33.string() });
-var RemindersListParams = z33.strictObject({
+var CalendarCreateResult = z34.strictObject({ id: z34.string(), calendar: z34.string() });
+var RemindersListParams = z34.strictObject({
   /** One list's name; absent: every list. */
-  list: z33.string().min(1).max(256).optional(),
-  include_completed: z33.boolean().default(false),
-  limit: z33.int().min(1).max(500).default(100)
-});
-var Reminder = z33.strictObject({
-  id: z33.string(),
-  title: z33.string(),
-  list: z33.string(),
+  list: z34.string().min(1).max(256).optional(),
+  include_completed: z34.boolean().default(false),
+  limit: z34.int().min(1).max(500).default(100)
+});
+var Reminder = z34.strictObject({
+  id: z34.string(),
+  title: z34.string(),
+  list: z34.string(),
   due_ms: epochMs.nullable(),
-  completed: z33.boolean(),
-  notes: z33.string().nullable()
+  completed: z34.boolean(),
+  notes: z34.string().nullable()
 });
-var RemindersListResult = z33.strictObject({ reminders: z33.array(Reminder) });
-var RemindersCreateParams = z33.strictObject({
-  title: z33.string().min(1).max(1024),
+var RemindersListResult = z34.strictObject({ reminders: z34.array(Reminder) });
+var RemindersCreateParams = z34.strictObject({
+  title: z34.string().min(1).max(1024),
   due_ms: epochMs.optional(),
-  list: z33.string().min(1).max(256).optional(),
+  list: z34.string().min(1).max(256).optional(),
   notes: Text.optional()
 });
-var RemindersCreateResult = z33.strictObject({ id: z33.string(), list: z33.string() });
-var PhotosSearchParams = z33.strictObject({
+var RemindersCreateResult = z34.strictObject({ id: z34.string(), list: z34.string() });
+var PhotosSearchParams = z34.strictObject({
   /** Matched against file names, titles, descriptions and keywords; absent: the newest. */
-  query: z33.string().min(1).max(256).optional(),
+  query: z34.string().min(1).max(256).optional(),
   from_ms: epochMs.optional(),
   to_ms: epochMs.optional(),
-  favorites_only: z33.boolean().default(false),
-  limit: z33.int().min(1).max(200).default(25)
+  favorites_only: z34.boolean().default(false),
+  limit: z34.int().min(1).max(200).default(25)
 });
-var Photo = z33.strictObject({
-  id: z33.string(),
-  filename: z33.string(),
+var Photo = z34.strictObject({
+  id: z34.string(),
+  filename: z34.string(),
   taken_at_ms: epochMs.nullable(),
   width: nonNegInt.nullable(),
   height: nonNegInt.nullable(),
-  favorite: z33.boolean(),
-  title: z33.string().nullable()
+  favorite: z34.boolean(),
+  title: z34.string().nullable()
 });
-var PhotosSearchResult = z33.strictObject({ photos: z33.array(Photo) });
-var PhotosGetParams = z33.strictObject({
-  id: z33.string().min(1).max(256),
+var PhotosSearchResult = z34.strictObject({ photos: z34.array(Photo) });
+var PhotosGetParams = z34.strictObject({
+  id: z34.string().min(1).max(256),
   /** Copy the original into a folder Matrx 2 owns and answer its path (then fs_read or desktop_documents reads it). */
-  export: z33.boolean().default(false)
+  export: z34.boolean().default(false)
 });
-var PhotosGetResult = z33.strictObject({ photo: Photo, path: z33.string().nullable() });
-var LocationGetParams = z33.strictObject({ timeout_s: z33.int().min(1).max(60).default(15) });
-var LocationGetResult = z33.strictObject({
-  latitude: z33.number().min(-90).max(90),
-  longitude: z33.number().min(-180).max(180),
+var PhotosGetResult = z34.strictObject({ photo: Photo, path: z34.string().nullable() });
+var LocationGetParams = z34.strictObject({ timeout_s: z34.int().min(1).max(60).default(15) });
+var LocationGetResult = z34.strictObject({
+  latitude: z34.number().min(-90).max(90),
+  longitude: z34.number().min(-180).max(180),
   /** Metres; null where the OS does not say. */
-  accuracy_m: z33.number().min(0).nullable(),
+  accuracy_m: z34.number().min(0).nullable(),
   at_ms: epochMs,
   /** Who answered: the OS's own location service. */
-  source: z33.enum(["corelocation", "windows", "geoclue"])
+  source: z34.enum(["corelocation", "windows", "geoclue"])
 });
 
 // src/schema/windows.ts
-import { z as z34 } from "zod";
-var RegistryKey = z34.string().min(6).max(1024).regex(/^(HKLM|HKCU|HKCR|HKU|HKCC|HKEY_LOCAL_MACHINE|HKEY_CURRENT_USER|HKEY_CLASSES_ROOT|HKEY_USERS|HKEY_CURRENT_CONFIG)(\\.*)?$/);
-var RegistryValueType = z34.enum(["REG_SZ", "REG_EXPAND_SZ", "REG_MULTI_SZ", "REG_DWORD", "REG_QWORD", "REG_BINARY", "REG_NONE"]);
-var WindowsRegistryReadParams = z34.strictObject({
+import { z as z35 } from "zod";
+var RegistryKey = z35.string().min(6).max(1024).regex(/^(HKLM|HKCU|HKCR|HKU|HKCC|HKEY_LOCAL_MACHINE|HKEY_CURRENT_USER|HKEY_CLASSES_ROOT|HKEY_USERS|HKEY_CURRENT_CONFIG)(\\.*)?$/);
+var RegistryValueType = z35.enum(["REG_SZ", "REG_EXPAND_SZ", "REG_MULTI_SZ", "REG_DWORD", "REG_QWORD", "REG_BINARY", "REG_NONE"]);
+var WindowsRegistryReadParams = z35.strictObject({
   key: RegistryKey,
   /** One value's name ("" is the key's default value); absent: every value and the subkeys. */
-  name: z34.string().max(16383).optional()
+  name: z35.string().max(16383).optional()
 });
-var RegistryValue = z34.strictObject({ name: z34.string(), type: RegistryValueType, data: z34.string() });
-var WindowsRegistryReadResult = z34.strictObject({
-  key: z34.string(),
-  exists: z34.boolean(),
-  values: z34.array(RegistryValue),
-  subkeys: z34.array(z34.string())
+var RegistryValue = z35.strictObject({ name: z35.string(), type: RegistryValueType, data: z35.string() });
+var WindowsRegistryReadResult = z35.strictObject({
+  key: z35.string(),
+  exists: z35.boolean(),
+  values: z35.array(RegistryValue),
+  subkeys: z35.array(z35.string())
 });
-var WindowsRegistryWriteParams = z34.strictObject({
+var WindowsRegistryWriteParams = z35.strictObject({
   key: RegistryKey,
-  name: z34.string().max(16383),
+  name: z35.string().max(16383),
   type: RegistryValueType.default("REG_SZ"),
   /** As reg.exe takes it: text, a number, hex for binary, \\0 between the strings of a multi-string. */
-  data: z34.string().max(1048576),
+  data: z35.string().max(1048576),
   /** Remove the value instead of writing it. */
-  delete: z34.boolean().default(false)
+  delete: z35.boolean().default(false)
 });
-var WindowsRegistryWriteResult = z34.strictObject({ key: z34.string(), name: z34.string(), deleted: z34.boolean() });
-var WindowsServicesParams = z34.strictObject({
+var WindowsRegistryWriteResult = z35.strictObject({ key: z35.string(), name: z35.string(), deleted: z35.boolean() });
+var WindowsServicesParams = z35.strictObject({
   /** Matched against the service's name and display name. */
-  filter: z34.string().min(1).max(256).optional(),
-  limit: z34.int().min(1).max(1e3).default(200)
+  filter: z35.string().min(1).max(256).optional(),
+  limit: z35.int().min(1).max(1e3).default(200)
 });
-var WindowsService = z34.strictObject({
-  name: z34.string(),
-  display_name: z34.string(),
+var WindowsService = z35.strictObject({
+  name: z35.string(),
+  display_name: z35.string(),
   /** Running, Stopped, Paused… as Windows says it. */
-  status: z34.string(),
+  status: z35.string(),
   /** Automatic, Manual, Disabled…; null where Windows does not say. */
-  start_type: z34.string().nullable()
+  start_type: z35.string().nullable()
 });
-var WindowsServicesResult = z34.strictObject({ services: z34.array(WindowsService) });
-var WindowsServiceControlParams = z34.strictObject({
-  name: z34.string().min(1).max(256),
-  action: z34.enum(["start", "stop", "restart"])
+var WindowsServicesResult = z35.strictObject({ services: z35.array(WindowsService) });
+var WindowsServiceControlParams = z35.strictObject({
+  name: z35.string().min(1).max(256),
+  action: z35.enum(["start", "stop", "restart"])
 });
-var WindowsServiceControlResult = z34.strictObject({ name: z34.string(), status: z34.string() });
-var WindowsEventLogParams = z34.strictObject({
-  log: z34.string().min(1).max(256).default("System"),
+var WindowsServiceControlResult = z35.strictObject({ name: z35.string(), status: z35.string() });
+var WindowsEventLogParams = z35.strictObject({
+  log: z35.string().min(1).max(256).default("System"),
   /** Only these levels; absent: all. */
-  levels: z34.array(z34.enum(["critical", "error", "warning", "information", "verbose"])).max(5).optional(),
+  levels: z35.array(z35.enum(["critical", "error", "warning", "information", "verbose"])).max(5).optional(),
   since_ms: epochMs.optional(),
-  limit: z34.int().min(1).max(500).default(50)
+  limit: z35.int().min(1).max(500).default(50)
 });
-var WindowsEvent = z34.strictObject({
-  id: z34.int(),
-  level: z34.string(),
-  source: z34.string(),
+var WindowsEvent = z35.strictObject({
+  id: z35.int(),
+  level: z35.string(),
+  source: z35.string(),
   at_ms: epochMs,
-  message: z34.string()
+  message: z35.string()
 });
-var WindowsEventLogResult = z34.strictObject({ log: z34.string(), events: z34.array(WindowsEvent) });
-var WindowsFeaturesParams = z34.strictObject({ filter: z34.string().min(1).max(256).optional() });
-var WindowsFeature = z34.strictObject({ name: z34.string(), state: z34.string() });
-var WindowsFeaturesResult = z34.strictObject({ features: z34.array(WindowsFeature) });
+var WindowsEventLogResult = z35.strictObject({ log: z35.string(), events: z35.array(WindowsEvent) });
+var WindowsFeaturesParams = z35.strictObject({ filter: z35.string().min(1).max(256).optional() });
+var WindowsFeature = z35.strictObject({ name: z35.string(), state: z35.string() });
+var WindowsFeaturesResult = z35.strictObject({ features: z35.array(WindowsFeature) });
 
 // src/schema/schedule.ts
-import { z as z35 } from "zod";
-var OpRef = z35.string().min(3).max(128).regex(/^[a-z_]+(\.[a-z_]+)+$/);
-var ScheduleCreateParams = z35.strictObject({
-  name: z35.string().min(1).max(200),
+import { z as z36 } from "zod";
+var OpRef = z36.string().min(3).max(128).regex(/^[a-z_]+(\.[a-z_]+)+$/);
+var ScheduleCreateParams = z36.strictObject({
+  name: z36.string().min(1).max(200),
   op: OpRef,
   /** The op's params, exactly as the op takes them; checked when the task is created. */
-  params: z35.record(z35.string(), z35.unknown()).default({}),
-  interval_s: z35.int().min(10).max(2592e3),
+  params: z36.record(z36.string(), z36.unknown()).default({}),
+  interval_s: z36.int().min(10).max(2592e3),
   /** Stop after this many runs; absent: until cancelled. */
-  max_runs: z35.int().min(1).max(1e5).optional(),
+  max_runs: z36.int().min(1).max(1e5).optional(),
   /** Run once now, before the first interval. */
-  run_now: z35.boolean().default(false)
+  run_now: z36.boolean().default(false)
 });
-var ScheduleRun = z35.strictObject({
+var ScheduleRun = z36.strictObject({
   at_ms: epochMs,
-  ok: z35.boolean(),
+  ok: z36.boolean(),
   elapsed_ms: nonNegInt,
   /** The error's code and message when the run failed. */
-  error: z35.string().nullable(),
+  error: z36.string().nullable(),
   /** The start of the answer, as JSON (cut at 4 KiB). */
-  result_preview: z35.string().nullable()
+  result_preview: z36.string().nullable()
 });
-var ScheduledTask = z35.strictObject({
-  id: z35.string(),
-  name: z35.string(),
-  op: z35.string(),
-  params: z35.record(z35.string(), z35.unknown()),
+var ScheduledTask = z36.strictObject({
+  id: z36.string(),
+  name: z36.string(),
+  op: z36.string(),
+  params: z36.record(z36.string(), z36.unknown()),
   interval_s: nonNegInt,
   max_runs: nonNegInt.nullable(),
   runs: nonNegInt,
   created_at_ms: epochMs,
   next_run_at_ms: epochMs.nullable(),
   /** active, done (ran max_runs), cancelled. */
-  state: z35.enum(["active", "done", "cancelled"]),
+  state: z36.enum(["active", "done", "cancelled"]),
   /** The newest runs, newest first (at most 10). */
-  recent: z35.array(ScheduleRun)
+  recent: z36.array(ScheduleRun)
 });
-var ScheduleCreateResult = z35.strictObject({ task: ScheduledTask });
-var ScheduleListParams = z35.strictObject({ include_finished: z35.boolean().default(false) });
-var ScheduleListResult = z35.strictObject({ tasks: z35.array(ScheduledTask) });
-var ScheduleCancelParams = z35.strictObject({ id: z35.string().min(1).max(64) });
-var ScheduleCancelResult = z35.strictObject({ task: ScheduledTask });
+var ScheduleCreateResult = z36.strictObject({ task: ScheduledTask });
+var ScheduleListParams = z36.strictObject({ include_finished: z36.boolean().default(false) });
+var ScheduleListResult = z36.strictObject({ tasks: z36.array(ScheduledTask) });
+var ScheduleCancelParams = z36.strictObject({ id: z36.string().min(1).max(64) });
+var ScheduleCancelResult = z36.strictObject({ task: ScheduledTask });
 
 // src/schema/notes.ts
-import { z as z36 } from "zod";
-var NoteFolder = z36.string().min(1).max(512).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*$/);
-var NotePath = z36.string().min(4).max(1024).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*\.md$/);
-var NotesFoldersParams = z36.strictObject({});
-var NotesFolder = z36.strictObject({ folder: z36.string(), notes: nonNegInt });
-var NotesFoldersResult = z36.strictObject({
+import { z as z37 } from "zod";
+var NoteFolder = z37.string().min(1).max(512).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*$/);
+var NotePath = z37.string().min(4).max(1024).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*\.md$/);
+var NotesFoldersParams = z37.strictObject({});
+var NotesFolder = z37.strictObject({ folder: z37.string(), notes: nonNegInt });
+var NotesFoldersResult = z37.strictObject({
   /** The notes root on this computer. */
-  root: z36.string(),
-  folders: z36.array(NotesFolder)
+  root: z37.string(),
+  folders: z37.array(NotesFolder)
 });
-var NotesListParams = z36.strictObject({
+var NotesListParams = z37.strictObject({
   folder: NoteFolder.optional(),
-  limit: z36.int().min(1).max(2e3).default(500)
+  limit: z37.int().min(1).max(2e3).default(500)
 });
-var NoteEntry = z36.strictObject({
-  path: z36.string(),
-  label: z36.string(),
-  folder: z36.string(),
+var NoteEntry = z37.strictObject({
+  path: z37.string(),
+  label: z37.string(),
+  folder: z37.string(),
   bytes: nonNegInt,
   modified_at_ms: epochMs
 });
-var NotesListResult = z36.strictObject({ root: z36.string(), notes: z36.array(NoteEntry), total: nonNegInt });
-var NotesReadParams = z36.strictObject({ path: NotePath });
-var NotesReadResult = z36.strictObject({
-  path: z36.string(),
-  content: z36.string(),
+var NotesListResult = z37.strictObject({ root: z37.string(), notes: z37.array(NoteEntry), total: nonNegInt });
+var NotesReadParams = z37.strictObject({ path: NotePath });
+var NotesReadResult = z37.strictObject({
+  path: z37.string(),
+  content: z37.string(),
   bytes: nonNegInt,
   modified_at_ms: epochMs,
   /** SHA-256 of the content: pass it back as `if_hash` to write only over this version. */
-  hash: z36.string()
+  hash: z37.string()
 });
-var NotesWriteParams = z36.strictObject({
+var NotesWriteParams = z37.strictObject({
   folder: NoteFolder.default("General"),
   /** The note's name, without ".md". */
-  label: z36.string().min(1).max(200).regex(/^[^/\\:*?"<>|]+$/),
-  content: z36.string().max(10485760),
+  label: z37.string().min(1).max(200).regex(/^[^/\\:*?"<>|]+$/),
+  content: z37.string().max(10485760),
   /** Write only when the note is still this version (notes.read's hash); a change since answers CONFLICT. */
-  if_hash: z36.string().length(64).optional()
+  if_hash: z37.string().length(64).optional()
 });
-var NotesWriteResult = z36.strictObject({ path: z36.string(), bytes: nonNegInt, created: z36.boolean(), hash: z36.string() });
-var NotesSearchParams = z36.strictObject({
-  query: z36.string().min(1).max(512),
-  limit: z36.int().min(1).max(200).default(50)
+var NotesWriteResult = z37.strictObject({ path: z37.string(), bytes: nonNegInt, created: z37.boolean(), hash: z37.string() });
+var NotesSearchParams = z37.strictObject({
+  query: z37.string().min(1).max(512),
+  limit: z37.int().min(1).max(200).default(50)
 });
-var NotesMatch = z36.strictObject({
-  path: z36.string(),
-  label: z36.string(),
-  folder: z36.string(),
+var NotesMatch = z37.strictObject({
+  path: z37.string(),
+  label: z37.string(),
+  folder: z37.string(),
   /** The matching lines (at most five), trimmed. */
-  lines: z36.array(z36.string())
+  lines: z37.array(z37.string())
 });
-var NotesSearchResult = z36.strictObject({ matches: z36.array(NotesMatch), total: nonNegInt });
+var NotesSearchResult = z37.strictObject({ matches: z37.array(NotesMatch), total: nonNegInt });
 
 // src/schema/documents.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 var DOCUMENTS_MAX_TEXT_CHARS = 1048576;
-var DocumentsPdfTextParams = z37.strictObject({
+var DocumentsPdfTextParams = z38.strictObject({
   path: AbsPath,
   /** 1-based, inclusive. */
-  first_page: z37.int().min(1).optional(),
-  last_page: z37.int().min(1).optional(),
-  max_chars: z37.int().min(1).max(DOCUMENTS_MAX_TEXT_CHARS).default(2e5)
+  first_page: z38.int().min(1).optional(),
+  last_page: z38.int().min(1).optional(),
+  max_chars: z38.int().min(1).max(DOCUMENTS_MAX_TEXT_CHARS).default(2e5)
 });
-var DocumentsPdfPage = z37.strictObject({ page: z37.int().min(1), text: z37.string() });
-var DocumentsPdfTextResult = z37.strictObject({
+var DocumentsPdfPage = z38.strictObject({ page: z38.int().min(1), text: z38.string() });
+var DocumentsPdfTextResult = z38.strictObject({
   pages: nonNegInt,
   /** Each page read, in order (an image-only page has empty text: OCR it). */
-  read: z37.array(DocumentsPdfPage),
-  truncated: z37.boolean(),
-  title: z37.string().nullable(),
-  author: z37.string().nullable()
+  read: z38.array(DocumentsPdfPage),
+  truncated: z38.boolean(),
+  title: z38.string().nullable(),
+  author: z38.string().nullable()
 });
-var DocumentsOcrParams = z37.strictObject({
+var DocumentsOcrParams = z38.strictObject({
   path: AbsPath,
   /** BCP-47 language hints ("en-US", "fr-FR"); absent: the OS's own choice. */
-  languages: z37.array(z37.string().min(2).max(16)).max(8).optional(),
+  languages: z38.array(z38.string().min(2).max(16)).max(8).optional(),
   /** Faster, less accurate. */
-  fast: z37.boolean().default(false)
+  fast: z38.boolean().default(false)
 });
-var DocumentsOcrLine = z37.strictObject({
-  text: z37.string(),
+var DocumentsOcrLine = z38.strictObject({
+  text: z38.string(),
   /** 0–1; null where the engine does not say. */
-  confidence: z37.number().min(0).max(1).nullable()
+  confidence: z38.number().min(0).max(1).nullable()
 });
-var DocumentsOcrResult = z37.strictObject({
-  text: z37.string(),
-  lines: z37.array(DocumentsOcrLine),
-  truncated: z37.boolean(),
+var DocumentsOcrResult = z38.strictObject({
+  text: z38.string(),
+  lines: z38.array(DocumentsOcrLine),
+  truncated: z38.boolean(),
   /** Which engine read it ("vision" on macOS, "windows-ocr", "tesseract"). */
-  engine: z37.string()
+  engine: z38.string()
 });
-var DocumentsImageResizeParams = z37.strictObject({
+var DocumentsImageResizeParams = z38.strictObject({
   path: AbsPath,
   /** Where to write it; absent: next to the original, "<name>-resized.<ext>". */
   out_path: AbsPath.optional(),
   /** The longest side, kept in proportion; absent: the size stays (a format change only). */
-  max_size: z37.int().min(1).max(32768).optional(),
-  format: z37.enum(["png", "jpeg", "tiff", "heic", "bmp", "gif"]).optional(),
-  overwrite: z37.boolean().default(false)
+  max_size: z38.int().min(1).max(32768).optional(),
+  format: z38.enum(["png", "jpeg", "tiff", "heic", "bmp", "gif"]).optional(),
+  overwrite: z38.boolean().default(false)
 });
-var DocumentsImageResizeResult = z37.strictObject({
-  path: z37.string(),
+var DocumentsImageResizeResult = z38.strictObject({
+  path: z38.string(),
   width: nonNegInt,
   height: nonNegInt,
   bytes: nonNegInt
 });
-var DocumentsParagraph = z37.strictObject({
-  style: z37.enum(["title", "heading1", "heading2", "heading3", "body", "bullet", "numbered", "quote", "code"]).default("body"),
-  text: z37.string().max(1e5)
+var DocumentsParagraph = z38.strictObject({
+  style: z38.enum(["title", "heading1", "heading2", "heading3", "body", "bullet", "numbered", "quote", "code"]).default("body"),
+  text: z38.string().max(1e5)
 });
-var DocumentsSheet = z37.strictObject({
-  name: z37.string().min(1).max(31),
+var DocumentsSheet = z38.strictObject({
+  name: z38.string().min(1).max(31),
   /** Rows of cells; the first row is the header when `header` is true. */
-  rows: z37.array(z37.array(z37.union([z37.string().max(32767), z37.number(), z37.boolean(), z37.null()])).max(16384)).max(1e5),
-  header: z37.boolean().default(true)
+  rows: z38.array(z38.array(z38.union([z38.string().max(32767), z38.number(), z38.boolean(), z38.null()])).max(16384)).max(1e5),
+  header: z38.boolean().default(true)
 });
-var DocumentsOfficeGenerateParams = z37.strictObject({
-  kind: z37.enum(["docx", "xlsx"]),
+var DocumentsOfficeGenerateParams = z38.strictObject({
+  kind: z38.enum(["docx", "xlsx"]),
   path: AbsPath,
-  title: z37.string().max(1024).optional(),
+  title: z38.string().max(1024).optional(),
   /** docx: the document's paragraphs, in order. */
-  paragraphs: z37.array(DocumentsParagraph).max(5e4).optional(),
+  paragraphs: z38.array(DocumentsParagraph).max(5e4).optional(),
   /** xlsx: the workbook's sheets, in order. */
-  sheets: z37.array(DocumentsSheet).min(1).max(64).optional(),
-  overwrite: z37.boolean().default(false)
+  sheets: z38.array(DocumentsSheet).min(1).max(64).optional(),
+  overwrite: z38.boolean().default(false)
 });
-var DocumentsOfficeGenerateResult = z37.strictObject({ path: z37.string(), bytes: nonNegInt });
-var EntitiesNerParams = z37.strictObject({
-  text: z37.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
+var DocumentsOfficeGenerateResult = z38.strictObject({ path: z38.string(), bytes: nonNegInt });
+var EntitiesNerParams = z38.strictObject({
+  text: z38.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
   /** Which kinds to keep; absent: all three. */
-  labels: z37.array(z37.enum(["person", "place", "organization"])).min(1).max(3).optional()
+  labels: z38.array(z38.enum(["person", "place", "organization"])).min(1).max(3).optional()
 });
-var EntitySpan = z37.strictObject({
-  text: z37.string(),
-  label: z37.string(),
+var EntitySpan = z38.strictObject({
+  text: z38.string(),
+  label: z38.string(),
   /** Character offsets into the text (UTF-16, as JavaScript counts). */
   start: nonNegInt,
   end: nonNegInt
 });
-var EntitiesNerResult = z37.strictObject({ entities: z37.array(EntitySpan), engine: z37.string() });
-var PiiKind = z37.enum(["email", "phone", "credit_card", "us_ssn", "iban", "ip_address", "url", "api_key"]);
-var EntitiesPiiParams = z37.strictObject({
-  text: z37.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
-  kinds: z37.array(PiiKind).min(1).max(8).optional(),
+var EntitiesNerResult = z38.strictObject({ entities: z38.array(EntitySpan), engine: z38.string() });
+var PiiKind = z38.enum(["email", "phone", "credit_card", "us_ssn", "iban", "ip_address", "url", "api_key"]);
+var EntitiesPiiParams = z38.strictObject({
+  text: z38.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
+  kinds: z38.array(PiiKind).min(1).max(8).optional(),
   /** Also answer the text with each finding replaced by its kind ("[email]"). */
-  redact: z37.boolean().default(false)
+  redact: z38.boolean().default(false)
 });
-var EntitiesPiiResult = z37.strictObject({
-  findings: z37.array(z37.strictObject({ kind: PiiKind, text: z37.string(), start: nonNegInt, end: nonNegInt })),
-  redacted: z37.string().nullable()
+var EntitiesPiiResult = z38.strictObject({
+  findings: z38.array(z38.strictObject({ kind: PiiKind, text: z38.string(), start: nonNegInt, end: nonNegInt })),
+  redacted: z38.string().nullable()
 });
 
 // src/schema/registry.ts
@@ -3442,6 +3886,36 @@ var OPS = {
   "apps.windows.shown": { params: AppsWindowsShownParams, result: AppsWindowsShownResult, kind: "unary", since: "1.21", errors: ["NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   // Claude Code history (SPEC §6 coding): served by the `coding` Python service through SERVICES below.
   "coding.history.import_missing": { params: CodingHistoryImportMissingParams, result: CodingHistoryImportMissingResult, kind: "unary", since: "1.5", errors: ["RESOURCE_BUSY", "RESOURCE_GONE", "CANCELLED", "INTERNAL"] },
+  // Code from anywhere (1.38): the coding engine's sessions, read and driven over any transport.
+  "coding.providers": { params: CodingProvidersParams, result: CodingProvidersResult, kind: "unary", since: "1.38", errors: ["INTERNAL"] },
+  "coding.sessions.list": { params: CodingSessionsListParams, result: CodingSessionsListResult, kind: "unary", since: "1.38", errors: ["PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "coding.discover": { params: CodingDiscoverParams, result: CodingDiscoverResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "coding.runs.list": { params: CodingRunsListParams, result: CodingRunsListResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "INTERNAL"] },
+  "coding.history": { params: CodingHistoryParams, result: CodingHistoryResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "NOT_FOUND", "INTERNAL"] },
+  "coding.transcript.read": { params: CodingTranscriptReadParams, result: CodingTranscriptReadResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "NOT_FOUND", "INTERNAL"] },
+  "coding.item.full": { params: CodingItemFullParams, result: CodingItemFullResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "NOT_FOUND", "PAYLOAD_TOO_LARGE", "INTERNAL"] },
+  "coding.activity": { params: CodingActivityParams, result: CodingActivityResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "INTERNAL"] },
+  "coding.folders.recent": { params: CodingFoldersRecentParams, result: CodingFoldersRecentResult, kind: "unary", since: "1.38", errors: ["INTERNAL"] },
+  "coding.folders.check": { params: CodingFoldersCheckParams, result: CodingFoldersCheckResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "AUTH_FORBIDDEN", "INTERNAL"] },
+  "coding.folders.create": { params: CodingFoldersCreateParams, result: CodingFoldersCreateResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "AUTH_FORBIDDEN", "PERMISSION_DENIED_OS", "INTERNAL"] },
+  "coding.start": { params: CodingStartParams, result: CodingStartResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "NOT_FOUND", "AUTH_FORBIDDEN", "RATE_LIMITED", "INTERNAL"] },
+  "coding.takeover": { params: CodingTakeoverParams, result: CodingTakeoverResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "NOT_FOUND", "RESOURCE_BUSY", "AUTH_FORBIDDEN", "INTERNAL"] },
+  "coding.send": { params: CodingSendParams, result: CodingSendResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "NOT_FOUND", "RATE_LIMITED", "INTERNAL"] },
+  "coding.stop": { params: CodingStopParams, result: CodingStopResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "INTERNAL"] },
+  "coding.stop_elsewhere": { params: CodingStopElsewhereParams, result: CodingStopElsewhereResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "NOT_FOUND", "CONFLICT", "PERMISSION_DENIED_OS", "INTERNAL"] },
+  "coding.options.set": { params: CodingOptionsSetParams, result: CodingOptionsSetResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "NOT_FOUND", "INTERNAL"] },
+  "coding.agent.set": { params: CodingAgentSetParams, result: CodingAgentSetResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "NOT_FOUND", "AUTH_FORBIDDEN", "INTERNAL"] },
+  "coding.agents.access": { params: CodingAgentsAccessParams, result: CodingAgentsAccessResult, kind: "unary", since: "1.38", errors: ["INTERNAL"] },
+  "coding.titles.status": { params: CodingTitlesStatusParams, result: CodingTitlesStatusResult, kind: "unary", since: "1.38", errors: ["INTERNAL"] },
+  "coding.prefs.list": { params: CodingPrefsListParams, result: CodingPrefsListResult, kind: "unary", since: "1.38", errors: ["INTERNAL"] },
+  "coding.prefs.set": { params: CodingPrefsSetParams, result: CodingPrefsSetResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "INTERNAL"] },
+  "coding.recent.seen": { params: CodingRecentSeenParams, result: CodingRecentSeenResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "INTERNAL"] },
+  "coding.search": { params: CodingSearchParams, result: CodingSearchResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "TIMEOUT", "INTERNAL"] },
+  "coding.reconcile": { params: CodingReconcileParams, result: CodingReconcileResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS", "NOT_FOUND", "RESOURCE_BUSY", "CANCELLED", "INTERNAL"] },
+  "coding.transcript.raw": { params: CodingTranscriptRawParams, result: CodingTranscriptRawResult, kind: "stream", since: "1.38", errors: ["INVALID_PARAMS", "NOT_FOUND", "CANCELLED", "INTERNAL"] },
+  "coding.watch": { params: CodingWatchParams, result: CodingWatchResult, kind: "resource", since: "1.38", errors: ["PLATFORM_UNSUPPORTED", "RATE_LIMITED", "INTERNAL"] },
+  "coding.session.watch": { params: CodingSessionWatchParams, result: CodingSessionWatchResult, kind: "resource", since: "1.38", errors: ["INVALID_PARAMS", "NOT_FOUND", "RATE_LIMITED", "INTERNAL"] },
+  "session.identify": { params: SessionIdentifyParams, result: SessionIdentifyResult, kind: "unary", since: "1.38", errors: ["INVALID_PARAMS"] },
   // 1.22: git for agents (core `git`, the system git; the cloud sandbox's /git/* set, SPEC 6.1).
   "git.status": { params: GitStatusParams, result: GitStatusResult, kind: "unary", since: "1.22", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
   "git.diff": { params: GitDiffParams, result: GitDiffResult, kind: "unary", since: "1.22", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
@@ -3462,6 +3936,10 @@ var OPS = {
   "account.agents.list": { params: AccountAgentsListParams, result: AccountAgentsListResult, kind: "unary", since: "1.23", errors: ["INTERNAL"] },
   "account.vault.list": { params: AccountVaultListParams, result: AccountVaultListResult, kind: "unary", since: "1.23", errors: ["INTERNAL"] },
   "account.vault.copy": { params: AccountVaultCopyParams, result: AccountVaultCopyResult, kind: "unary", since: "1.23", errors: ["AUTH_REQUIRED", "AUTH_FORBIDDEN", "NOT_FOUND", "INVALID_PARAMS", "DEVICE_OFFLINE", "INTERNAL"] },
+  // 1.39: one agent opened (its inputs and what it uses), its runs (mandate.run_history, one agent at a time) and its star.
+  "account.agents.get": { params: AccountAgentsGetParams, result: AccountAgentsGetResult, kind: "unary", since: "1.39", errors: ["INVALID_PARAMS", "INTERNAL"] },
+  "account.agents.runs": { params: AccountAgentsRunsParams, result: AccountAgentsRunsResult, kind: "unary", since: "1.39", errors: ["INVALID_PARAMS", "INTERNAL"] },
+  "account.agents.favorite": { params: AccountAgentsFavoriteParams, result: AccountAgentsFavoriteResult, kind: "unary", since: "1.39", errors: ["AUTH_REQUIRED", "NOT_FOUND", "INVALID_PARAMS", "DEVICE_OFFLINE", "INTERNAL"] },
   // 1.26: the app's own update (it installs only once every window quit) and bringing the windows back.
   "apps.windows.update_state": { params: AppsWindowsUpdateStateParams, result: AppsWindowsUpdateStateResult, kind: "unary", since: "1.26", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "apps.windows.reopen": { params: AppsWindowsReopenParams, result: AppsWindowsReopenResult, kind: "unary", since: "1.26", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
@@ -3535,6 +4013,10 @@ var EVENTS = {
   "session.control_changed": SessionControlChangedEvent,
   "models.progress": ModelsProgressEvent,
   "coding.history.progress": CodingHistoryProgressEvent,
+  "coding.changed": CodingChangedEvent,
+  "coding.watch_state": CodingWatchStateEvent,
+  "coding.item": CodingItemEvent,
+  "coding.gap": CodingGapEvent,
   "relay.device_status": RelayDeviceStatusEvent,
   "relay.auth_expiring": RelayAuthExpiringEvent,
   "diag.errors.changed": DiagErrorsChangedEvent,
@@ -3543,6 +4025,42 @@ var EVENTS = {
   "browser.progress": BrowserProgressEvent
 };
 
+// src/versioning.ts
+function compareVersions(a, b) {
+  const [am = 0, an = 0] = a.split(".").map(Number);
+  const [bm = 0, bn = 0] = b.split(".").map(Number);
+  return am - bm || an - bn;
+}
+function knows(version, since) {
+  return compareVersions(version, since) >= 0;
+}
+var RESULT_PATH = /* @__PURE__ */ new Map([
+  ["fs.patch", "FsPatchResult"],
+  ["apps.chats.list", "AppsChatsListResult"],
+  ["apps.accounts.usage", "AppsAccountsUsageResult"],
+  ["apps.accounts.resets", "AppsAccountsResetsResult"],
+  ["apps.windows.update_state", "AppsWindowsUpdateStateResult"]
+]);
+var NESTED_RESULTS = /* @__PURE__ */ new Map([
+  ["apps.chats.list", [["chats", "ChatRow"]]],
+  ["apps.projects.file", [["chat", "ChatRow"]]],
+  ["apps.projects.file_many", [["chats", "ChatRow"]]],
+  ["apps.projects.unfile", [["chat", "ChatRow"]]],
+  ["apps.projects.move", [["chat", "ChatRow"]]],
+  ["apps.chats.star", [["chat", "ChatRow"]]],
+  ["apps.chats.place", [["chat", "ChatRow"]]],
+  ["apps.accounts.usage", [["accounts", "AccountUsage"]]],
+  ["resources.snapshot", [["disks", "ResourcesDisk"]]],
+  ["stack.state", [["servers", "StackServer"]]],
+  ["account.agents.list", [["agents", "AccountAgent"]]]
+]);
+var WINDOW_RESULTS = /* @__PURE__ */ new Map([
+  ["window.list", "windows"],
+  ["window.focus", "window"],
+  ["window.move", "window"]
+]);
+var VERSIONED_RESULT_OPS = [.../* @__PURE__ */ new Set([...RESULT_PATH.keys(), ...WINDOW_RESULTS.keys(), ...NESTED_RESULTS.keys()])];
+
 // src/client/client.ts
 var WS_OPEN = 1;
 var defaultTimers = {
@@ -3891,6 +4409,11 @@ function createDesktopClient(options) {
     backoff.markConnected();
     authRefusals = 0;
     setState({ status: "open", welcome: welcome.data, attempts: 0, retryInMs: null, lastError: null, outcome: null });
+    if (options.clientLabel && knows(welcome.data.protocol_version, "1.38")) {
+      void request("session.identify", { label: options.clientLabel.slice(0, 60) }).catch(
+        (error) => diagnose({ kind: "handler_threw", where: "session.identify", error })
+      );
+    }
     for (const w of [...readyWaiters]) {
       readyWaiters.delete(w);
       w.resolve(welcome.data);